arena_barby 0.3.2

data/lib/barby/barcode/pdf_417.rb

@@ -0,0 +1,76 @@
+require 'barby/barcode'
+require 'java'
+require 'Pdf417lib'
+import 'Pdf417lib'
+
+module Barby
+  class Pdf417 < Barcode2D
+    DEFAULT_OPTIONS = {
+      :options       => 0,
+      :y_height      => 3,
+      :aspect_ratio  => 0.5, 
+      :error_level   => 0,
+      :len_codewords => 0,
+      :code_rows     => 0,
+      :code_columns  => 0
+    }
+
+    # Creates a new Pdf417 barcode. The +options+ argument
+    # can use the same keys as DEFAULT_OPTIONS. Please consult
+    # the source code of Pdf417lib.java for details about values
+    # that can be used.
+    def initialize(data, options={})
+      @pdf417 = Java::Pdf417lib.new
+      self.data = data
+      DEFAULT_OPTIONS.merge(options).each{|k,v| send("#{k}=", v) }
+    end
+
+    def options=(options)
+      @options = options
+    end
+
+    def y_height=(y_height)
+      @pdf417.setYHeight(y_height)
+    end
+
+    def aspect_ratio=(aspect_ratio)
+      @pdf417.setAspectRatio(aspect_ratio)
+    end
+
+    def error_level=(error_level)
+      @pdf417.setErrorLevel(error_level)
+    end
+
+    def len_codewords=(len_codewords)
+      @pdf417.setLenCodewords(len_codewords)
+    end
+
+    def code_rows=(code_rows)
+      @pdf417.setCodeRows(code_rows)
+    end
+
+    def code_columns=(code_columns)
+      @pdf417.setCodeColumns(code_columns)
+    end
+
+    def data=(data)
+      @pdf417.setText(data)
+    end
+
+    def encoding
+      @pdf417.paintCode()
+
+      cols = (@pdf417.getBitColumns() - 1) / 8 + 1
+      enc = []
+      row = nil
+      @pdf417.getOutBits.each_with_index do |byte, n|
+        if n%cols == 0
+          row = ""
+          enc << row
+        end
+        row << sprintf("%08b", (byte & 0xff) | 0x100)
+      end
+      enc
+    end
+  end
+end

data/lib/barby/barcode/qr_code.rb

@@ -0,0 +1,101 @@
+require 'rqrcode'
+require 'barby/barcode'
+
+module Barby
+
+
+  #QrCode is a thin wrapper around the RQRCode library
+  class QrCode < Barcode2D
+
+    #Maximum sizes for each correction level for binary data
+    #It's an array
+    SIZES = {
+            #L   M   Q   H
+      1  => [17, 14, 11, 7],          2  => [32, 26, 20, 14],
+      3  => [53, 42, 32, 24],         4  => [78, 62, 46, 34],
+      5  => [106, 84, 60, 44],        6  => [134, 106, 74, 58],
+      7  => [154, 122, 86, 64],       8  => [192, 152, 108, 84],
+      9  => [230, 180, 130, 98],      10 => [271, 213, 151, 119],
+      11 => [321, 251, 177, 137],     12 => [367, 287, 203, 155],
+      13 => [425, 331, 241, 177],     14 => [458, 362, 258, 194],
+      15 => [520, 412, 292, 220],     16 => [586, 450, 322, 250],
+      17 => [644, 504, 364, 280],     18 => [718, 560, 394, 310],
+      19 => [792, 624, 442, 338],     20 => [858, 666, 482, 382],
+      21 => [929, 711, 509, 403],     22 => [1003, 779, 565, 439],
+      23 => [1091, 857, 611, 461],    24 => [1171, 911, 661, 511],
+      25 => [1273, 997, 715, 535],    26 => [1367, 1059, 751, 593],
+      27 => [1465, 1125, 805, 625],   28 => [1528, 1190, 868, 658],
+      29 => [1628, 1264, 908, 698],   30 => [1732, 1370, 982, 742],
+      31 => [1840, 1452, 1030, 790],  32 => [1952, 1538, 1112, 842],
+      33 => [2068, 1628, 1168, 898],  34 => [2188, 1722, 1228, 958],
+      35 => [2303, 1809, 1283, 983],  36 => [2431, 1911, 1351, 1051],
+      37 => [2563, 1989, 1423, 1093], 38 => [2699, 2099, 1499, 1139],
+      39 => [2809, 2213, 1579, 1219], 40 => [2953, 2331, 1663, 1273]
+    }.sort
+
+    LEVELS = { :l => 0, :m => 1, :q => 2, :h => 3 }
+
+    attr_reader :data
+    attr_writer :level, :size
+
+
+    def initialize(data, options={})
+      self.data = data
+      options.each{|k,v| send("#{k}=", v) }
+      raise(ArgumentError, "data too large") unless size
+    end
+
+
+    def data=(data)
+      @data = data
+    end
+
+
+    def encoding
+      rqrcode.modules.map{|r| r.inject(''){|s,m| s << (m ? '1' : '0') } }
+    end
+
+
+    #Error correction level
+    #Can be one of [:l, :m, :q, :h] (7%, 15%, 25%, 30%)
+    def level
+      @level || :l
+    end
+
+
+    def size
+      #@size is only used for manual override, if it's not set
+      #manually the size is always dynamic, calculated from the
+      #length of the data
+      return @size if @size
+
+      level_index = LEVELS[level]
+      length = data.length
+      found_size = nil
+      SIZES.each do |size,max_values|
+        if max_values[level_index] >= length
+          found_size = size
+          break
+        end
+      end
+      found_size
+    end
+
+
+    def to_s
+      data[0,20]
+    end
+
+
+  private
+  
+    #Generate an RQRCode object with the available values
+    def rqrcode
+      RQRCode::QRCode.new(data, :level => level, :size => size)
+    end
+
+
+  end
+
+
+end

