hexapdf 0.1.0

data/data/hexapdf/encoding/zapfdingbats.txt

@@ -0,0 +1,225 @@
+# -----------------------------------------------------------
+# Copyright 2002, 2010, 2015 Adobe Systems Incorporated.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License. You may
+# obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0.html
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+# -----------------------------------------------------------
+# Name:          ITC Zapf Dingbats Glyph List
+# Table version: 2.0
+# Date:          September 20, 2002
+# URL:           https://github.com/adobe-type-tools/agl-aglfn
+#
+# Format: two semicolon-delimited fields:
+#   (1) glyph name--upper/lowercase letters and digits
+#   (2) Unicode scalar value--four uppercase hexadecimal digits
+#
+a100;275E
+a101;2761
+a102;2762
+a103;2763
+a104;2764
+a105;2710
+a106;2765
+a107;2766
+a108;2767
+a109;2660
+a10;2721
+a110;2665
+a111;2666
+a112;2663
+a117;2709
+a118;2708
+a119;2707
+a11;261B
+a120;2460
+a121;2461
+a122;2462
+a123;2463
+a124;2464
+a125;2465
+a126;2466
+a127;2467
+a128;2468
+a129;2469
+a12;261E
+a130;2776
+a131;2777
+a132;2778
+a133;2779
+a134;277A
+a135;277B
+a136;277C
+a137;277D
+a138;277E
+a139;277F
+a13;270C
+a140;2780
+a141;2781
+a142;2782
+a143;2783
+a144;2784
+a145;2785
+a146;2786
+a147;2787
+a148;2788
+a149;2789
+a14;270D
+a150;278A
+a151;278B
+a152;278C
+a153;278D
+a154;278E
+a155;278F
+a156;2790
+a157;2791
+a158;2792
+a159;2793
+a15;270E
+a160;2794
+a161;2192
+a162;27A3
+a163;2194
+a164;2195
+a165;2799
+a166;279B
+a167;279C
+a168;279D
+a169;279E
+a16;270F
+a170;279F
+a171;27A0
+a172;27A1
+a173;27A2
+a174;27A4
+a175;27A5
+a176;27A6
+a177;27A7
+a178;27A8
+a179;27A9
+a17;2711
+a180;27AB
+a181;27AD
+a182;27AF
+a183;27B2
+a184;27B3
+a185;27B5
+a186;27B8
+a187;27BA
+a188;27BB
+a189;27BC
+a18;2712
+a190;27BD
+a191;27BE
+a192;279A
+a193;27AA
+a194;27B6
+a195;27B9
+a196;2798
+a197;27B4
+a198;27B7
+a199;27AC
+a19;2713
+a1;2701
+a200;27AE
+a201;27B1
+a202;2703
+a203;2750
+a204;2752
+a205;276E
+a206;2770
+a20;2714
+a21;2715
+a22;2716
+a23;2717
+a24;2718
+a25;2719
+a26;271A
+a27;271B
+a28;271C
+a29;2722
+a2;2702
+a30;2723
+a31;2724
+a32;2725
+a33;2726
+a34;2727
+a35;2605
+a36;2729
+a37;272A
+a38;272B
+a39;272C
+a3;2704
+a40;272D
+a41;272E
+a42;272F
+a43;2730
+a44;2731
+a45;2732
+a46;2733
+a47;2734
+a48;2735
+a49;2736
+a4;260E
+a50;2737
+a51;2738
+a52;2739
+a53;273A
+a54;273B
+a55;273C
+a56;273D
+a57;273E
+a58;273F
+a59;2740
+a5;2706
+a60;2741
+a61;2742
+a62;2743
+a63;2744
+a64;2745
+a65;2746
+a66;2747
+a67;2748
+a68;2749
+a69;274A
+a6;271D
+a70;274B
+a71;25CF
+a72;274D
+a73;25A0
+a74;274F
+a75;2751
+a76;25B2
+a77;25BC
+a78;25C6
+a79;2756
+a7;271E
+a81;25D7
+a82;2758
+a83;2759
+a84;275A
+a85;276F
+a86;2771
+a87;2772
+a88;2773
+a89;2768
+a8;271F
+a90;2769
+a91;276C
+a92;276D
+a93;276A
+a94;276B
+a95;2774
+a96;2775
+a97;275B
+a98;275C
+a99;275D
+a9;2720
+#END

data/examples/arc.rb

