#!/usr/bin/env ruby

=begin rdoc

== vpp - View and (selectively) Print PDF and PostScript 

=== Synopsis

    vpp [options] [file]

    Options:

    -b, --batch=STRING      run in batch using STRING for print command
    -p, --printer=STRING    print to printer named STRING
    -d, --doublesided       printer is doublesided
    -r, --rc=STRING         use STRING as an rc file
    -V, --version           print version and exit
    -v, --[no-]verbose      be [not] verbose (quiet is the default)
        --[no-]view         do [not] view the document
        --[no-]print        do [not] offer printing interaction
    -h, --help              print this help and exit

=== Copyright

Copyright (C) 2009 Wybo Dekker (<tt>wybo@servalys.nl</tt>)

This program is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but without any warranty; without even the implied warranty of
merchantability or fitness for a particular purpose. See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see http://www.gnu.org/licenses.

=== Introduction

_vpp_ displays a PDF or PostScript document (after conversion to
PDF) using _xpdf_, _gv_, or any other PDF viewer of your choice).
The user can use the viewer to print the document or,
alternatively, leave the viewer and use _vpp_'s facilities to
print selected pages to a one- or two-sided hardcopy or an
A5-booklet: see the section `Page selection' for the details.
Instead of printing your selections, you can also save them into
PDF files.

If +file+ is specified with a <tt>.ps</tt> or a <tt>.pdf</tt>
extension, _vpp_ will simply use that +file+. Otherwise, _vpp_
will look for <tt>file.pdf</tt>, <tt>file.ps</tt>, and +file+, in
that order, and will use the first existing file. If +file+
lacks, standard input is used.

In any case, the first few characters <i>in</i> the file
determine whether it is treated as a PDF or as a PostScript file.

_vpp_ has three possible exit values:
0:: OK
1:: error
2:: edit, which is a signal to the calling program that a new edit
    session is at order; this is used by _mk_.
3:: re-compile; this is used by _mk_

=== Options

_vpp_
comes with several options. Before evaluating any options, _vpp_ will
try to read a system rc-file, a user rc-file, and, finally an rc-file in
the current directory. 

You can also set option defaults in an alias. For example:

      alias vpp='vpp --verbose'

<tt>--help</tt>:: 
      Prints help information, then quits

<tt>--version</tt>:: 
      Prints version, then quits.

<tt>--verbose</tt>:: 
      Prints messages about the progress _vpp_ is making. Can be
      reverted with <tt>--no-verbose</tt>

<tt>--rc=rc-file</tt>:: 
      Read specified <tt>rc-file</tt> before processing, but after any
      other rc files. The contents of this rc-file will override other
      options specified.

<tt>--batch=string</tt>:: 
      Prevents the --print option to interrogate the user about pages
      to be printed. Instead the document is printed according to the
      mandatory <tt>string</tt>. Also sets viewing off. Thus the
      command <tt>vpp -batch '2-3 x3' test.pdf</tt> prints 3 copies of
      pages 2 and 3 of <tt>test.pdf</tt> without viewing.

<tt>--print</tt>:: 
      Present the print prompt. This is the default. Can be reverted
      with <tt>--no-print</tt>, normally used to
      suppress the print prompt, for example when using _vpp_ from
      other scripts that generate PDF or PostScript documents that
      have only to be displayed or printed without even being
      displayed.

<tt>--view</tt>:: 
      Run the file viewer. This is the default. Can be reverted
      with <tt>--no-view</tt>, normally used to suppress
      starting the viewer, for example when using _vpp_ from other
      scripts that generate PDF or PostScript documents that have
      only to be printed.

<tt>--printer=string</tt>:: 
      Specifies the printer to be used instead of the system default printer.

<tt>--doublesided</tt>:: 
      Tells that the printer is able, and configured, to do doublesided printing. 

=== Page selection

When you select the <tt>--print</tt> option, and you did not also
use the <tt>--batch</tt> option, _vpp_ interrogates you about the
pages you want to print. To that end the following prompt appears:

    vpp command (? for help):

upon typing <tt>?</tt> or +h+, _vpp_ displays examples of possible commands:

=====
Examples of print commands:
    5       to print page 5
    5-      to print pages 5 through the end
    5-7     to print pages 5, 6 and 7
    -7      to print the first 7 pages
    5-7,19- to print pages 5, 6, 7 and 19 through the end
    a       to print the whole document
    -       to print the whole document
    a x3    to print 3 copies of the document
    x3      the same
    5 x3    to print 3 copies of page 5
    t       print the whole document twosided
    t 2-    print twosided starting at page 2
    b       to print the whole document as an a5 size booklet
    b -12   to print the first 12 pages as an a5 size booklet
Other commands:
    e       (if called by mk) edit the tex source and rerun mk
    c       (if called by mk) rerun mk
    v       (re)view the ps/pdf file
    oxyz    send pdf output to file xyz.pdf instead of printer
    h       display this help
    ?       display this help
    q       quit
=====
With these descriptions, no further explanation should be necessary, except
for the following:

When twosided (+t+) or booklet (+b+) printing is selected,
printing will be performed in two shifts, one for the front side and one
for the backside. Between the shifts, another prompt appears:

    printer ready? then turn stack and type return

You will have to arrange your printer such that, with the printed sides
up, the first page printed will be at the bottom of the stack, and the
last page printed will be on top. Normally you will then have your
output come out the back of your printer. `Turn the stack' then means:
rotate it over the long side of the paper and feed it back into the
printer for the other side to be printed.