data/lib/barby/outputter.rb

@@ -0,0 +1,127 @@
+require 'barby/barcode'
+
+module Barby
+
+
+  #An Outputter creates something from a barcode. That something can be
+  #anything, but is most likely a graphical representation of the barcode.
+  #Outputters can register methods on barcodes that will be associated with
+  #them.
+  #
+  #The basic structure of an outputter class:
+  #
+  #  class FooOutputter < Barby::Outputter
+  #    register :to_foo
+  #    def to_too
+  #      do_something_with(barcode.encoding)
+  #    end
+  #  end
+  #
+  #Barcode#to_foo will now be available to all barcodes
+  class Outputter
+
+    attr_accessor :barcode
+
+
+    #An outputter instance will have access to a Barcode
+    def initialize(barcode)
+      self.barcode = barcode
+    end
+
+  
+    #Register one or more handler methods with this outputter
+    #Barcodes will then be able to use these methods to get the output
+    #from the outputter. For example, if you have an ImageOutputter,
+    #you could do:
+    #
+    #register :to_png, :to_gif
+    #
+    #You could then do aBarcode.to_png and get the result of that method.
+    #The class which registers the method will receive the barcode as the only
+    #argument, and the default implementation of initialize puts that into
+    #the +barcode+ accessor.
+    #
+    #You can also have different method names on the barcode and the outputter
+    #by providing a hash:
+    #
+    #register :to_png => :create_png, :to_gif => :create_gif
+    def self.register(*method_names)
+      if method_names.first.is_a? Hash
+        method_names.first.each do |name, method_name|
+          Barcode.register_outputter(name, self, method_name)
+        end
+      else
+        method_names.each do |name|
+          Barcode.register_outputter(name, self, name)
+        end
+      end
+    end
+
+
+  private
+
+    #Converts the barcode's encoding (a string containing 1s and 0s)
+    #to true and false values (1 == true == "black bar")
+    #
+    #If the barcode is 2D, each line will be converted to an array
+    #in the same way
+    def booleans(reload=false)#:doc:
+      if barcode.two_dimensional?
+        encoding(reload).map{|l| l.split(//).map{|c| c == '1' } }
+      else
+        encoding(reload).split(//).map{|c| c == '1' }
+      end
+    end
+
+
+    #Returns the barcode's encoding. The encoding
+    #is cached and can be reloaded by passing true
+    def encoding(reload=false)#:doc:
+      @encoding = barcode.encoding if reload
+      @encoding ||= barcode.encoding
+    end
+
+
+    #Collects continuous groups of bars and spaces (1 and 0)
+    #into arrays where the first item is true or false (1 or 0)
+    #and the second is the size of the group
+    #
+    #For example, "1100111000" becomes [[true,2],[false,2],[true,3],[false,3]]
+    def boolean_groups(reload=false)
+      if barcode.two_dimensional?
+        encoding(reload).map do |line|
+          line.scan(/1+|0+/).map do |group|
+            [group[0,1] == '1', group.size]
+          end
+        end
+      else
+        encoding(reload).scan(/1+|0+/).map do |group|
+          [group[0,1] == '1', group.size]
+        end
+      end
+    end
+
+
+    def with_options(options={})
+      original_options = options.inject({}) do |origs,pair|
+        if respond_to?(pair.first) && respond_to?("#{pair.first}=")
+          origs[pair.first] = send(pair.first)
+          send("#{pair.first}=", pair.last)
+        end
+        origs
+      end
+
+      rv = yield
+
+      original_options.each do |attribute,value|
+        send("#{attribute}=", value)
+      end
+
+      rv
+    end
+
+
+  end
+
+
+end

data/lib/barby/outputter/ascii_outputter.rb

@@ -0,0 +1,41 @@
+require 'barby/outputter'
+
+module Barby
+
+  #Outputs an ASCII representation of the barcode. This is mostly useful for printing
+  #the barcode directly to the terminal for testing.
+  #
+  #Registers to_ascii
+  class ASCIIOutputter < Outputter
+
+    register :to_ascii
+
+
+    def to_ascii(opts={})
+      default_opts = {:height => 10, :xdim => 1, :bar => '#', :space => ' '}
+      default_opts.update(:height => 1, :bar => ' X ', :space => '   ') if barcode.two_dimensional?
+      opts = default_opts.merge(opts)
+
+      if barcode.two_dimensional?
+        booleans.map do |bools|
+          line_to_ascii(bools, opts)
+        end.join("\n")
+      else
+        line_to_ascii(booleans, opts)
+      end
+    end
+
+
+  private
+
+    def line_to_ascii(booleans, opts)
+      Array.new(
+        opts[:height],
+        booleans.map{|b| (b ? opts[:bar] : opts[:space]) * opts[:xdim] }.join
+      ).join("\n")
+    end
+
+
+  end
+
+end

data/lib/barby/outputter/cairo_outputter.rb

@@ -0,0 +1,185 @@
+require 'barby/outputter'
+require 'cairo'
+require 'stringio'
+
+module Barby
+
+  #Uses Cairo to render a barcode to a number of formats: PNG, PS, EPS, PDF and SVG
+  #
+  #Registers methods render_to_cairo_context, to_png, to_ps, to_eps, to_pdf and to_svg
+  class CairoOutputter < Outputter
+
+    register :render_to_cairo_context
+    register :to_png
+
+    if Cairo.const_defined?(:PSSurface)
+      register :to_ps
+      register :to_eps if Cairo::PSSurface.method_defined?(:eps=)
+    end
+
+    register :to_pdf if Cairo.const_defined?(:PDFSurface)
+    register :to_svg if Cairo.const_defined?(:SVGSurface)
+
+    attr_writer :x, :y, :xdim, :height, :margin
+
+
+    #Render the barcode onto a Cairo context
+    def render_to_cairo_context(context, options={})
+      if context.respond_to?(:have_current_point?) and
+          context.have_current_point?
+        current_x, current_y = context.current_point
+      else
+        current_x = x(options) || margin(options)
+        current_y = y(options) || margin(options)
+      end
+
+      _xdim = xdim(options)
+      _height = height(options)
+      original_current_x = current_x
+      context.save do
+        context.set_source_color(:black)
+        context.fill do
+          if barcode.two_dimensional?
+            boolean_groups.each do |groups|
+              groups.each do |bar,amount|
+                current_width = _xdim * amount
+                if bar
+                  context.rectangle(current_x, current_y, current_width, _xdim)
+                end
+                current_x += current_width
+              end
+              current_x = original_current_x
+              current_y += _xdim
+            end
+          else
+            boolean_groups.each do |bar,amount|
+              current_width = _xdim * amount
+              if bar
+                context.rectangle(current_x, current_y, current_width, _height)
+              end
+              current_x += current_width
+            end
+          end
+        end
+      end
+
+      context
+    end
+
+
+    #Render the barcode to a PNG image
+    def to_png(options={})
+      output_to_string_io do |io|
+        Cairo::ImageSurface.new(options[:format],
+                                full_width(options),
+                                full_height(options)) do |surface|
+          render(surface, options)
+          surface.write_to_png(io)
+        end
+      end
+    end
+
+
+    #Render the barcode to a PS document
+    def to_ps(options={})
+      output_to_string_io do |io|
+        Cairo::PSSurface.new(io,
+                             full_width(options),
+                             full_height(options)) do |surface|
+          surface.eps = options[:eps] if surface.respond_to?(:eps=)
+          render(surface, options)
+        end
+      end
+    end
+
+
+    #Render the barcode to an EPS document
+    def to_eps(options={})
+      to_ps(options.merge(:eps => true))
+    end
+
+
+    #Render the barcode to a PDF document
+    def to_pdf(options={})
+      output_to_string_io do |io|
+        Cairo::PDFSurface.new(io,
+                              full_width(options),
+                              full_height(options)) do |surface|
+          render(surface, options)
+        end
+      end
+    end
+
+
+    #Render the barcode to an SVG document
+    def to_svg(options={})
+      output_to_string_io do |io|
+        Cairo::SVGSurface.new(io,
+                              full_width(options),
+                              full_height(options)) do |surface|
+          render(surface, options)
+        end
+      end
+    end
+
+
+    def x(options={})
+      @x || options[:x]
+    end
+
+    def y(options={})
+      @y || options[:y]
+    end
+
+    def width(options={})
+      (barcode.two_dimensional? ? encoding.first.length : encoding.length) * xdim(options)
+    end
+
+    def height(options={})
+      if barcode.two_dimensional?
+        encoding.size * xdim(options)
+      else
+        @height || options[:height] || 50
+      end
+    end
+
+    def full_width(options={})
+      width(options) + (margin(options) * 2)
+    end
+
+    def full_height(options={})
+      height(options) + (margin(options) * 2)
+    end
+
+    def xdim(options={})
+      @xdim || options[:xdim] || 1
+    end
+
+    def margin(options={})
+      @margin || options[:margin] || 10
+    end
+
+
+  private
+
+    def output_to_string_io
+      io = StringIO.new
+      yield(io)
+      io.rewind
+      io.read
+    end
+
+
+    def render(surface, options)
+      context = Cairo::Context.new(surface)
+      yield(context) if block_given?
+      context.set_source_color(options[:background] || :white)
+      context.paint
+      render_to_cairo_context(context, options)
+      context
+    end
+
+
+  end
+
+end