@@ -0,0 +1,50 @@
+# ## Arcs and Solid Arcs
+#
+# This example shows how to use the graphic objects `:arc` and `:solid_arc` to
+# draw simple pie charts.
+#
+# Usage:
+# : `ruby arc.rb`
+#
+
+require 'hexapdf'
+
+doc = HexaPDF::Document.new
+page = doc.pages.add_page
+canvas = page.canvas
+
+radius = 75
+
+# Left pie chart
+center = [page.box.width * 0.25, page.box.height * 0.85]
+pie = canvas.graphic_object(:solid_arc, cx: center[0], cy: center[1], 
+                            outer_a: radius, outer_b: radius)
+canvas.fill_color('ddddff')
+canvas.draw(pie, start_angle: 30, end_angle: 110).fill
+canvas.fill_color('ffdddd')
+canvas.draw(pie, start_angle: 110, end_angle: 130).fill
+canvas.fill_color('ddffdd')
+canvas.draw(pie, start_angle: 130, end_angle: 30).fill
+
+arc = canvas.graphic_object(:arc, cx: center[0], cy: center[1], 
+                            a: radius, b: radius)
+canvas.stroke_color('0000ff')
+canvas.draw(arc, start_angle: 30, end_angle: 110).stroke
+canvas.stroke_color('ff0000')
+canvas.draw(arc, start_angle: 110, end_angle: 130).stroke
+canvas.stroke_color('00ff00')
+canvas.draw(arc, start_angle: 130, end_angle: 30).stroke
+
+# Right pie chart
+center = [page.box.width * 0.75, page.box.height * 0.85]
+canvas.stroke_color('777777')
+pie = canvas.graphic_object(:solid_arc, cx: center[0], cy: center[1], 
+                            outer_a: radius, outer_b: radius)
+canvas.fill_color('ddddff')
+canvas.draw(pie, start_angle: 30, end_angle: 110).fill_stroke
+canvas.fill_color('ffdddd')
+canvas.draw(pie, start_angle: 110, end_angle: 130).fill_stroke
+canvas.fill_color('ddffdd')
+canvas.draw(pie, start_angle: 130, end_angle: 30).fill_stroke
+
+doc.write('arc.pdf', optimize: true)

data/examples/graphics.rb