When you use the +oxyz+ subcommand, your selection will not be printed but
instead will be saved in a PDF file named <tt>xyz.pdf</tt>. When you use a +t+ or
+b+ selection, you will not, of course, be prompted to turn the paper
stack. Instead, the odd and even pages of your selection will be saved in
separate PDF files, <tt>xyz_odd.pdf</tt> and <tt>xyz_even.pdf</tt>.

=== RC-files and customization

Unless the environment variable NORC has been set, three rc-files are
executed, if they exist, before reading the command line options, in the
following order:

<tt>/etc/vpprc</tt>:: the system rc-file
<tt>$HOME/.vpprc</tt>:: the user rc-file
<tt>./.vpprc</tt>:: the local rc-file

You can use these rc-files to set the default values for some of the options,
by quoting <b>key = value</b> pairs. Valid keys are:

<tt>@batch</tt>::       (string) sets the <tt>--batch</tt> option
<tt>@print</tt>::       (true or false) sets printing interaction on of off
<tt>@printer</tt>::     (string) sets the <tt>--printer</tt> option
<tt>@doublesided</tt>:: (true or false) sets the <tt>--doublesided</tt> option
<tt>@verbose</tt>::     (true or false) sets the <tt>--verbose</tt> option 
<tt>@view</tt>::        (true or false) sets viewing on or off
<tt>@viewer</tt>::      (string) set the viewer; arguments may be added

For example:

    @verbose = true # run in verbose mode

set your PDF viewer:

    @viewer = 'gv' # set the viewer

You should use a basename here, i.e. the name of the viewer should
contain no slashes, and it should be in your PATH. But you may add
options, for example:

    @viewer = 'acroread -geometry 1450x1150+0+0'

_xpdf_ is the default viewer for both PostScript and PDF; PostScript
files are temporarily converted to PDF for viewing.

You may add Ruby-style comments as usual in rc files, but rdoc-style comments 
are not allowed.

=== Examples

Since _vpp_ can read from standard input, it can be used to print
(parts of) manpages. This example prints the full +ls+ manpage
first, followed by an A5 booklet of the first 8 pages:

    $ man -t ls | vpp # (xpdf shows preview and is left with `q')
    vpp command (? for help): a
    vpp command (? for help): b 1-8
    printer ready? then turn pack over the long side and type enter (^D skips)
    vpp command (? for help): q
    $

If you don't need a preview, because you have seen the man page already,
you can print it immediately as an A5 booklet with:

    $ man -t ls | vpp --batch=b

or, to make an A5 booklet of the first 8 pages:

    $ man -t ls |vpp --batch='-8 b'

If you just want to save a PDF copy of the man page, you can say:

    $ man -t ls |vpp -b ols

Some PDF-documents, like the CVS manual (<tt>cvs.pdf</tt>), have their
Table of Contents in their back instead of behind the title page. You
can use vpp to rearrange such documents:

    $ vpp --batch='1,2,153-160,3-152 ocvs' cvs.pdf 

This overwrites the input document. Note that any links in the file will
get broken, so that is only useful for documents that have to be printed.
It would have been more sensible in this case to say:

    $ vpp --batch=b 1,2,153-160,3-152' cvs

which prints the reordered document as an A5 booklet without replacing it.