@@ -0,0 +1,274 @@
+# ## Graphics Primitives
+#
+# This example shows many of the operations that the canvas implementation
+# allows.
+#
+# Note that the PDF canvas has its origin in the lower left corner of the page.
+# This means the coordinate (100, 50) is 100 PDF points from the left side and
+# 50 PDF points from the bottom. One PDF point is equal to 1/72 inch.
+#
+# Usage:
+# : `ruby graphics.rb`
+#
+
+require 'hexapdf'
+
+doc = HexaPDF::Document.new
+page = doc.pages.add_page
+canvas = page.canvas
+
+# Draws the shape that is used to showcase the transformations in the given
+# color.
+def transformation_shape(canvas, *color)
+  canvas.stroke_color(*color)
+  canvas.polygon(0, 0, 0, 80, 30, 50, 60, 80, 60, 0, 30, 30)
+  canvas.line(-30, 0, 30, 0)
+  canvas.line(0, 30, 0, -30)
+  canvas.stroke
+end
+
+# Basic transformations: translate, scale, rotate, skew
+canvas.translate(0, 710) do
+  normal_color = [0.7, 0.7, 0.3]
+  transformed_color = [0.3, 0.7, 0.7]
+
+  canvas.translate(50, 0) do
+    transformation_shape(canvas, normal_color)
+    canvas.translate(40, 40) { transformation_shape(canvas, transformed_color) }
+  end
+
+  canvas.translate(180, 0) do
+    transformation_shape(canvas, normal_color)
+    canvas.scale(1.7, 1.3) { transformation_shape(canvas, transformed_color) }
+  end
+
+  canvas.translate(330, 0) do
+    transformation_shape(canvas, normal_color)
+    canvas.rotate(30) { transformation_shape(canvas, transformed_color) }
+  end
+
+  canvas.translate(430, 0) do
+    transformation_shape(canvas, normal_color)
+    canvas.skew(15, 30) { transformation_shape(canvas, transformed_color) }
+  end
+end
+
+# Draws a thin white line over a thick black line.
+def dual_lines(canvas)
+  canvas.stroke_color(0)
+  canvas.line_width = 15
+  yield
+  canvas.stroke
+  canvas.stroke_color(1.0)
+  canvas.line_width = 1
+  yield
+  canvas.stroke
+end
+
+# Graphics state: line width, line cap style, line join style, miter limit,
+# line dash pattern
+canvas.translate(0, 550) do
+  canvas.translate(50, 0) do
+    [1, 5, 10, 15].each_with_index do |i, index|
+      canvas.stroke_color(0)
+      canvas.line_width(i)
+      canvas.line(20 * index, 0, 20 * index, 100)
+      canvas.stroke
+    end
+  end
+
+  canvas.translate(150, 0) do
+    0.upto(2) do |i|
+      canvas.line_cap_style = i
+      dual_lines(canvas) { canvas.line(20 * i, 0, 20 * i, 100) }
+    end
+  end
+
+  canvas.translate(230, 0) do
+    0.upto(2) do |i|
+      canvas.line_join_style = i
+      dual_lines(canvas) { canvas.polyline(0, 30 * i, 40, 50 + 30 * i, 80, 30 * i) }
+    end
+  end
+
+  canvas.translate(350, 0) do
+    canvas.line_join_style = :miter
+    canvas.miter_limit = 1
+    dual_lines(canvas) { canvas.polyline(0, 0, 20, 80, 40, 0) }
+    canvas.miter_limit = 10
+    dual_lines(canvas) { canvas.polyline(60, 0, 80, 80, 100, 0) }
+  end
+
+  canvas.translate(490, 0) do
+    canvas.line_width(1)
+    [[[1, 1]],
+     [[3, 1]], 
+     [[3, 3]], 
+     [[5, 1, 1, 1, 1, 1]], 
+     [[3, 5], 6]].each_with_index do |(value, phase), index|
+      canvas.line_dash_pattern(value, phase || 0)
+      canvas.line(20 * index, 0, 20 * index, 100)
+      canvas.stroke
+    end
+  end
+end
+
+# Basic shapes: line, polyline, (rounded) rectangle, (rounded) polygon, circle, ellipse
+canvas.translate(0, 420) do
+  canvas.line(50, 0, 50, 100)
+  canvas.polyline(80, 0, 80, 20, 70, 30, 90, 40, 70, 50, 90, 60, 70, 70, 80, 80, 80, 100)
+  canvas.rectangle(110, 0, 50, 100)
+  canvas.rectangle(180, 0, 50, 100, radius: 20)
+  canvas.polygon(250, 0, 250, 100, 280, 70, 310, 100, 310, 0, 280, 30)
+  canvas.polygon(330, 0, 330, 100, 360, 70, 390, 100, 390, 0, 360, 30, radius: 20)
+  canvas.circle(440, 50, 30)
+  canvas.ellipse(520, 50, a: 30, b: 15, inclination: 45)
+  canvas.stroke
+end
+
+# Various arcs w/wo filling, using the Canvas#arc method as well as directly
+# working with the arc objects
+canvas.translate(0, 320) do
+  canvas.arc(50, 50, a: 10, start_angle: -60, end_angle: 115)
+  canvas.arc(100, 50, a: 40, b: 20, start_angle: -60, end_angle: 115)
+  canvas.arc(180, 50, a: 40, b: 20, start_angle: -60, end_angle: 115, inclination: 45)
+  canvas.stroke
+
+  canvas.fill_color(0.4, 0.3, 0.4)
+  canvas.arc(250, 50, a: 10, start_angle: -60, end_angle: 115)
+  canvas.arc(300, 50, a: 40, b: 20, start_angle: -60, end_angle: 115)
+  canvas.arc(380, 50, a: 40, b: 20, start_angle: -60, end_angle: 115, inclination: 45)
+  canvas.fill
+
+  arc = canvas.graphic_object(:arc, cx: 450, cy: 50, a: 30, b: 30, 
+                              start_angle: -30, end_angle: 105)
+  canvas.fill_color(0.4, 0.3, 0.4)
+  canvas.move_to(450, 50)
+  canvas.line_to(*arc.start_point)
+  arc.curves.each {|c| canvas.curve_to(*c)}
+  canvas.fill
+  arc.configure(start_angle: 105, end_angle: -30)
+  canvas.fill_color(0.3, 0.7, 0.7)
+  canvas.move_to(450, 50)
+  canvas.line_to(*arc.start_point)
+  arc.curves.each {|c| canvas.curve_to(*c)}
+  canvas.fill
+
+  arc = canvas.graphic_object(:arc, cx: 530, cy: 50, a: 40, b: 20,
+                              start_angle: -30, end_angle: 105)
+  canvas.fill_color(0.4, 0.3, 0.4)
+  canvas.move_to(530, 50)
+  canvas.line_to(*arc.start_point)
+  arc.curves.each {|c| canvas.curve_to(*c)}
+  canvas.fill
+  arc.configure(start_angle: 105, end_angle: -30)
+  canvas.fill_color(0.7, 0.7, 0.3)
+  canvas.move_to(530, 50)
+  canvas.line_to(*arc.start_point)
+  arc.curves.each {|c| canvas.curve_to(*c)}
+  canvas.fill
+end
+
+# Draws a circle and two half circles inside with different directions.
+def shapes_to_paint(canvas)
+  canvas.line_width = 2
+  canvas.arc(50, 50, a: 50)
+  canvas.arc(50, 60, a: 25, end_angle: 180, clockwise: false)
+  canvas.arc(50, 40, a: 25, end_angle: 180, clockwise: true)
+end
+
+# Draws arrows showing the direction of the #shapes_to_paint
+def arrows(canvas)
+  canvas.line_width = 1
+  canvas.polyline(95, 45, 100, 50, 105, 45)
+  canvas.polyline(55, 105, 50, 100, 55, 95)
+  canvas.polyline(-5, 55, 0, 50, 5, 55)
+  canvas.polyline(45, 5, 50, 0, 45, -5)
+  canvas.polyline(55, 90, 50, 85, 55, 80)
+  canvas.polyline(55, 20, 50, 15, 55, 10)
+  canvas.stroke
+end
+
+# Path painting and clipping operations: stroke, close and stroke, fill nonzero,
+# fill even-odd, fill nonzero and stroke, fill even-odd and stroke, close and
+# fill nonzero and stroke, close fill even-odd and stroke, clip even-odd, clip
+# nonzero
+canvas.translate(0, 190) do
+  canvas.fill_color(0.3, 0.7, 0.7)
+
+  [[:stroke], [:close_stroke], [:fill, :nonzero], [:fill, :even_odd],
+   [:fill_stroke, :nonzero], [:fill_stroke, :even_odd],
+   [:close_fill_stroke, :nonzero], [:close_fill_stroke, :even_odd],
+   ].each_with_index do |op, index|
+    row = (1 - (index / 4))
+    column = index % 4
+    x = 50 + 80 * column
+    y = 80 * row
+    canvas.transform(0.6, 0, 0, 0.6, x, y) do
+      shapes_to_paint(canvas)
+      canvas.send(*op)
+      arrows(canvas)
+    end
+  end
+
+  canvas.fill_color(0.7, 0.7, 0.3)
+
+  [:even_odd, :nonzero].each_with_index do |op, index|
+    canvas.translate(370 + 110 * index, 20) do
+      canvas.circle(50, 50, 50)
+      canvas.circle(50, 50, 20)
+      canvas.clip_path(op)
+      canvas.end_path
+      canvas.rectangle(0, 0, 100, 100, radius: 100)
+      canvas.fill_stroke
+    end
+  end
+end
+
+# Some composite shapes, an image and a form XObject
+canvas.translate(0, 80) do
+  canvas.fill_color(0.3, 0.7, 0.7)
+  canvas.rectangle(50, 0, 80, 80, radius: 80)
+  canvas.fill
+
+  solid = canvas.graphic_object(:solid_arc, cx: 190, cy: 40, inner_a: 20, inner_b: 15,
+                                outer_a: 40, outer_b: 30, start_angle: 10, end_angle: 130)
+
+  canvas.line_width(0.5)
+  canvas.opacity(fill_alpha: 0.5, stroke_alpha: 0.2) do
+    canvas.fill_color('AA8888').draw(solid).fill_stroke
+    canvas.fill_color('88AA88').draw(solid, start_angle: 130, end_angle: 220).fill_stroke
+    canvas.fill_color('8888AA').draw(solid, start_angle: 220, end_angle: 10).fill_stroke
+
+    solid.configure(inner_a: 0, inner_b: 0, outer_a: 40, outer_b: 40, cx: 290)
+    canvas.fill_color('AA8888').draw(solid, start_angle: 10, end_angle: 130).fill_stroke
+    canvas.fill_color('88AA88').draw(solid, start_angle: 130, end_angle: 220).fill_stroke
+    canvas.fill_color('8888AA').draw(solid, start_angle: 220, end_angle: 10).fill_stroke
+
+    canvas.image(File.join(__dir__, 'machupicchu.jpg'), at: [350, 0], height: 80)
+  end
+end
+
+# Reusing the already draw graphics for an XObject
+# Note that converting the page to a form XObject automatically closes all open
+# graphics states, therefore this can't be inside the above Canvas#translate
+# call
+form = doc.add(page.to_form_xobject(reference: false))
+canvas.rectangle(480, 80, form.box.width * (100 / form.box.height.to_f), 100).stroke
+canvas.xobject(form, at: [480, 80], height: 100)
+
+# A simple rainbow color band
+canvas.translate(0, 20) do
+  canvas.line_width = 10
+  freq = 0.3
+  0.upto(50) do |i|
+    r = Math.sin(freq * i) * 127 + 128
+    g = Math.sin(freq * i + 2) * 127 + 128
+    b = Math.sin(freq * i + 4) * 127 + 128
+    canvas.stroke_color(r.to_i, g.to_i, b.to_i)
+    canvas.line(50 + i * 10, 0, 50 + i * 10, 40)
+    canvas.stroke
+  end
+end
+
+doc.write('graphics.pdf', optimize: true)

data/examples/hello_world.rb

@@ -0,0 +1,16 @@
+# ## Hello World
+#
+# This simple example mimics the classic "hello world" examples from
+# programming languages.
+#
+# Usage:
+# : `ruby hello_world.rb`
+#
+
+require 'hexapdf'
+
+doc = HexaPDF::Document.new
+canvas = doc.pages.add_page.canvas
+canvas.font('Helvetica', size: 100)
+canvas.text("Hello World!", at: [20, 400])
+doc.write("hello_world.pdf", optimize: true)

data/examples/merging.rb

@@ -0,0 +1,24 @@
+# ## Merging PDF Files
+#
+# Merging of PDF files can be done in various ways of sophistication.
+#
+# The easiest way, which this example shows, just imports the pages of
+# the source files into the target file. This preserves the page
+# contents themselves but nothing else.
+#
+# For example, named destinations are not properly handled by the code.
+# Sometimes other things like attached files or a document outline
+# should also be preserved.
+#
+# Usage:
+# : `ruby merging.rb INPUT1.PDF INPUT2.PDF ...`
+#
+
+require 'hexapdf'
+
+target = HexaPDF::Document.new
+ARGV.each do |file|
+  pdf = HexaPDF::Document.open(file)
+  pdf.pages.each_page {|page| target.pages.add_page(target.import(page))}
+end
+target.write("merging.pdf", optimize: true)