You can even print or output page ranges in reverse order:

    $ vpp --batch='12-1 otest' cvs.pdf

=end

require 'readline'
include Readline

require 'fileutils'
include FileUtils

begin
  require 'scriptingutils'
rescue LoadError
  raise LoadError,<<EOF
\n    You probably did not install scriptingutils.rb. 
    This module is included in #{File.basename($0)}'s distribution
    and must be placed in your LOAD_PATH, that is,
    in one of these directories:
    #{$LOAD_PATH.join("   \n    ")}
EOF
end

       RELEASE = 2.2
       VIEWERS = %w{ xpdf gv acroread }
        NEEDED = %w{ pdflatex texi2dvi pdfinfo ps2pdf }
        @saved = false
         @view = true
           @rc = nil
        @check = nil
       @viewer = nil
      @verbose = nil
        @print = true
        @batch = nil
      EDITEXIT = 99
   COMPILEEXIT = 98
           TMP = "/tmp/#{$$}"
     MYABSNAME = File.expand_path($0)

# find pdf viewer
def find_viewer
  if @viewer 
    # before looking for this program, strip off any arguments:
    executable(@viewer.split.shift) or
      quit(<<-EOF,1)
        #{@viewer} was specified for viewing
        in an rc file, but is was not found in PATH
        (rc files: #{@rcfiles}
      EOF
  else
    VIEWERS.each do |v|
      if executable(v)
        @viewer = v
        break
      end
    end
    @viewer or quit("no valid pdf viewer could be found",1)
  end
end

# handle options
def handle_options
  
  ARGV.options do |opt|
    opt.banner =  "#{MYNAME} - view and (selectively) print PDF and PostScript"
    opt.separator ''
    
    opt.on('-b','--batch=STRING',String,
           'run in batch using STRING for print command') do |v| @batch = v end
    opt.on('-p','--printer=STRING',String,
           'print to printer named STRING') do |v| @printer = v end
    opt.on('-d','--doublesided',
           'printer is doublesided') do |v| @doublesided = true end
    opt.on('-r','--rc=STRING',  String,
           'use STRING as an rc file') \
           do |v|
             @rc = v
             File.exist?(v) or quit("File #{v}, specified with --rc, does not exist",1) 
             File.readable?(v) or quit("File #{v}, specified with --rc, is not readable",1) 
           end
    opt.on('-V','--version',        
           'print version and exit') \
           do print_version(RELEASE) end
    opt.on('-v','--[no-]verbose',        
           'be [not] verbose (quiet is the default)') \
           do |v| @verbose = v end
    opt.on(    '--[no-]view',        
           "do [not] view the document") \
           do |v| @view = v end
    opt.on(    '--[no-]print',        
           "do [not] offer printing interaction") \
           do |v| @print = v end
    opt.on('-h','--help',          
           'print this help and exit') \
           do quit(opt.help) end

    opt.separator ''
    opt.separator 'For backward compatibility with Perl version:'
    
    opt.on('-q','--quiet',
                'be quiet (quiet is the default)') \
                do @verbose = false end
    opt.on(     '--noquiet',
                'be verbose (quiet is the default)') \
                do @verbose = true end
    opt.on(     '--noview',
                "do not view the document") \
                do @view = false end
    opt.on(     '--noprint',
                "do not offer printing interaction") \
                do @print = false end
    opt.parse!
  end or quit("Option parsing error",1)
  @view, @print = false, true if @batch
  @printer = "-P#{@printer}" if @printer
end

# find the input and provide a pdf-copy:
def pdf
  f = ARGV.shift
  case f
  when nil
    fhin = STDIN
    using = "standard input"
  when /\.(pdf|ps)$/ # extension given - use f
    File.exist?(f) or quit("File #{f} does not exist!")
    fhin = File.new(f)
    using = f
  else                               # no extension given:
    if File.exist?("#{f}.pdf")       # try .pdf
      using = "#{f}.pdf"
      fhin = File.new(using)
    elsif File.exist?("#{f}.ps")     # try .ps
      using = "#{f}.ps"
      fhin = File.new(using)
    else                             # use f if f.pdf and f.ps aren't there
      File.exist?(f) or quit("Found no file #{f}, #{f}.pdf or #{f}.ps!")
      fhin = File.new(f)
      using = f
    end
  end
  warn "Using #{using}" if @verbose
  fhin.eof and quit("Empty input file")
  fhin.binmode

  # is it PDF or PostScript?
  first = fhin.read(4)
  ispdf = case first
  when /%!/   : false
  when /%PDF/ : true
  else
    quit("Input is neither PDF nor PostScript")
  end
  #
  # continue running in temporary directory
  Dir.mkdir(TMP)
  warn "Running in temporary directory #{TMP}" if @verbose
  Dir.chdir(TMP)

  # make a pdf copy in the temporary directory:
  open(ispdf ? 'main.pdf' : '|ps2pdf - main.pdf','wb') do |fout|
    fout.write(first)
    while s = fhin.read(512)
      fout.write(s)
    end
  end
  return File.join(Dir.getwd,'main.pdf')
end

# find PDF properties in file: 
# paperwidth, paperheight, pagecount
def pdfproperties(file)
  width,height,pagecount = nil,nil,nil
  open("|pdfinfo #{file}") do |pdfinfo|
    pdfinfo.each do |l|
      case l
      when /Pages:\s*(\d+)/
        pagecount = $1
      when /Page size:\s*([\d.]+) x ([\d.]+)/
        width,height = $1,$2
        break
      end
    end
  end
  width = "%.0f" % width.to_f
  height = "%.0f" % height.to_f
  warn "#{pagecount || 'Unknown number of'} pages, papersize #{width}bp x #{height}bp" if @verbose
  return width, height, pagecount.to_i
end

# run the viewer
def view(viewer,file)
  h = sys("#{viewer} #{file}",true)
  quit(h[:error]) unless h[:success]
end

# make a selection of pdf pages
def doselection(selection, booklet, evenodd, lpropt, output)
  includeopt = booklet ? ', booklet, landscape' : ''
  pagesel = evenodd ? "\\usepackage[#{evenodd}]{pagesel}" : ''
  outpdf = 'vpp.pdf'
  # if the whole document is selected, without booklet or twosided printing, 
  # we can simply print the original pdf or, if a copy is requested with the
  # o command, copy it to the new pdf, saving link information which is lost
  # otherwise:
  unless includeopt + pagesel + selection == '-' # unless just a copy needed
    begin
      open('vpp.tex','w') do |tex|
        tex.print <<-EOF
          \\documentclass[pdftex]{article}
          \\usepackage[papersize={#{@width}bp,#{@height}bp}]{geometry}
          \\usepackage{pdfpages}[2004/03/27]
          #{pagesel}
          \\begin{document}
          \\includepdf[pages={#{selection}}#{includeopt}]{#{@filename}}
          \\end{document}
        EOF
      end
    rescue
      quit("Could not create vpp.tex in #{TMPDIR}: #{$!}",1)
    end
    h = sys("PDFLATEX='pdflatex -interaction=batchmode' texi2dvi -p #{@verbose ? '' : '-q'} vpp.tex")
    quit(h[:error]) unless h[:success]
  else
    outpdf = 'main.pdf'
  end
  if output
    output += '_' if evenodd
    to = (output+(evenodd||'')+'.pdf').sub(/\.pdf\.pdf/,'.pdf')
    warn "copying #{outpdf} to #{to}" if @verbose
    open(to,'w') { |p| p.write(open(outpdf).read) }
    puts "#{to} written"
  else
    h = sys("#{PRINTER} #{@printer} #{lpropt} #{outpdf}") 
    quit(h[:error]) unless h[:success]
  end
end

# wait for printer ready
def wait_for_printer
  readline("printer ready? then turn pack over the long side and type enter (^D skips)") or quit(nil,0,true)
end

# prompt for a command, return the command,
# but quit on EOD after printing a newline to end up at column 1 of the screen
def ask(prompt)
  x = readline(prompt,true)
  quit(nil,0,true) unless x # EOD prints newline and quits
  x.chomp
end

# ask user for pages to printed or exported as pdf
def ask_selection(com=nil)
  prompt='vpp command (? for help): '
  com ||= ask(prompt)
  output = nil
  com.chomp!
  return 'continue' if com == ''
  booklet,twosided,selection,lpropt = nil,nil,'-',''
  help = <<-EOF
  Examples of print commands:
    5       to print page 5
    5-      to print pages 5 through the end
    5-7     to print pages 5, 6 and 7
    -7      to print the first 7 pages
    5-7,19- to print pages 5, 6, 7 and 19 through the end
    a       to print the whole document
    -       to print the whole document
    a x3    to print 3 copies of the document
    x3      the same
    5 x3    to print 3 copies of page 5
    t       print the whole document twosided
    t 2-    print twosided starting at page 2
    b       to print the whole document as an a5 size booklet
    b -12   to print the first 12 pages as an a5 size booklet
  Other commands:
    e       (if called by mk) edit the tex source and rerun mk
    c       (if called by mk) rerun mk
    v       (re)view the ps/pdf file
    oxyz    send pdf output to file xyz.pdf instead of printer
    h       display this help
    ?       display this help
    q       quit
  EOF
  com.split.each do |c|
    case c
    when 'q':            	       # drop on q
      if ENV['VPPCHECKSAVED'] && ! @saved
        puts "You requested saving but did not use the o command"
        puts "Another q will destroy your copy"
        @saved = true
        return 'continue'
      end
      rm_rf(TMP)
      return 'quit'
    when 'e': quit(nil,EDITEXIT)       # edit request for caller
    when 'c': quit(nil,COMPILEEXIT)    # re-compile request for caller
    when 's':                          # make sure o command will be used; used in scripting
      @save = true
      return 'continue'
    when 'v':                          # (re)view the ps/pdf data
      view(@viewer,@filename);
      return 'continue'
    when /^x([0-9]+)$/:                # x3 -> -#3
      lpropt = "-#"+$1
    when /^o(.*)/:                     # output to file instead of printer
      output = $1.sub(/\~/,ENV['HOME'])
      if output == ''
        puts("filename must follow o without spacing")
        return 'continue'
      end
      if output =~ /\//
        puts("filename may not contain /'s")
        return 'continue'
      end
      @saved = true
    when 'b':    booklet  = true       # print a5 booklet
    when 't':    twosided  = true      # print twosided
    when 'a':    selection = '-'       # print all
    when '-':    selection = '-'       # print all
    when /^((\d+-?\d*|\d*-?\d+),?)+$/: # n-m or n- or -m
      selection = c.sub(/,$/,'')
    when /^(\?|h)$/:
      puts input_options
      return 'continue'
    else
      puts "Illegal specification(s)"
      puts input_options
      return 'continue'
    end
  end
  # pages in range?
  selection.sub!(/^-/,'1-') 		# -m means 1-m
  selection.sub!(/-$/,"-#{@pagecount}")	# n- means n-@pagecount
  selection.split(/\D+/).each do |n|
    unless n.to_i.between?(1,@pagecount)
      puts "Illegal page number #{n}; PDF has #{@pagecount} pages"
      return 'continue'
    end
  end
  return selection,booklet,twosided,lpropt,output
end

# print selected pages
def printout
  # always get commands interactively
  if Readline.respond_to?('input')
    # for ruby versions > 1.8.2
    Readline.input = open(DEVTTY)
  else
    # for ruby versions upto 1.8.2
    STDIN.reopen DEVTTY unless STDIN.tty?
  end

  loop do
    selection,booklet,twosided,lpropt,output = ask_selection(@batch)
    selection == 'quit' and quit
    selection == 'continue' and next
    selection ||= '-'
    
    if output
      output.sub!(/.*\//,'')
      output = File.join(ENV['VPPOUTDIR'] || WORKDIR,output)
    end
    if @doublesided
      doselection(selection,booklet, nil  ,lpropt,output)
    else
      if booklet
        doselection(selection,true, 'odd' ,lpropt,output)
        wait_for_printer unless output
        doselection(selection,true, 'even',lpropt,output)
      elsif twosided
        doselection(selection,false,'odd' ,lpropt,output)
        wait_for_printer unless output
        doselection(selection,false,'even',lpropt,output)
      else
        doselection(selection,false, nil  ,lpropt,output)
      end
    end
    break if @batch
  end
end

# return the input options, taken from the rdoc comment:
def input_options
  sep = "\n=====\n"
  open(MYABSNAME) do |f| "\n" + f.readlines(sep)[1].chomp(sep) + "\n" end
end

init(NEEDED,:handle_options)

find_viewer

@filename = pdf
@width, @height, @pagecount = pdfproperties(@filename)

@view || @print or quit("Nothing to do: use --view or --print or both",1)
@view and view(@viewer,@filename)
@print and printout
quit

# $Id: vpp,v 1.69 2009-11-11 14:44:01 wybo Exp $