data/examples/optimizing.rb

@@ -0,0 +1,20 @@
+# ## Optimizing a PDF File
+#
+# This example shows how to read a PDF file, optimize it and write it
+# out again.
+#
+# The heavy work is done by the `:optimize` task which allows control
+# over which aspects should be optimized. See [HexaPDF::Task::Optimize]
+# for detailed information.
+#
+# Usage:
+# : `ruby optimizing.rb INPUT.PDF`
+#
+
+require 'hexapdf'
+
+HexaPDF::Document.open(ARGV.shift) do |doc|
+  doc.task(:optimize, compact: true, object_streams: :generate,
+           compress_pages: false)
+  doc.write('optimizing.pdf')
+end

data/examples/show_char_bboxes.rb

@@ -0,0 +1,55 @@
+# ## Show Character Bounding Boxes
+#
+# This examples shows how to process the contents of a page. It finds all
+# characters on a page and surrounds them with their bounding box. Additionally,
+# all consecutive text runs are also surrounded by box.
+#
+# The code provides two ways of generating the boxes. The commented part of
+# `ShowTextProcessor#show_text` uses a polyline since some characters may be
+# transforemd (rotated or skewed). The un-commented part uses rectangles which
+# is faster and correct in most cases.
+#
+# Usage:
+# : `ruby show_char_boxes.rb INPUT.PDF`
+#
+
+require 'hexapdf'
+
+class ShowTextProcessor < HexaPDF::Content::Processor
+
+  def initialize(page)
+    super()
+    @canvas = page.canvas(type: :overlay)
+  end
+
+  def show_text(str)
+    boxes = decode_text_with_positioning(str)
+    return if boxes.string.empty?
+
+    @canvas.line_width = 1
+    @canvas.stroke_color(224, 0, 0)
+    # Polyline for transformed characters
+    #boxes.each {|box| @canvas.polyline(*box.points).close_subpath.stroke}
+    # Using rectangles is faster but not 100% correct
+    boxes.each do |box|
+      x, y = *box.lower_left
+      tx, ty = *box.upper_right
+      @canvas.rectangle(x, y, tx - x, ty - y).stroke
+    end
+
+    @canvas.line_width = 0.5
+    @canvas.stroke_color(0, 224, 0)
+    @canvas.polyline(*boxes.lower_left, *boxes.lower_right,
+                     *boxes.upper_right, *boxes.upper_left).close_subpath.stroke
+  end
+  alias :show_text_with_positioning :show_text
+
+end
+
+doc = HexaPDF::Document.open(ARGV.shift)
+doc.pages.each_page.with_index do |page, index|
+  puts "Processing page #{index + 1}"
+  processor = ShowTextProcessor.new(page)
+  page.process_contents(processor)
+end
+doc.write('show_char_boxes.pdf', optimize: true)