—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—
—

              
#=======================================================================
#    ____  ____  _____              _    ____ ___   ____
#   |  _ \|  _ \|  ___|  _   _     / \  |  _ \_ _| |___ \
#   | |_) | | | | |_    (_) (_)   / _ \ | |_) | |    __) |
#   |  __/| |_| |  _|    _   _   / ___ \|  __/| |   / __/
#   |_|   |____/|_|     (_) (_) /_/   \_\_|  |___| |_____|
#
#   A Perl Module Chain to faciliate the Creation and Modification
#   of High-Quality "Portable Document Format (PDF)" Files.
#
#   Copyright 1999-2005 Alfred Reibenschuh <areibens@cpan.org>.
#
#=======================================================================
#
#   This library is free software; you can redistribute it and/or
#   modify it under the terms of the GNU Lesser General Public
#   License as published by the Free Software Foundation; either
#   version 2 of the License, or (at your option) any later version.
#
#   This library 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
#   Lesser General Public License for more details.
#
#   You should have received a copy of the GNU Lesser General Public
#   License along with this library; if not, write to the
#   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
#   Boston, MA 02111-1307, USA.
#
#   $Id: API2.pm,v 2.15 2008/01/18 00:11:38 areibens Exp $
#
#=======================================================================
package PDF::API3::Compat::API2;
BEGIN {
    use vars qw( $VERSION $seq @FontDirs );
    ($VERSION) = "0.74";
    @FontDirs = ( (map { "$_/PDF/API3/Compat/API2/fonts" } @INC), 
        qw[ /usr/share/fonts /usr/local/share/fonts c:/windows/fonts c:/winnt/fonts ] );
    $seq="AA";
    require 5.008; # we need this for unicode support
    use PDF::API3::Compat::API2::Basic::PDF::File;
    use PDF::API3::Compat::API2::Basic::PDF::Page;
    use PDF::API3::Compat::API2::Basic::PDF::Utils;
    use PDF::API3::Compat::API2::Util;
    use PDF::API3::Compat::API2::Page;
    use PDF::API3::Compat::API2::Outlines;
    use PDF::API3::Compat::API2::NamedDestination;
    use PDF::API3::Compat::API2::Resource::ExtGState;
    use PDF::API3::Compat::API2::Resource::Pattern;
    use PDF::API3::Compat::API2::Resource::Shading;
    use PDF::API3::Compat::API2::Resource::Font::CoreFont;
    use PDF::API3::Compat::API2::Resource::Font::Postscript;
    use PDF::API3::Compat::API2::Resource::Font::BdFont;
    use PDF::API3::Compat::API2::Resource::Font::SynFont;
    use PDF::API3::Compat::API2::Resource::Font::neTrueType;
    use PDF::API3::Compat::API2::Resource::CIDFont::TrueType;
    use PDF::API3::Compat::API2::Resource::CIDFont::CJKFont;
    use PDF::API3::Compat::API2::Resource::UniFont;
    use PDF::API3::Compat::API2::Resource::XObject::Image::JPEG;
    use PDF::API3::Compat::API2::Resource::XObject::Image::TIFF;
    use PDF::API3::Compat::API2::Resource::XObject::Image::PNM;
    use PDF::API3::Compat::API2::Resource::XObject::Image::PNG;
    use PDF::API3::Compat::API2::Resource::XObject::Image::GIF;
    use PDF::API3::Compat::API2::Resource::XObject::Image::GD;
    use PDF::API3::Compat::API2::Resource::XObject::Form::Hybrid;
    use PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::int2of5;
    use PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::codabar;
    use PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::code128;
    use PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::code3of9;
    use PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::ean13;
    use PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::ACTFile;
    use PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::Hue;
    use PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::WebColor;
    use PDF::API3::Compat::API2::Resource::ColorSpace::Separation;
    use PDF::API3::Compat::API2::Resource::ColorSpace::DeviceN;
     
    use Compress::Zlib;
    use Math::Trig;
    use POSIX qw( ceil floor );
    use utf8;
    use Encode qw(:all);
        use FileHandle;
}
no warnings qw[ deprecated recursion uninitialized ];
HideShow 42 lines of Pod
=head1 NAME
PDF::API3::Compat::API2 - A Perl Module Chain to faciliate the Creation and Modification of High-Quality "Portable Document Format (aka. PDF)" Files.
=head1 SYNOPSIS
    use PDF::API3::Compat::API2;
    #
    $pdf = PDF::API3::Compat::API2->new;
    $pdf = PDF::API3::Compat::API2->open('some.pdf');
    $page = $pdf->page;
    $page = $pdf->openpage($pagenum);
    $img = $pdf->image('some.jpg');
    $font = $pdf->corefont('Times-Roman');
    $font = $pdf->ttfont('TimesNewRoman.ttf');
=head1 GENERIC METHODS
=over 4
=item $pdf = PDF::API->new %opts
Creates a new pdf-file object. If you know beforehand
to save the pdf to file you can give the '-file' option,
to minimize possible memory requirements later-on.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new();
    ...
    print $pdf->stringify;
    $pdf = PDF::API3::Compat::API2->new();
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new(-file => 'our/new.pdf');
    ...
    $pdf->save;
=cut
sub new {
    my $class=shift(@_);
    my %opt=@_;
    my $self={};
    bless($self,$class);
    $self->{pdf}=PDF::API3::Compat::API2::Basic::PDF::File->new();
    $self->{time}='_'.pdfkey(time());
    $self->{pdf}->{' version'} = 4;
    $self->{pages} = PDF::API3::Compat::API2::Basic::PDF::Pages->new($self->{pdf});
    $self->{pages}->proc_set(qw( PDF Text ImageB ImageC ImageI ));
    $self->{pages}->{Resources}||=PDFDict();
    $self->{pdf}->new_obj($self->{pages}->{Resources}) unless($self->{pages}->{Resources}->is_obj($self->{pdf}));
    $self->{catalog}=$self->{pdf}->{Root};
    $self->{fonts}={};
    $self->{pagestack}=[];
    $self->{forcecompress}= ($^O eq 'os390') ? 0 : 1;
    $self->preferences(%opt);
    if($opt{-file}) {
        $self->{' filed'}=$opt{-file};
        $self->{pdf}->create_file($opt{-file});
    }
    $self->{infoMeta}=[qw(  Author CreationDate ModDate Creator Producer Title Subject Keywords  )];
    $self->info( 'Producer' => $PDF::API3::Compat::API2::Version::CVersion{vFredo}." [$^O]" );
    return $self;
}
HideShow 16 lines of Pod
=item $pdf = PDF::API->open $pdffile
Opens an existing PDF for modification.
B<Example:>
    $pdf = PDF::API3::Compat::API2->open('my/old.pdf');
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->open('our/to/be/updated.pdf');
    ...
    $pdf->update;
=cut
sub open {
    my $class=shift(@_);
    my $file=shift(@_);
    my %opt=@_;
    my $filestr;
    my $self={};
    bless($self,$class);
    $self->default('Compression',1);
    $self->default('subset',1);
    $self->default('update',1);
    foreach my $para (keys(%opt)) {
        $self->default($para,$opt{$para});
    }
    die "File '$file' does not exist." unless(-f $file);
     
    $self->{content_ref} = \$filestr;
    my $fh = new FileHandle;
    CORE::open($fh, "+<", \$filestr) || die "Can't begin scalar IO";
    binmode($fh,':raw');
    my $inf = new FileHandle;
    CORE::open($inf,$file);
    binmode($inf,':raw');
    $inf->seek(0,0);
    while(!$inf->eof) {
        $inf->read($in,512);
        $fh->print($in);
    }
    $inf->close;
    $fh->seek(0,0);
    $self->{pdf}=PDF::API3::Compat::API2::Basic::PDF::File->open($fh,1);
    $self->{pdf}->{' fname'}=$file;
    $self->{pdf}->{'Root'}->realise;
    $self->{pages}=$self->{pdf}->{'Root'}->{'Pages'}->realise;
    $self->{pdf}->{' version'} = 3;
    $self->{pdf}->{' apipagecount'} = 0;
    my @pages=proc_pages($self->{pdf},$self->{pages});
    $self->{pagestack}=[sort {$a->{' pnum'} <=> $b->{' pnum'}} @pages];
    $self->{catalog}=$self->{pdf}->{Root};
    $self->{reopened}=1;
    $self->{time}='_'.pdfkey(time());
    $self->{forcecompress}= ($^O eq 'os390') ? 0 : 1;
    $self->{fonts}={};
    $self->{infoMeta}=[qw(  Author CreationDate ModDate Creator Producer Title Subject Keywords  )];
    return $self;
}
HideShow 14 lines of Pod
=item $pdf = PDF::API->openScalar $pdfstream
Opens an existing PDF-stream for modification.
B<Example:>
    open($fh,'our/stream.pdf') or die "$@";
    @pdf = <$fh>;
    $pdf = PDF::API->openScalar(join('',@pdf));
    ...
    $pdf->saveas('our/new.pdf');
=cut
sub openScalar {
    my $class=shift(@_);
    my $file=shift(@_);
    my %opt=@_;
    my $self={};
    bless($self,$class);
    $self->default('Compression',1);
    $self->default('subset',1);
    $self->default('update',1);
    foreach my $para (keys(%opt)) {
        $self->default($para,$opt{$para});
    }
    $self->{content_ref} = \$file;
    my $fh;
    CORE::open($fh, "+<", \$file) || die "Can't begin scalar IO";
    $self->{pdf}=PDF::API3::Compat::API2::Basic::PDF::File->open($fh,1);
    $self->{pdf}->{'Root'}->realise;
    $self->{pages}=$self->{pdf}->{'Root'}->{'Pages'}->realise;
    $self->{pdf}->{' version'} = 3;
    $self->{pdf}->{' apipagecount'} = 0;
    my @pages=proc_pages($self->{pdf},$self->{pages});
    $self->{pagestack}=[sort {$a->{' pnum'} <=> $b->{' pnum'}} @pages];
    $self->{catalog}=$self->{pdf}->{Root};
    $self->{reopened}=1;
    $self->{time}='_'.pdfkey(time());
    $self->{forcecompress}= ($^O eq 'os390') ? 0 : 1;
    $self->{fonts}={};
    $self->{infoMeta}=[qw(  Author CreationDate ModDate Creator Producer Title Subject Keywords  )];
    return $self;
}
HideShow 149 lines of Pod
=item $pdf->preferences %opts
Controls viewing-preferences for the pdf.
=cut
=pod
B<Page Mode Options:>
I<-fullscreen>
... Full-screen mode, with no menu bar, window controls, or any other window visible.
I<-thumbs>
... Thumbnail images visible.
I<-outlines>
... Document outline visible.
=cut
=pod
B<Page Layout Options:>
I<-singlepage>
... Display one page at a time.
I<-onecolumn>
... Display the pages in one column.
I<-twocolumnleft>
... Display the pages in two columns, with oddnumbered pages on the left.
I<-twocolumnright>
... Display the pages in two columns, with oddnumbered pages on the right.
=cut
=pod
B<Viewer Options:>
I<-hidetoolbar>
        ... Specifying whether to hide tool bars.
I<-hidemenubar>
        ... Specifying whether to hide menu bars.
I<-hidewindowui>
        ... Specifying whether to hide user interface elements.
I<-fitwindow>
        ... Specifying whether to resize the document’s window to the size of the displayed page.
I<-centerwindow>
        ... Specifying whether to position the document’s window in the center of the screen.
I<-displaytitle>
        ... Specifying whether the window’s title bar should display the document title
        taken from the Title entry of the document information dictionary.
I<-afterfullscreenthumbs>
        ... Thumbnail images visible after Full-screen mode.
I<-afterfullscreenoutlines>
        ... Document outline visible after Full-screen mode.
I<-printscalingnone>
                ... Set the default print setting for page scaling to none.
=cut
=pod
B<Initial Page Option:>
I<-firstpage> => [ $pageobj, %opts]
        ... Specifying the page to be displayed, plus one of the following options:
=cut
=pod
B<Initial Page Options:>
I<-fit> => 1
            ... Display the page designated by page, with its contents magnified just enough to
            fit the entire page within the window both horizontally and vertically. If the
            required horizontal and vertical magnification factors are different, use the
            smaller of the two, centering the page within the window in the other dimension.
I<-fith> => $top
            ... Display the page designated by page, with the vertical coordinate top positioned
            at the top edge of the window and the contents of the page magnified just enough
            to fit the entire width of the page within the window.
I<-fitv> => $left
            ... Display the page designated by page, with the horizontal coordinate left positioned
            at the left edge of the window and the contents of the page magnified just enough
            to fit the entire height of the page within the window.
I<-fitr> => [ $left, $bottom, $right, $top ]
            ... Display the page designated by page, with its contents magnified just enough to
            fit the rectangle specified by the coordinates left, bottom, right, and top
            entirely within the window both horizontally and vertically. If the required
            horizontal and vertical magnification factors are different, use the smaller of
            the two, centering the rectangle within the window in the other dimension.
I<-fitb> => 1
            ... Display the page designated by page, with its contents magnified just enough
            to fit its bounding box entirely within the window both horizontally and
            vertically. If the required horizontal and vertical magnification factors are
            different, use the smaller of the two, centering the bounding box within the
            window in the other dimension.
I<-fitbh> => $top
            ... Display the page designated by page, with the vertical coordinate top
            positioned at the top edge of the window and the contents of the page
            magnified just enough to fit the entire width of its bounding box
            within the window.
I<-fitbv> => $left
            ... Display the page designated by page, with the horizontal coordinate
            left positioned at the left edge of the window and the contents of the page
            magnified just enough to fit the entire height of its bounding box within the
            window.
I<-xyz> => [ $left, $top, $zoom ]
            ... Display the page designated by page, with the coordinates (left, top) positioned
            at the top-left corner of the window and the contents of the page magnified by
            the factor zoom. A zero (0) value for any of the parameters left, top, or zoom
            specifies that the current value of that parameter is to be retained unchanged.
=cut
=pod
B<Example:>
    $pdf->preferences(
        -fullscreen => 1,
        -onecolumn => 1,
        -afterfullscreenoutlines => 1,
        -firstpage => [ $pageobj , -fit => 1],
    );
=cut
sub preferences {
    my $self=shift @_;
    my %opt=@_;
    if($opt{-fullscreen}) {
        $self->{catalog}->{PageMode}=PDFName('FullScreen');
    } elsif($opt{-thumbs}) {
        $self->{catalog}->{PageMode}=PDFName('UseThumbs');
    } elsif($opt{-outlines}) {
        $self->{catalog}->{PageMode}=PDFName('UseOutlines');
    } else {
        $self->{catalog}->{PageMode}=PDFName('UseNone');
    }
    if($opt{-singlepage}) {
        $self->{catalog}->{PageLayout}=PDFName('SinglePage');
    } elsif($opt{-onecolumn}) {
        $self->{catalog}->{PageLayout}=PDFName('OneColumn');
    } elsif($opt{-twocolumnleft}) {
        $self->{catalog}->{PageLayout}=PDFName('TwoColumnLeft');
    } elsif($opt{-twocolumnright}) {
        $self->{catalog}->{PageLayout}=PDFName('TwoColumnRight');
    } else {
        $self->{catalog}->{PageLayout}=PDFName('SinglePage');
    }
    $self->{catalog}->{ViewerPreferences}||=PDFDict();
    $self->{catalog}->{ViewerPreferences}->realise;
    if($opt{-hidetoolbar}) {
        $self->{catalog}->{ViewerPreferences}->{HideToolbar}=PDFBool(1);
    }
    if($opt{-hidemenubar}) {
        $self->{catalog}->{ViewerPreferences}->{HideMenubar}=PDFBool(1);
    }
    if($opt{-hidewindowui}) {
        $self->{catalog}->{ViewerPreferences}->{HideWindowUI}=PDFBool(1);
    }
    if($opt{-fitwindow}) {
        $self->{catalog}->{ViewerPreferences}->{FitWindow}=PDFBool(1);
    }
    if($opt{-centerwindow}) {
        $self->{catalog}->{ViewerPreferences}->{CenterWindow}=PDFBool(1);
    }
    if($opt{-displaytitle}) {
        $self->{catalog}->{ViewerPreferences}->{DisplayDocTitle}=PDFBool(1);
    }
    if($opt{-righttoleft}) {
        $self->{catalog}->{ViewerPreferences}->{Direction}=PDFName("R2L");
    }
    if($opt{-afterfullscreenthumbs}) {
        $self->{catalog}->{ViewerPreferences}->{NonFullScreenPageMode}=PDFName('UseThumbs');
    } elsif($opt{-afterfullscreenoutlines}) {
        $self->{catalog}->{ViewerPreferences}->{NonFullScreenPageMode}=PDFName('UseOutlines');
    } else {
        $self->{catalog}->{ViewerPreferences}->{NonFullScreenPageMode}=PDFName('UseNone');
    }
    if($opt{-printscalingnone}) {
                $self->{catalog}->{ViewerPreferences}->{PrintScaling}=PDFName("None");
    }
    if($opt{-firstpage}) {
        my ($page,%o)=@{$opt{-firstpage}};
        $o{-fit}=1 if(scalar(keys %o)<1);
        if(defined $o{-fit}) {
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('Fit'));
        } elsif(defined $o{-fith}) {
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('FitH'),PDFNum($o{-fith}));
        } elsif(defined $o{-fitb}) {
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('FitB'));
        } elsif(defined $o{-fitbh}) {
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('FitBH'),PDFNum($o{-fitbh}));
        } elsif(defined $o{-fitv}) {
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('FitV'),PDFNum($o{-fitv}));
        } elsif(defined $o{-fitbv}) {
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('FitBV'),PDFNum($o{-fitbv}));
        } elsif(defined $o{-fitr}) {
            die "insufficient parameters to -fitr => [] " unless(scalar @{$o{-fitr}} == 4);
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('FitR'),map {PDFNum($_)} @{$o{-fitr}});
        } elsif(defined $o{-xyz}) {
            die "insufficient parameters to -xyz => [] " unless(scalar @{$o{-xyz}} == 3);
            $self->{catalog}->{OpenAction}=PDFArray($page,PDFName('XYZ'),map {PDFNum($_)} @{$o{-xyz}});
        }
    }
    $self->{pdf}->out_obj($self->{catalog});
    return $self;
}
HideShow 16 lines of Pod
=item $val = $pdf->default $parameter
=item $pdf->default $parameter, $val
Gets/Sets default values for the behaviour of ::API2.
B<Supported Parameters:>
I<nounrotate> ... prohibits API2 from rotating imported/opened page to re-create a default pdf-context.
I<pageencaps> ... enables than API2 will add save/restore commands upon imported/opened pages to preserve graphics-state for modification.
I<copyannots> ... enables importing of annotations (B<*EXPERIMENTAL*>).
=cut
sub default {
    my ($self,$parameter,$var)=@_;
    $parameter=~s/[^a-zA-Z\d]//g;
    $parameter=lc($parameter);
    my $temp=$self->{$parameter};
    if(defined $var) {
        $self->{$parameter}=$var;
    }
    return($temp);
}
HideShow 6 lines of Pod
=item $bool = $pdf->isEncrypted
Checks if the previously opened pdf is encrypted.
=cut
sub isEncrypted {
    my $self=shift @_;
    return(defined($self->{pdf}->{'Encrypt'}) ? 1 : 0);
}
HideShow 21 lines of Pod
     
=item %infohash = $pdf->info %infohash
Sets/Gets the info structure of the document.
B<Example:>
    %h = $pdf->info(
        'Author'       => " Alfred Reibenschuh ",
        'CreationDate' => "D:20020911000000+01'00'",
        'ModDate'      => "D:YYYYMMDDhhmmssOHH'mm'",
        'Creator'      => "fredos-script.pl",
        'Producer'     => "PDF::API3::Compat::API2",
        'Title'        => "some Publication",
        'Subject'      => "perl ?",
        'Keywords'     => "all good things are pdf"
    );
    print "Author: $h{Author}\n";
     
=cut
sub info {
    my $self=shift @_;
    my %opt=@_;
    if(!defined($self->{pdf}->{'Info'})) {
            $self->{pdf}->{'Info'}=PDFDict();
            $self->{pdf}->new_obj($self->{'pdf'}->{'Info'});
    } else {
        $self->{pdf}->{'Info'}->realise;
    }
    if(scalar @_) {
      foreach my $k (@{$self->{infoMeta}}) {
        next unless(defined $opt{$k});
        if(is_utf8($opt{$k})) {
            $self->{pdf}->{'Info'}->{$k}=PDFUtf($opt{$k}||'NONE');
        #} elsif(is_utf8($opt{$k}) || utf8::valid($opt{$k})) {
        #    $self->{pdf}->{'Info'}->{$k}=PDFUtf($opt{$k}||'NONE');
        } else {
            $self->{pdf}->{'Info'}->{$k}=PDFStr($opt{$k}||'NONE');
        }
      }
      $self->{pdf}->out_obj($self->{pdf}->{'Info'});
    }
    if(defined $self->{pdf}->{'Info'}) {
      %opt=();
      foreach my $k (@{$self->{infoMeta}}) {
        next unless(defined $self->{pdf}->{'Info'}->{$k});
        $opt{$k}=$self->{pdf}->{'Info'}->{$k}->val;
        if ((unpack('n',$opt{$k})==0xfffe) or (unpack('n',$opt{$k})==0xfeff)) 
        {
            $opt{$k} = decode('UTF-16', $self->{pdf}->{'Info'}->{$k}->val);
        }
      }
  }
  return(%opt);
}
HideShow 13 lines of Pod
=item @meta_data_attribs = $pdf->infoMetaAttributes @meta_data_attribs
Sets/Gets the supported info-structure tags.
B<Example:>
    @attrs = $pdf->infoMetaAttributes;
    print "Supported Attributes: @attr\n";
    @attrs = $pdf->infoMetaAttributes('CustomField1');
    print "Supported Attributes: @attr\n";
=cut
sub infoMetaAttributes 
{
    my ($self,@attr) = @_;
    if(scalar @attr > 0) {
        my %at = map { $_ => $_ } (@{$self->{infoMeta}},@attr);
        @{$self->{infoMeta}}=(keys %at);
    }
    return(@{$self->{infoMeta}});
}
HideShow 26 lines of Pod
=item $xml = $pdf->xmpMetadata $xml
Sets/Gets the XMP XML data-stream.
B<Example:>
    $xml = $pdf->xmpMetadata;
    print "PDFs Metadata reads: $xml\n";
    $xml=<<EOT;
    <?xpacket begin='' id='W5M0MpCehiHzreSzNTczkc9d'?>
    <?adobe-xap-filters esc="CRLF"?>
    <x:xmpmeta xmlns:x='adobe:ns:meta/' x:xmptk='XMP toolkit 2.9.1-14, framework 1.6'>
    <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:iX='http://ns.adobe.com/iX/1.0/'>
    <rdf:Description rdf:about='uuid:b8659d3a-369e-11d9-b951-000393c97fd8' xmlns:pdf='http://ns.adobe.com/pdf/1.3/' pdf:Producer='Acrobat Distiller 6.0.1 for Macintosh'></rdf:Description>
    <rdf:Description rdf:about='uuid:b8659d3a-369e-11d9-b951-000393c97fd8' xmlns:xap='http://ns.adobe.com/xap/1.0/' xap:CreateDate='2004-11-14T08:41:16Z' xap:ModifyDate='2004-11-14T16:38:50-08:00' xap:CreatorTool='FrameMaker 7.0' xap:MetadataDate='2004-11-14T16:38:50-08:00'></rdf:Description>
    <rdf:Description rdf:about='uuid:b8659d3a-369e-11d9-b951-000393c97fd8' xmlns:xapMM='http://ns.adobe.com/xap/1.0/mm/' xapMM:DocumentID='uuid:919b9378-369c-11d9-a2b5-000393c97fd8'/>
    <rdf:Description rdf:about='uuid:b8659d3a-369e-11d9-b951-000393c97fd8' xmlns:dc='http://purl.org/dc/elements/1.1/' dc:format='application/pdf'><dc:description><rdf:Alt><rdf:li xml:lang='x-default'>Adobe Portable Document Format (PDF)</rdf:li></rdf:Alt></dc:description><dc:creator><rdf:Seq><rdf:li>Adobe Systems Incorporated</rdf:li></rdf:Seq></dc:creator><dc:title><rdf:Alt><rdf:li xml:lang='x-default'>PDF Reference, version 1.6</rdf:li></rdf:Alt></dc:title></rdf:Description>
    </rdf:RDF>
    </x:xmpmeta>
    <?xpacket end='w'?>
    EOT
    $xml = $pdf->xmpMetadata($xml);
    print "PDFs Metadata now reads: $xml\n";
     
=cut
sub xmpMetadata {
    my $self=shift @_;
    if(!defined($self->{catalog}->{Metadata})) 
    {
            $self->{catalog}->{Metadata}=PDFDict();
            $self->{catalog}->{Metadata}->{Type}=PDFName('Metadata');
            $self->{catalog}->{Metadata}->{Subtype}=PDFName('XML');
            $self->{pdf}->new_obj($self->{catalog}->{Metadata});
    } 
    else 
    {
        $self->{catalog}->{Metadata}->realise;
        $self->{catalog}->{Metadata}->{' stream'}=unfilter($self->{catalog}->{Metadata}->{Filter}, $self->{catalog}->{Metadata}->{' stream'});
        delete $self->{catalog}->{Metadata}->{' nofilt'};
        delete $self->{catalog}->{Metadata}->{Filter};
    }
     
    my $md=$self->{catalog}->{Metadata};
     
    if(defined $_[0])
    {
        $md->{' stream'}=$_[0];
        delete $md->{Filter};
        delete $md->{' nofilt'};
        $self->{pdf}->out_obj($md);
        $self->{pdf}->out_obj($self->{catalog});
    }
    return($md->{' stream'});
}
HideShow 40 lines of Pod
=item $pdf->pageLabel $index $options
Sets PageLabel options.
B<Supported Options:>
I<-style> ... 'Roman', 'roman', 'decimal', 'Alpha' or 'alpha'.
I<-start> ... restart numbering at given number.
I<-prefix> ... text prefix for numbering.
B<Example:>
        $pdf->pageLabel( 0, {
                -style => 'roman',
        } ); # start with roman numbering
        $pdf->pageLabel( 4, {
                -style => 'decimal',
        } ); # switch to arabic
        $pdf->pageLabel( 32, {
                -start => 1,
                -prefix => 'A-'
        } ); # numbering for appendix A
     
        $pdf->pageLabel( 36, {
                -start => 1,
                -prefix => 'B-'
        } ); # numbering for appendix B
     
        $pdf->pageLabel( 40, {
                -style => 'Roman'
                -start => 1,
                -prefix => 'Index '
        } ); # numbering for index
     
=cut
sub pageLabel {
    my $self=shift @_;
        $self->{catalog}->{PageLabels}||=PDFDict();
        $self->{catalog}->{PageLabels}->{Nums}||=PDFArray();
         
        my $arr=$self->{catalog}->{PageLabels}->{Nums};
        while(scalar @_)
        {
                my $index=shift @_;
                my $opts=shift @_;
                 
                $arr->add_elements(PDFNum($index));
                my $d=PDFDict();
                if($opts->{-style} eq 'Roman')
                {
                        $d->{S}=PDFName('R');
                }
                elsif($opts->{-style} eq 'roman')
                {
                        $d->{S}=PDFName('r');
                }
                elsif($opts->{-style} eq 'Alpha')
                {
                        $d->{S}=PDFName('A');
                }
                elsif($opts->{-style} eq 'alpha')
                {
                        $d->{S}=PDFName('a');
                }
                else
                {
                        $d->{S}=PDFName('D');
                }
                if(defined $opts->{-prefix})
                {
                        $d->{P}=PDFStr($opts->{-prefix});
                }
                if(defined $opts->{-start})
                {
                        $d->{St}=PDFNum($opts->{-start});
                }
                                 
                $arr->add_elements($d);
        }
}
HideShow 14 lines of Pod
=item $pdf->finishobjects @objects
Force objects to be written to file if available.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new(-file => 'our/new.pdf');
    ...
    $pdf->finishobjects($page, $gfx, $txt);
    ...
    $pdf->save;
=cut
sub finishobjects {
    my ($self,@objs)=@_;
    if($self->{reopened}) {
        die "invalid method invokation: no file, use 'saveas' instead.";
    } elsif($self->{' filed'}) {
        $self->{pdf}->ship_out(@objs);
    } else {
        die "invalid method invokation: no file, use 'saveas' instead.";
    }
}
sub proc_pages {
    my ($pdf, $pgs) = @_;
    my ($pg, $pgref, @pglist);
    if(defined($pgs->{Resources})) {
        eval {
            $pgs->{Resources}->realise;
        };
    }
    foreach $pg ($pgs->{'Kids'}->elementsof) {
        $pg->realise;
        if ($pg->{'Type'}->val =~ m/^Pages$/o) 
        {
            my @morepages = proc_pages($pdf, $pg);
            push(@pglist, @morepages);
        } 
        else 
        {
            $pdf->{' apipagecount'}++;
            $pg->{' pnum'} = $pdf->{' apipagecount'};
            if(defined($pg->{Resources})) {
                eval {
                    $pg->{Resources}->realise;
                };
            }
            push (@pglist, $pg);
        }
    }
    return(@pglist);
}
HideShow 12 lines of Pod
=item $pdf->update
Updates a previously "opened" document after all changes have been applied.
B<Example:>
    $pdf = PDF::API3::Compat::API2->open('our/to/be/updated.pdf');
    ...
    $pdf->update;
=cut
sub update {
    my $self=shift @_;
    $self->saveas($self->{pdf}->{' fname'});
}
HideShow 12 lines of Pod
=item $pdf->saveas $file
Saves the document to file.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new();
    ...
    $pdf->saveas("our/new.pdf");
=cut
sub saveas {
    my ($self,$file)=@_;
    if($self->{reopened}) {
        $self->{pdf}->append_file;
        CORE::open(OUTF,">$file");
        binmode(OUTF,':raw');
        print OUTF ${$self->{content_ref}};
        CORE::close(OUTF);
    } elsif($self->{' filed'}) {
        $self->{pdf}->close_file;
    } else {
        $self->{pdf}->out_file($file);
    }
    $self->end;
}
sub save {
    my ($self,$file)=@_;
    if($self->{reopened}) {
        die "invalid method invokation: use 'saveas' instead.";
    } elsif($self->{' filed'}) {
        $self->{pdf}->close_file;
    } else {
        die "invalid method invokation: use 'saveas' instead.";
    }
    $self->end;
}
sub save_xml {
    my ($self,$file)=@_;
    my $fh=IO::File->new;
    $fh->open("> $file");
    $self->{pdf}->save_xml($fh);
    $fh->close;
    $self->end;
}
HideShow 12 lines of Pod
=item $string = $pdf->stringify
Returns the document in a string.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new();
    ...
    print $pdf->stringify;
=cut
sub stringify {
    my ($self)=@_;
    my $str;
    if((defined $self->{reopened}) && ($self->{reopened}==1)) {
        $self->{pdf}->append_file;
        $str=${$self->{content_ref}};
    } else {
        my $fh = new FileHandle;
        CORE::open($fh, ">", \$str) || die "Can't begin scalar IO";
        $self->{pdf}->out_file($fh);
        $fh->close;
    }
    $self->end;
    return($str);
}
sub release { $_[0]->end; return(undef);}
HideShow 6 lines of Pod
=item $pdf->end
Destroys the document.
=cut
sub end {
    my $self=shift(@_);
    $self->{pdf}->release if(defined($self->{pdf}));
        foreach my $key (keys %{$self})
        {
            $self->{$key}=undef;
            delete ($self->{$key});
        }
    undef;
}
HideShow 20 lines of Pod
=back
=head1 PAGE METHODS
=over 4
=item $page = $pdf->page
=item $page = $pdf->page $index
Returns a new page object or inserts-and-returns a new page at $index.
B<Note:> on $index
    -1 ... is inserted before the last page
    1 ... is inserted before page number 1 (the first page)
    0 ... is simply appended
=cut
sub page {
    my $self=shift;
    my $index=shift || 0;
    my $page;
    if($index==0) {
        $page=PDF::API3::Compat::API2::Page->new($self->{pdf},$self->{pages});
    } else {
        $page=PDF::API3::Compat::API2::Page->new($self->{pdf},$self->{pages},$index-1);
    }
    $page->{' apipdf'}=$self->{pdf};
    $page->{' api'}=$self;
    $self->{pdf}->out_obj($page);
    $self->{pdf}->out_obj($self->{pages});
    if($index==0) {
        push(@{$self->{pagestack}},$page);
    } elsif($index<0) {
        splice(@{$self->{pagestack}},$index,0,$page);
    } else {
        splice(@{$self->{pagestack}},$index-1,0,$page);
    }
 #   $page->{Resources}=$self->{pages}->{Resources};
    return $page;
}
HideShow 18 lines of Pod
=item $pageobj = $pdf->openpage $index
Returns the pageobject of page $index.
B<Note:> on $index
    -1,0 ... returns the last page
    1 ... returns page number 1
B<Example:> (A Document with 99 Pages)
    $page = $pdf->openpage(1);   # returns the first page
    $page = $pdf->openpage(99);  # returns the last page
    $page = $pdf->openpage(-1);  # returns the last page
    $page = $pdf->openpage(999); # returns undef
=cut
sub openpage {
    my $self=shift @_;
    my $index=shift @_||0;
    my ($page,$rotate,$media,$trans);
    if($index==0) 
    {
        $page=$self->{pagestack}->[-1];
    } 
    elsif($index<0) 
    {
        $page=$self->{pagestack}->[$index];
    } 
    else 
    {
        $page=$self->{pagestack}->[$index-1];
    }
    return undef unless(ref $page);
     
    if(ref($page) ne 'PDF::API3::Compat::API2::Page') 
    {
        bless($page,'PDF::API3::Compat::API2::Page');
        $page->{' apipdf'}=$self->{pdf};
        $page->{' api'}=$self;
        $self->{pdf}->out_obj($page);
        if(($rotate=$page->find_prop('Rotate')) && (!defined($page->{' fixed'}) || $page->{' fixed'}<1)) 
        {
            $rotate=($rotate->val+360)%360;
            if($rotate!=0 && !$self->default('nounrotate')) {
                $page->{Rotate}=PDFNum(0);
                foreach my $mediatype (qw( MediaBox CropBox BleedBox TrimBox ArtBox )) {
                    if($media=$page->find_prop($mediatype)) {
                        $media=[ map{ $_->val } $media->elementsof ];
                    } else {
                        $media=[0,0,612,792];
                        next if($mediatype ne 'MediaBox');
                    }
                    if($rotate==90) {
                        $trans="0 -1 1 0 0 $media->[2] cm" if($mediatype eq 'MediaBox');
                        $media=[$media->[1],$media->[0],$media->[3],$media->[2]];
                    } elsif($rotate==180) {
                        $trans="-1 0 0 -1 $media->[2] $media->[3] cm" if($mediatype eq 'MediaBox');
                    } elsif($rotate==270) {
                        $trans="0 1 -1 0 $media->[3] 0 cm" if($mediatype eq 'MediaBox');
                        $media=[$media->[1],$media->[0],$media->[3],$media->[2]];
                    }
                    $page->{$mediatype}=PDFArray(map { PDFNum($_) } @{$media});
                }
            } else {
                $trans="";
            }
        } else {
            $trans="";
        }
        if(defined $page->{Contents} && (!defined($page->{' fixed'}) || $page->{' fixed'}<1) ) {
            $page->fixcontents;
            my $uncontent=$page->{Contents};
            delete $page->{Contents};
            my $content=$page->gfx();
            $content->add(" $trans ");
            if($self->default('pageencaps'))
            {
                $content->{' stream'}.=" q ";
            }
            foreach my $k ($uncontent->elementsof) 
            {
                $k->realise;
                    $content->{' stream'}.=" ".unfilter($k->{Filter}, $k->{' stream'})." ";
            }
            if($self->default('pageencaps'))
            {
                $content->{' stream'}.=" Q ";
            }
            ## $content->{Length}=PDFNum(length($content->{' stream'}));
            # this  will be fixed by the following code or content or filters
            ## if we like compress we will do it now to do quicker saves
            if($self->{forcecompress}>0){
            ##    $content->compressFlate;
                $content->{' stream'}=dofilter($content->{Filter}, $content->{' stream'});
                $content->{' nofilt'}=1;
                delete $content->{-docompress};
                $content->{Length}=PDFNum(length($content->{' stream'}));
            }
            $page->{' fixed'}=1;
        }
    }
    $self->{pdf}->out_obj($page);
    $self->{pdf}->out_obj($self->{pages});
    $page->{' apipdf'}=$self->{pdf};
    $page->{' api'}=$self;
    $page->{' reopened'}=1;
    return($page);
}
# $target_object = walk_obj $obj_cache, $source_pdf, $target_pdf, $source_object [, @keys_to_copy ]
sub walk_obj {
    my ($objs,$spdf,$tpdf,$obj,@keys)=@_;
    my $tobj;
    if(ref($obj)=~/Objind$/) {
        $obj->realise;
    }
    return($objs->{scalar $obj}) if(defined $objs->{scalar $obj});
####die "infinite loop while copying objects" if($obj->{' copied'});
    $tobj=$obj->copy($spdf); ## thanks to: yaheath // Fri, 17 Sep 2004
     
####$obj->{' copied'}=1;
    $tpdf->new_obj($tobj) if($obj->is_obj($spdf));
    $objs->{scalar $obj}=$tobj;
    if(ref($obj)=~/Array$/) {
        $tobj->{' val'}=[];
        foreach my $k ($obj->elementsof) {
            $k->realise if(ref($k)=~/Objind$/);
            $tobj->add_elements(walk_obj($objs,$spdf,$tpdf,$k));
        }
    } elsif(ref($obj)=~/Dict$/) {
        @keys=keys(%{$tobj}) if(scalar @keys <1);
        foreach my $k (@keys) {
            next if($k=~/^ /);
            next unless(defined($obj->{$k}));
            $tobj->{$k}=walk_obj($objs,$spdf,$tpdf,$obj->{$k});
        }
        if($obj->{' stream'}) {
            if($tobj->{Filter}) {
                $tobj->{' nofilt'}=1;
            } else {
                delete $tobj->{' nofilt'};
                $tobj->{Filter}=PDFArray(PDFName('FlateDecode'));
            }
            $tobj->{' stream'}=$obj->{' stream'};
        }
    }
    delete $tobj->{' streamloc'};
    delete $tobj->{' streamsrc'};
    return($tobj);
}
HideShow 25 lines of Pod
=item $xoform = $pdf->importPageIntoForm $sourcepdf, $sourceindex
Returns a form-xobject created from $sourcepdf,$sourceindex.
This is useful if you want to transpose the imported page-description
somewhat differently onto a page (ie. two-up, four-up, duplex, etc.).
B<Note:> on $index
    -1,0 ... returns the last page
    1 ... returns page number 1
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $old = PDF::API3::Compat::API2->open('my/old.pdf');
    $xo = $pdf->importPageIntoForm($old,2); # get page 2
    $page = $pdf->page;
    $gfx = $page->gfx;
    $gfx->formimage($xo,0,0,1); # put it on page 1 with scale x1
    $pdf->saveas("our/new.pdf");
B<Note:> you can only import a page from an existing pdf-file!
=cut
sub importPageIntoForm {
    my $self=shift @_;
    my $s_pdf=shift @_;
    my $s_idx=shift @_||0;
        UNIVERSAL::isa($s_pdf, 'PDF::API3::Compat::API2') || die "Invalid usage: 1st argument must be PDF::API3::Compat::API2 instance, not: ".ref($s_pdf);
    my ($s_page,$xo);
    $xo=$self->xo_form;
    if(ref($s_idx) eq 'PDF::API3::Compat::API2::Page') {
        $s_page=$s_idx;
    } else {
        $s_page=$s_pdf->openpage($s_idx);
    }
    $self->{apiimportcache}||={};
    $self->{apiimportcache}->{$s_pdf}||={};
    foreach my $k (qw( MediaBox ArtBox TrimBox BleedBox CropBox )) {
        #next unless(defined $s_page->{$k});
        #my $box = walk_obj($self->{apiimportcache}->{$s_pdf},$s_pdf->{pdf},$self->{pdf},$s_page->{$k});
        next unless(defined $s_page->find_prop($k));
        my $box = walk_obj($self->{apiimportcache}->{$s_pdf},$s_pdf->{pdf},$self->{pdf},$s_page->find_prop($k));
        $xo->bbox(map { $_->val } $box->elementsof);
        last;
    }
    $xo->bbox( 0, 0, 612, 792) unless(defined $xo->{BBox});
    foreach my $k (qw( Resources )) {
        $s_page->{$k}=$s_page->find_prop($k);
        next unless(defined $s_page->{$k});
        $s_page->{$k}->realise if(ref($s_page->{$k})=~/Objind$/);
        foreach my $sk (qw( XObject ExtGState Font ProcSet Properties ColorSpace Pattern Shading )) {
            next unless(defined $s_page->{$k}->{$sk});
            $s_page->{$k}->{$sk}->realise if(ref($s_page->{$k}->{$sk})=~/Objind$/);
            foreach my $ssk (keys %{$s_page->{$k}->{$sk}}) {
                next if($ssk=~/^ /);
                $xo->resource($sk,$ssk,walk_obj($self->{apiimportcache}->{$s_pdf},$s_pdf->{pdf},$self->{pdf},$s_page->{$k}->{$sk}->{$ssk}));
            }
        }
    }
    # create a whole content stream
    ## technically it is possible to submit an unfinished
    ## (eg. newly created) source-page, but thats non-sense,
    ## so we expect a page fixed by openpage and die otherwise
    die "page not processed via openpage ... " unless($s_page->{' fixed'}==1);
    # since the source page comes from openpage it may already
    # contain the required starting 'q' without the final 'Q'
    # if forcecompress is in effect
    if(defined $s_page->{Contents}) {
        $s_page->fixcontents;
        $xo->{' stream'}="";
        # openpage pages only contain one stream
        my ($k)=$s_page->{Contents}->elementsof;
        $k->realise;
        if($k->{' nofilt'}) {
          # we have a finished stream here
          # so we unfilter
          $xo->add('q',unfilter($k->{Filter}, $k->{' stream'}),'Q');
        } else {
          # stream is an unfinished/unfiltered content
          # so we just copy it and add the required "qQ"
            $xo->add('q',$k->{' stream'},'Q');
        }
        $xo->compressFlate if($self->{forcecompress}>0);
    }
    return($xo);
}
HideShow 23 lines of Pod
=item $pageobj = $pdf->importpage $sourcepdf, $sourceindex, $targetindex
Returns the pageobject of page $targetindex, imported from $sourcepdf,$sourceindex.
B<Note:> on $index
    -1,0 ... returns the last page
    1 ... returns page number 1
B<Note:> you can specify a page object instead as $targetindex
so that the contents of the sourcepage will be 'merged into'.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $old = PDF::API3::Compat::API2->open('my/old.pdf');
    $page = $pdf->importpage($old,2); # get page 2 into page 1
    $pdf->saveas("our/new.pdf");
B<Note:> you can only import a page from an existing pdf-file!
=cut
# B<Note:> the interactive forms of a page will also be imported, but may
# cause problems if forms of another document have already been imported.
sub importpage {
    my $self=shift @_;
    my $s_pdf=shift @_;
    my $s_idx=shift @_||0;
    my $t_idx=shift @_||0;
    my ($s_page,$t_page);
        UNIVERSAL::isa($s_pdf, 'PDF::API3::Compat::API2') || die "Invalid usage: 1st argument must be PDF::API3::Compat::API2 instance, not: ".ref($s_pdf);
         
    if(ref($s_idx) eq 'PDF::API3::Compat::API2::Page') {
        $s_page=$s_idx;
    } else {
        $s_page=$s_pdf->openpage($s_idx);
    }
    if(ref($t_idx) eq 'PDF::API3::Compat::API2::Page') {
        $t_page=$t_idx;
    } else {
        if($self->pages<$t_idx) {
            $t_page=$self->page;
        } else {
            $t_page=$self->page($t_idx);
        }
    }
    $self->{apiimportcache}=$self->{apiimportcache}||{};
    $self->{apiimportcache}->{$s_pdf}=$self->{apiimportcache}->{$s_pdf}||{};
    # we now import into a form to keep
    # all that nasty resources from polluting
    # our very own resource naming space.
    my $xo = $self->importPageIntoForm($s_pdf,$s_page);
    $t_page->mediabox( map { $_->val } $xo->{BBox}->elementsof) if(defined $xo->{BBox});
    $t_page->gfx->formimage($xo,0,0,1);
    # copy annotations and/or form elements as well
    if (exists $s_page->{Annots} and $s_page->{Annots} and $self->{copyannots}) {
            # first set up the AcroForm, if required
            my $AcroForm;
            if (my $a = $s_pdf->{pdf}->{Root}->realise->{AcroForm}) {
                    $a->realise;
                    $AcroForm = walk_obj({},$s_pdf->{pdf},$self->{pdf},$a,qw( NeedAppearances SigFlags CO DR DA Q ));
            }
            my @Fields = ();
            my @Annots = ();
            foreach my $a ($s_page->{Annots}->elementsof) {
                    $a->realise;
                    my $t_a = PDFDict();
                    $self->{pdf}->new_obj($t_a);
                    # these objects are likely to be both annotations and Acroform fields
                    # key names are copied from PDF Reference 1.4 (Tables)
                    my @k = (
                            qw( Type Subtype Contents P Rect NM M F BS Border AP AS C CA T Popup A AA StructParent Rotate
                            ),                                      # Annotations - Common (8.10)
                            qw( Subtype Contents Open Name ),       # Text Annotations (8.15)
                            qw( Subtype Contents Dest H PA ),       # Link Annotations (8.16)
                            qw( Subtype Contents DA Q ),            # Free Text Annotations (8.17)
                            qw( Subtype Contents L BS LE IC ) ,     # Line Annotations (8.18)
                            qw( Subtype Contents BS IC ),           # Square and Circle Annotations (8.20)
                            qw( Subtype Contents QuadPoints ),      # Markup Annotations (8.21)
                            qw( Subtype Contents Name ),            # Rubber Stamp Annotations (8.22)
                            qw( Subtype Contents InkList BS ),      # Ink Annotations (8.23)
                            qw( Subtype Contents Parent Open ),     # Popup Annotations (8.24)
                            qw( Subtype FS Contents Name ),         # File Attachment Annotations (8.25)
                            qw( Subtype Sound Contents Name ),      # Sound Annotations (8.26)
                            qw( Subtype Movie Contents A ),         # Movie Annotations (8.27)
                            qw( Subtype Contents H MK ),            # Widget Annotations (8.28)
                                                                    # Printers Mark Annotations (none)
                                                                    # Trap Network Annotations (none)
                    );
                    push @k, (
                            qw( Subtype FT Parent Kids T TU TM Ff V DV AA
                            ),                                      # Fields - Common (8.49)
                            qw( DR DA Q ),                          # Fields containing variable text (8.51)
                            qw( Opt ),                              # Checkbox field (8.54)
                            qw( Opt ),                              # Radio field (8.55)
                            qw( MaxLen ),                           # Text field (8.57)
                            qw( Opt TI I ),                         # Choice field (8.59)
                    ) if $AcroForm;
                    # sorting out dups
                    my %ky=map { $_ => 1 } @k;
                    # we do P separately, as it points to the page the Annotation is on
                    delete $ky{P};
                    # copy everything else
                    foreach my $k (keys %ky) {
                            next unless defined $a->{$k};
                            $a->{$k}->realise;
                            $t_a->{$k} = walk_obj({},$s_pdf->{pdf},$self->{pdf},$a->{$k});
                    }
                    $t_a->{P} = $t_page;
                    push @Annots, $t_a;
                    push @Fields, $t_a if ($AcroForm and $t_a->{Subtype}->val eq 'Widget');
            }
            $t_page->{Annots} = PDFArray(@Annots);
            $AcroForm->{Fields} = PDFArray(@Fields) if $AcroForm;
            $self->{pdf}->{Root}->{AcroForm} = $AcroForm;
    }
    $t_page->{' imported'} = 1;
    $self->{pdf}->out_obj($t_page);
    $self->{pdf}->out_obj($self->{pages});
    return($t_page);
}
HideShow 6 lines of Pod
=item $pagenumber = $pdf->pages
Returns the number of pages in the document.
=cut
sub pages {
    my $self=shift @_;
    return scalar @{$self->{pagestack}};
}
HideShow 28 lines of Pod
=item $pdf->mediabox $name
=item $pdf->mediabox $w, $h
=item $pdf->mediabox $llx, $lly, $urx, $ury
Sets the global mediabox. Other methods: cropbox, bleedbox, trimbox and artbox.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->mediabox('A4');
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->mediabox(595,842);
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->mediabox(0,0,595,842);
    ...
    $pdf->saveas("our/new.pdf");
=cut
sub mediabox {
    my ($self,$x1,$y1,$x2,$y2) = @_;
    $self->{pages}->{'MediaBox'}=PDFArray( map { PDFNum(float($_)) } page_size($x1,$y1,$x2,$y2) );
    $self;
}
HideShow 27 lines of Pod
=item $pdf->cropbox $name
=item $pdf->cropbox $w, $h
=item $pdf->cropbox $llx, $lly, $urx, $ury
Sets the global cropbox.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->cropbox('A4');
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->cropbox(595,842);
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->cropbox(0,0,595,842);
    ...
    $pdf->saveas("our/new.pdf");
=cut
sub cropbox {
    my ($self,$x1,$y1,$x2,$y2) = @_;
    $self->{pages}->{'CropBox'}=PDFArray( map { PDFNum(float($_)) } page_size($x1,$y1,$x2,$y2) );
    $self;
}
HideShow 27 lines of Pod
=item $pdf->bleedbox $name
=item $pdf->bleedbox $w, $h
=item $pdf->bleedbox $llx, $lly, $urx, $ury
Sets the global bleedbox.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->bleedbox('A4');
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->bleedbox(595,842);
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->bleedbox(0,0,595,842);
    ...
    $pdf->saveas("our/new.pdf");
=cut
sub bleedbox {
    my ($self,$x1,$y1,$x2,$y2) = @_;
    $self->{pages}->{'BleedBox'}=PDFArray( map { PDFNum(float($_)) } page_size($x1,$y1,$x2,$y2) );
    $self;
}
HideShow 27 lines of Pod
=item $pdf->trimbox $name
=item $pdf->trimbox $w, $h
=item $pdf->trimbox $llx, $lly, $urx, $ury
Sets the global trimbox.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->trimbox('A4');
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->trimbox(595,842);
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->trimbox(0,0,595,842);
    ...
    $pdf->saveas("our/new.pdf");
=cut
sub trimbox {
    my ($self,$x1,$y1,$x2,$y2) = @_;
    $self->{pages}->{'TrimBox'}=PDFArray( map { PDFNum(float($_)) } page_size($x1,$y1,$x2,$y2) );
    $self;
}
HideShow 27 lines of Pod
=item $pdf->artbox $name
=item $pdf->artbox $w, $h
=item $pdf->artbox $llx, $lly, $urx, $ury
Sets the global artbox.
B<Example:>
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->artbox('A4');
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->artbox(595,842);
    ...
    $pdf->saveas("our/new.pdf");
    $pdf = PDF::API3::Compat::API2->new;
    $pdf->artbox(0,0,595,842);
    ...
    $pdf->saveas("our/new.pdf");
=cut
sub artbox {
    my ($self,$x1,$y1,$x2,$y2) = @_;
    $self->{pages}->{'ArtBox'}=PDFArray( map { PDFNum(float($_)) } page_size($x1,$y1,$x2,$y2) );
    $self;
}
HideShow 13 lines of Pod
=back
=head1 FONT METHODS
=over 4
=item @allFontDirs = PDF::API3::Compat::API2::addFontDirs $dir1, ..., $dirN
Adds one or more directories to the search-path for finding font files.
Returns the list of searched directories.
=cut
sub addFontDirs {
    push( @FontDirs, @_ );
    return( @FontDirs );
}
sub _findFont {
    my $font=shift @_;
    my @fonts=($font,map { "$_/$font" } @FontDirs);
    while((scalar @fonts > 0) && (! -f $fonts[0])) { shift @fonts; }
    return($fonts[0]);
}
HideShow 27 lines of Pod
=item $font = $pdf->corefont $fontname [, %options]
Returns a new adobe core font object.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::Font::CoreFont> for an explanation.
B<Examples:>
    $font = $pdf->corefont('Times-Roman');
    $font = $pdf->corefont('Times-Bold');
    $font = $pdf->corefont('Helvetica');
    $font = $pdf->corefont('ZapfDingbats');
Valid %options are:
  '-encode' ... changes the encoding of the font from its default.
  '-dokern' ... enables kerning if data is available.
=cut
sub corefont {
    my ($self,$name,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::Font::CoreFont->new_api($self,$name,@opts);
    $self->resource('Font',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    $obj->tounicodemap if($opts{-unicodemap}==1);
    return($obj);
}
HideShow 30 lines of Pod
=item $font = $pdf->psfont $psfile  [, %options]
Returns a new adobe type1 font object.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::Font::Postscript> for an explanation.
B<Examples:>
    $font = $pdf->psfont( 'Times-Book.pfa', -afmfile => 'Times-Book.afm' );
    $font = $pdf->psfont( '/fonts/Synest-FB.pfb', -pfmfile => '/fonts/Synest-FB.pfm' );
Valid %options are:
  '-encode' ... changes the encoding of the font from its default.
  '-afmfile' ... specifies that font metrics to be read from the
                adobe font metrics file (AFM).
  '-pfmfile' ... specifies that font metrics to be read from the
                windows printer font metrics file (PFM).
                (this option overrides the -encode option)
  '-dokern' ... enables kerning if data is available.
=cut
sub psfont {
    my ($self,$psf,%opts)=@_;
    foreach my $o (qw(-afmfile -pfmfile)) {
        next unless(defined $opts{$o});
        $opts{$o}=_findFont($opts{$o});
    }
    $psf=_findFont($psf);
    my $obj=PDF::API3::Compat::API2::Resource::Font::Postscript->new_api($self,$psf,%opts);
    $self->resource('Font',$obj->name,$obj,$self->{reopened});
    $self->{pdf}->out_obj($self->{pages});
    $obj->tounicodemap if($opts{-unicodemap}==1);
    return($obj);
}
HideShow 28 lines of Pod
=item $font = $pdf->ttfont $ttfile  [, %options]
Returns a new truetype or opentype font object.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::CIDFont::TrueType> for an explanation.
B<Examples:>
    $font = $pdf->ttfont('Times.ttf');
    $font = $pdf->ttfont('Georgia.otf');
Valid %options are:
  '-encode' ... changes the encoding of the font from its default.
  '-isocmap' ... per default the MS Unicode Map is used, if this 
                 option is given the ISO Unicode Map will be used.
  '-dokern' ... enables kerning if data is available.
  '-noembed' ... disables embedding the fontfile.
=cut
sub ttfont {
    my ($self,$file,%opts)=@_;
    $file=_findFont($file);
    my $obj=PDF::API3::Compat::API2::Resource::CIDFont::TrueType->new_api($self,$file,%opts);
    $self->resource('Font',$obj->name,$obj,$self->{reopened});
    $self->{pdf}->out_obj($self->{pages});
    $obj->tounicodemap if($opts{-unicodemap}==1);
    return($obj);
}
sub nettfont {
    my ($self,$file,%opts)=@_;
    $file=_findFont($file);
    my $obj=PDF::API3::Compat::API2::Resource::Font::neTrueType->new_api($self,$file,%opts);
    $self->resource('Font',$obj->name,$obj,$self->{reopened});
    $self->{pdf}->out_obj($self->{pages});
    $obj->tounicodemap if($opts{-unicodemap}==1);
    return($obj);
}
HideShow 21 lines of Pod
=item $font = $pdf->cjkfont $cjkname  [, %options]
Returns a new cjk font object.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::CIDFont::CJKFont> for an explanation.
B<Examples:>
    $font = $pdf->cjkfont('korean');
    $font = $pdf->cjkfont('traditional');
Valid %options are:
  '-encode' ... changes the encoding of the font from its default.
=cut
sub cjkfont {
    my ($self,$name,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::CIDFont::CJKFont->new_api($self,$name,%opts);
    $self->resource('Font',$obj->name,$obj,$self->{reopened});
    $self->{pdf}->out_obj($self->{pages});
    $obj->tounicodemap if($opts{-unicodemap}==1);
    return($obj);
}
HideShow 33 lines of Pod
=item $font = $pdf->synfont $basefont  [, %options]
Returns a new synthetic font object.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::Font::SynFont> for an explanation.
B<Examples:>
    $cf = $pdf->corefont('Times-Roman',-encode=>'latin1');
    $sf = $pdf->synfont($cf,-slant=>0.85);  # compressed 85%
    $sfb= $pdf->synfont($cf,-bold=>1);      # embolden by 10em
    $sfi= $pdf->synfont($cf,-oblique=>-12); # italic at -12 degrees
Valid %options are:
I<-slant>
... slant/expansion factor (0.1-0.9 = slant, 1.1+ = expansion).
I<-oblique>
... italic angle (+/-)
I<-bold>
... embolding factor (0.1+, bold=1, heavy=2, ...)
I<-space>
... additional charspacing in em (0-1000)
=cut
sub synfont {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::Font::SynFont->new_api($self,@opts);
    $self->resource('Font',$obj->name,$obj,$self->{reopened});
    $self->{pdf}->out_obj($self->{pages});
    $obj->tounicodemap if($opts{-unicodemap}==1);
    return($obj);
}
HideShow 12 lines of Pod
=item $font = $pdf->bdfont $bdffile
Returns a new BDF font object, based on the specified adobe-bdf file.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::Font::BdFont> for an explanation.
=cut
sub bdfont {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::Font::BdFont->new_api($self,@opts);
    $self->resource('Font',$obj->name,$obj,$self->{reopened});
    $self->{pdf}->out_obj($self->{pages});
    ## $obj->tounicodemap; # does not support unicode!
    return($obj);
}
HideShow 18 lines of Pod
=item $font = $pdf->unifont @fontspecs, %options
Returns a new uni-font object, based on the specified fonts and options.
=cut
=pod
B<BEWARE:> This is not a true pdf-object, but a virtual/abstract font-definition !
See L<PDF::API3::Compat::API2::Resource::UniFont> for an explanation.
Valid %options are:
  '-encode' ... changes the encoding of the font from its default.
=cut
sub unifont {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::UniFont->new_api($self,@opts);
    return($obj);
}
HideShow 12 lines of Pod
=back
=head1 IMAGE METHODS
=over 4
=item $jpeg = $pdf->image_jpeg $file
Returns a new jpeg image object.
=cut
sub image_jpeg {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::JPEG->new_api($self,$file);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $tiff = $pdf->image_tiff $file
Returns a new tiff image object.
=cut
sub image_tiff {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::TIFF->new_api($self,$file);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $pnm = $pdf->image_pnm $file
Returns a new pnm image object.
=cut
sub image_pnm {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::PNM->new_api($self,$file);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $png = $pdf->image_png $file
Returns a new png image object.
=cut
sub image_png {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::PNG->new_api($self,$file);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $gif = $pdf->image_gif $file
Returns a new gif image object.
=cut
sub image_gif {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::GIF->new_api($self,$file);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 8 lines of Pod
=item $gdf = $pdf->image_gd $gdobj, %options
Returns a new image object from GD::Image.
B<Options:> The only option currently supported is C<-lossless =E<gt> 1>.
=cut
sub image_gd {
    my ($self,$gd,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::GD->new_api($self,$gd,undef,%opts);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
#=item $img = $pdf->image_rgb $file_or_ref, %options
#
#Returns a new image object from a raw RGB image.
#
#B<Options:> C<-width>, C<-height>, C<-bits> (required).
#
#=cut
#
#sub image_rgb {
#    my ($self,$rgb,@opts)=@_;
#
#    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::RGBA->new_api($self,$rgb,-alpha=>0,@opts);
#
#    $self->resource('XObject',$obj->name,$obj);
#
#    $self->{pdf}->out_obj($self->{pages});
#    return($obj);
#}
#=item $img = $pdf->image_rgba $file_or_ref, %options
#
#Returns a new image object from a raw RGBA image.
#
#B<Options:> C<-width>, C<-height>, C<-bits> (required).
#
#=cut
#
#sub image_rgba {
#    my ($self,$rgb,@opts)=@_;
#
#    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::RGBA->new_api($self,$rgb,-alpha=>1,@opts);
#
#    $self->resource('XObject',$obj->name,$obj);
#
#    $self->{pdf}->out_obj($self->{pages});
#    return($obj);
#}
#=item $img = $pdf->image_cmyk $file_or_ref, %options
#
#Returns a new image object from a raw CMYK image.
#
#B<Options:> C<-width>, C<-height>, C<-bits> (required).
#
#=cut
#
#sub image_cmyk {
#    my ($self,$rgb,@opts)=@_;
#
#    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::CMYKA->new_api($self,$rgb,-alpha=>0,@opts);
#
#    $self->resource('XObject',$obj->name,$obj);
#
#    $self->{pdf}->out_obj($self->{pages});
#    return($obj);
#}
#=item $img = $pdf->image_cmyka $file_or_ref, %options
#
#Returns a new image object from a raw CMYKA image.
#
#B<Options:> C<-width>, C<-height>, C<-bits> (required).
#
#=cut
#
#sub image_cmyka {
#    my ($self,$rgb,@opts)=@_;
#
#    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::CMYKA->new_api($self,$rgb,-alpha=>1,@opts);
#
#    $self->resource('XObject',$obj->name,$obj);
#
#    $self->{pdf}->out_obj($self->{pages});
#    return($obj);
#}
#=item $img = $pdf->image_indexed $file_or_ref, %options
#
#Returns a new image object from a raw indexed image.
#
#B<Options:> C<-width>, C<-height>, C<-bits>, C<-colorspace> (required).
#
#=cut
#
#sub image_indexed {
#    my ($self,$rgb,@opts)=@_;
#
#    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::Indexed->new_api($self,$rgb,-alpha=>0,@opts);
#
#    $self->resource('XObject',$obj->name,$obj);
#
#    $self->{pdf}->out_obj($self->{pages});
#    return($obj);
#}
#=item $img = $pdf->image_indexedalpha $file_or_ref, %options
#
#Returns a new image object from a raw indexed-alpha image.
#
#B<Options:> C<-width>, C<-height>, C<-bits>, C<-colorspace> (required).
#
#=cut
#
#sub image_indexedalpha {
#    my ($self,$rgb,@opts)=@_;
#
#    my $obj=PDF::API3::Compat::API2::Resource::XObject::Image::Indexed->new_api($self,$rgb,-alpha=>1,@opts);
#
#    $self->resource('XObject',$obj->name,$obj);
#
#    $self->{pdf}->out_obj($self->{pages});
#    return($obj);
#}
HideShow 29 lines of Pod
=pod
B<Examples:>
    $jpeg = $pdf->image_jpeg('../some/nice/picture.jpeg');
    $tiff = $pdf->image_tiff('../some/nice/picture.tiff');
    $pnm = $pdf->image_pnm('../some/nice/picture.pnm');
    $png = $pdf->image_png('../some/nice/picture.png');
    $gif = $pdf->image_gif('../some/nice/picture.gif');
    $gdf = $pdf->image_gd($gdobj);
=back
=head1 COLORSPACE METHODS
=over 4
=item $cs = $pdf->colorspace_act $file
Returns a new colorspace-object based on a adobe-color-table file.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::ACTFile> for an explanation of the file format.
=cut
sub colorspace_act {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::ACTFile->new_api($self,$file);
    $self->resource('ColorSpace',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 12 lines of Pod
=item $cs = $pdf->colorspace_web
Returns a new colorspace-object based on the web color palette.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::WebColor> for an explanation.
=cut
sub colorspace_web {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::WebColor->new_api($self);
    $self->resource('ColorSpace',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 12 lines of Pod
=item $cs = $pdf->colorspace_hue
Returns a new colorspace-object based on the hue color palette.
=cut
=pod
See L<PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::Hue> for an explanation.
=cut
sub colorspace_hue {
    my ($self,$file,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::ColorSpace::Indexed::Hue->new_api($self);
    $self->resource('ColorSpace',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 18 lines of Pod
=item $cs = $pdf->colorspace_separation $tint, $color
Returns a new separation colorspace-object based on the parameters.
=cut
=pod
I<$tint> can be any valid ink-identifier, including but not limited to:
'Cyan', 'Magenta', 'Yellow', 'Black', 'Red', 'Green', 'Blue' or 'Orange'.
I<$color> must be a valid color-specification limited to:
'#rrggbb', '!hhssvv', '%ccmmyykk' or a "named color" (rgb).
The colorspace model for will be automatically chosen based on the specified color.
=cut
sub colorspace_separation {
    my ($self,$name,@clr)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::ColorSpace::Separation->new_api($self,$name,@clr);
    $self->resource('ColorSpace',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 22 lines of Pod
=item $cs = $pdf->colorspace_devicen \@tintCSx [, $samples]
Returns a new DeviceN colorspace-object based on the parameters.
B<Example:> 
    $cy = $pdf->colorspace_separation('Cyan',    '%f000');
    $ma = $pdf->colorspace_separation('Magenta', '%0f00');
    $ye = $pdf->colorspace_separation('Yellow',  '%00f0');
    $bk = $pdf->colorspace_separation('Black',   '%000f');
    $pms023 = $pdf->colorspace_separation('PANTONE 032CV', '%0ff0');
    $dncs = $pdf->colorspace_devicen( [ $cy,$ma,$ye,$bk,$pms023 ] );
     
=cut
=pod
The colorspace model for will be automatically chosen based on the first colorspace specified.
=cut
sub colorspace_devicen {
    my ($self,$clrs,$samples)=@_;
    $samples||=2;
     
    my $obj=PDF::API3::Compat::API2::Resource::ColorSpace::DeviceN->new_api($self,$clrs,$samples);
    $self->resource('ColorSpace',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 20 lines of Pod
=back
=head1 BARCODE METHODS
=over 4
=item $bc = $pdf->xo_codabar %opts
=item $bc = $pdf->xo_code128 %opts
=item $bc = $pdf->xo_2of5int %opts
=item $bc = $pdf->xo_3of9 %opts
=item $bc = $pdf->xo_ean13 %opts
creates the specified barcode object as a form-xo.
=cut
sub xo_code128 {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::code128->new_api($self,@opts);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
sub xo_codabar {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::codabar->new_api($self,@opts);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
sub xo_2of5int {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::int2of5->new_api($self,@opts);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
sub xo_3of9 {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::code3of9->new_api($self,@opts);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
sub xo_ean13 {
    my ($self,@opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Form::BarCode::ean13->new_api($self,@opts);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 16 lines of Pod
=back
=head1 OTHER METHODS
=over 4
=item $xo = $pdf->xo_form
Returns a new form-xobject.
B<Examples:>
    $xo = $pdf->xo_form;
=cut
sub xo_form {
    my ($self)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::XObject::Form::Hybrid->new_api($self);
    $self->resource('XObject',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 10 lines of Pod
=item $egs = $pdf->egstate
Returns a new extended graphics state object.
B<Examples:>
    $egs = $pdf->egstate;
=cut
sub egstate {
    my ($self)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::ExtGState->new_api($self,pdfkey());
    $self->resource('ExtGState',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $obj = $pdf->pattern
Returns a new pattern-object.
=cut
sub pattern {
    my ($self,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::Pattern->new_api($self,undef,%opts);
    $self->resource('Pattern',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $obj = $pdf->shading
Returns a new shading-object.
=cut
sub shading {
    my ($self,%opts)=@_;
    my $obj=PDF::API3::Compat::API2::Resource::Shading->new_api($self,undef,%opts);
    $self->resource('Shading',$obj->name,$obj);
    $self->{pdf}->out_obj($self->{pages});
    return($obj);
}
HideShow 6 lines of Pod
=item $otls = $pdf->outlines
Returns a new or existing outlines object.
=cut
sub outlines {
    my ($self)=@_;
    $self->{pdf}->{Root}->{Outlines}||=PDF::API3::Compat::API2::Outlines->new($self);
    my $obj=$self->{pdf}->{Root}->{Outlines};
    $self->{pdf}->new_obj($obj) if(!$obj->is_obj($self->{pdf}));
    $self->{pdf}->out_obj($obj);
    $self->{pdf}->out_obj($self->{pdf}->{Root});
    return($obj);
}
#=item $dst $pdf->named_destination $category, $name
#
#Returns a new or existing outlines object.
#
#=cut
sub named_destination
{
    my ($self,$cat,$name,$obj)=@_;
    my $root=$self->{catalog};
    $root->{Names}||=PDFDict();
    $root->{Names}->{$cat}||=PDFDict();
    $root->{Names}->{$cat}->{-vals}||={};
    $root->{Names}->{$cat}->{Limits}||=PDFArray();
    $root->{Names}->{$cat}->{Names}||=PDFArray();
     
    unless(defined $obj)
    {
        $obj=PDF::API3::Compat::API2::NamedDestination->new_api($self);
    }
    $root->{Names}->{$cat}->{-vals}->{$name}=$obj;
     
    my @names=sort {$a cmp $b} keys %{$root->{Names}->{$cat}->{-vals}};
     
    $root->{Names}->{$cat}->{Limits}->{' val'}->[0]=PDFStr($names[0]);
    $root->{Names}->{$cat}->{Limits}->{' val'}->[1]=PDFStr($names[-1]);
     
    @{$root->{Names}->{$cat}->{Names}->{' val'}}=();
     
    foreach my $k (@names)
    {
        push @{$root->{Names}->{$cat}->{Names}->{' val'}},
            PDFStr($k),$root->{Names}->{$cat}->{-vals}->{$k};
    }
    return($obj);
}
HideShow 23 lines of Pod
=back
=head1 RESOURCE METHODS
=over 4
=item $pdf->resource $type, $key, $obj, $force
Adds a resource to the global pdf tree.
B<Example:>
    $pdf->resource('Font',$fontkey,$fontobj);
    $pdf->resource('XObject',$imagekey,$imageobj);
    $pdf->resource('Shading',$shadekey,$shadeobj);
    $pdf->resource('ColorSpace',$spacekey,$speceobj);
B<Note:> You only have to add the required resources, if
they are NOT handled by the *font*, *image*, *shade* or *space*
methods.
=cut
sub resource 
{
    return(undef);
    my ($self, $type, $key, $obj, $force) = @_;
    $self->{pages}->{Resources}||=PDFDict();
    my $dict=$self->{pages}->{Resources};
    $dict->realise if(ref($dict)=~/Objind$/);
    $self->{pdf}->new_obj($dict) unless($dict->is_obj($self->{pdf}));
    $dict->{$type}=$dict->{$type} || PDFDict();
    $dict->{$type}->realise if(ref($dict->{$type})=~/Objind$/);
    if(defined($obj)) 
    {
        if($force) 
        {
            $dict->{$type}->{$key}=$obj;
        } 
        else 
        {
            $dict->{$type}->{$key}=$dict->{$type}->{$key} || $obj;
        }
        $self->{pdf}->out_obj($dict)
            if($dict->is_obj($self->{pdf}));
        $self->{pdf}->out_obj($dict->{$type})
            if($dict->{$type}->is_obj($self->{pdf}));
        $self->{pdf}->out_obj($obj)
            if($obj->is_obj($self->{pdf}));
        $self->{pdf}->out_obj($self->{pages});
        return($dict);
    }
    return($dict->{$type}->{$key} || undef);
}
1;
__END__
HideShow 266 lines of Pod
=back
=head1 BUGS
This module does not work with perl's -l commandline switch.
=head1 AUTHOR
alfred reibenschuh
=head1 HISTORY
    $Log: API2.pm,v $
    Revision 2.15  2008/01/18 00:11:38  areibens
    fixed catalog update and infohash utf16 from http://bugs.debian.org/461167
    Revision 2.14  2007/11/16 19:30:31  areibens
    added -noembed option
    Revision 2.13  2007/11/14 23:01:32  areibens
    fixed relative page insert
    Revision 2.12  2007/11/14 22:49:49  areibens
    added non-embedded truetype font (8-bit only) support
    Revision 2.11  2007/09/18 22:29:31  areibens
    added -printscalingnone option
    Revision 2.10  2007/08/01 23:12:08  areibens
    fix BOM in info strings
    Revision 2.9  2007/05/16 21:45:32  areibens
    fixed importpage doku bug http://rt.cpan.org/Ticket/Display.html?id=27152
    Revision 2.8  2007/05/10 23:38:38  areibens
    added note on importintoform and importpage for existing pdf-file
    Revision 2.7  2007/05/08 18:32:10  areibens
    renamed compress to compressFlate
    Revision 2.6  2007/05/07 20:33:46  areibens
    fix tounicode option
    Revision 2.5  2007/03/17 20:07:21  areibens
    fixed open to CORE::open
    Revision 2.4  2007/03/16 15:28:30  areibens
    replaced IOString dep. with scalar IO.
    Revision 2.3  2007/03/15 14:15:19  areibens
    added pageLabel method
    Revision 2.2  2007/03/14 19:30:25  areibens
    fixed -twocolumnright option typo
    Revision 2.1  2007/02/22 08:00:37  areibens
    changed import* methods to check its first arg -- thanks alankila2@yahoo.ca
    Revision 2.0  2005/11/16 02:16:00  areibens
    revision workaround for SF cvs import not to screw up CPAN
    Revision 1.2  2005/11/16 01:27:48  areibens
    genesis2
    Revision 1.1  2005/11/16 01:19:24  areibens
    genesis
    Revision 1.86  2005/10/21 19:51:05  fredo
    fixed proc_pages
    Revision 1.85  2005/10/20 21:06:39  fredo
    documented '-dokern' option for ttfonts
    Revision 1.84  2005/10/19 21:23:26  fredo
    documented '-dokern' option for core- and psfonts
    Revision 1.83  2005/09/12 16:54:21  fredo
    added -isocmap option
    Revision 1.82  2005/06/17 19:43:45  fredo
    fixed CPAN modulefile versioning (again)
    Revision 1.81  2005/06/17 18:53:04  fredo
    fixed CPAN modulefile versioning (dislikes cvs)
    Revision 1.80  2005/06/10 16:12:49  fredo
    documentation update
    Revision 1.79  2005/03/23 16:42:06  fredo
    fixed typo in infoMetaAttributes
    Revision 1.78  2005/03/21 22:36:36  fredo
    fix for landscape imports
    Revision 1.77  2005/03/15 17:31:06  fredo
    corrected utf8 handling in info tags
    Revision 1.76  2005/03/14 23:53:51  fredo
    added xmpMetadata method to get/set XMP document data
    Revision 1.75  2005/03/14 22:01:05  fredo
    upd 2005
    Revision 1.74  2005/02/25 18:07:48  fredo
    no message
    Revision 1.73  2005/02/17 07:03:14  fredo
    added 'pageencaps' default option to fix unusual styled content streams
    Revision 1.72  2005/02/14 20:09:48  fredo
    fixed an openpage recompression bug / thanks to steve_wu@iinet.net.au
    Revision 1.71  2005/01/03 03:47:52  fredo
    fixed use named destination
    Revision 1.70  2005/01/03 03:46:25  fredo
    added named destination support
    Revision 1.69  2004/12/31 03:12:09  fredo
    no message
    Revision 1.68  2004/12/16 00:30:51  fredo
    added no warn for recursion
    Revision 1.67  2004/11/29 15:19:23  fredo
    added docs for bdfont, synfont and unifont
    Revision 1.66  2004/11/24 20:09:57  fredo
    added unifont
    Revision 1.65  2004/10/17 03:57:21  fredo
    added ToUnicode call for supported fonts
    Revision 1.64  2004/10/01 01:39:24  fredo
    reverted annotations import fix
    Revision 1.63  2004/09/30 23:57:26  fredo
    versioning beautify
    Revision 1.62  2004/09/30 22:40:41  fredo
    fixed pdf-producer to include OS
    Revision 1.61  2004/09/30 21:18:21  fredo
    changed file version back to cvs
    Revision 1.60  2004/09/20 11:22:18  fredo
    added default param to fix import-rotation
    added default param to fix annotation-import
    Revision 1.59  2004/09/03 12:35:09  fredo
    pop'd to new version
    Revision 1.58  2004/08/25 02:59:25  fredo
    disabled memoize since long-running scripts bug from reused adresses
    Revision 1.57  2004/07/24 23:10:55  fredo
    fixed memoize bug for bdf fonts
    Revision 1.56  2004/07/24 23:09:26  fredo
    added bdf fonts
    Revision 1.55  2004/07/23 13:41:11  fredo
    fixed in decoding info dictionary
    Revision 1.54  2004/07/21 08:07:17  fredo
    added devicen colorspace
    Revision 1.53  2004/07/15 14:28:21  fredo
    added devicen colorspace
    Revision 1.52  2004/06/22 01:33:43  fredo
    corrected spelling
    Revision 1.51  2004/06/21 22:33:10  fredo
    added basic pattern/shading handling
    Revision 1.50  2004/06/15 09:06:26  fredo
    forced version to 1.50 for beta state
    Revision 1.30  2004/06/15 08:09:07  fredo
    fixed memoized bug
    Revision 1.29  2004/06/01 00:09:57  fredo
    memoized *font methods for braindead invokers
    Revision 1.28  2004/05/28 11:29:01  fredo
    added -lossless param to gd images
    Revision 1.27  2004/05/21 10:12:29  fredo
    fixed slight importpage quirk
    Revision 1.26  2004/04/18 18:07:19  fredo
    fixed _findFont method
    Revision 1.25  2004/04/07 17:38:00  fredo
    added infoMetaAttributes and support code
    Revision 1.24  2004/04/07 10:48:53  fredo
    fixed handling of ColorSpace/Separation
    Revision 1.23  2004/04/06 21:00:52  fredo
    separation colorspace now a full resource
    Revision 1.22  2004/04/04 23:42:10  fredo
    fixed 270 degree rotation in openpage
    Revision 1.21  2004/04/04 23:36:33  fredo
    added simple separation colorspace
    Revision 1.20  2004/03/20 09:11:45  fredo
    modified font search path methodname
    Revision 1.19  2004/03/20 08:38:38  fredo
    added isEncrypted determinator
    Revision 1.18  2004/03/18 09:43:32  fredo
    added font search path handling
    Revision 1.17  2004/02/12 14:38:33  fredo
    added openScalar method
    Revision 1.16  2004/02/05 13:18:39  fredo
    corrected info hash utf8 usage
    Revision 1.15  2004/02/04 23:43:53  fredo
    pdf info method now properly recognized utf8 parameters
    Revision 1.14  2004/01/21 12:29:06  fredo
    moved release versioning to PDF::API3::Compat::API2::Version
    Revision 1.13  2004/01/19 14:16:32  fredo
    update for 0.40_16
    Revision 1.12  2004/01/15 21:26:04  fredo
    docbug: fixed inconsistent links
    Revision 1.11  2004/01/14 18:25:41  fredo
    release update 0.40_15
    Revision 1.10  2004/01/12 13:52:41  fredo
    update for 0.40_14
    Revision 1.9  2004/01/08 23:56:20  fredo
    corrected producer tag versioning, updated to release 0.40_13
    Revision 1.8  2003/12/08 13:05:18  Administrator
    corrected to proper licencing statement
    Revision 1.7  2003/12/08 11:47:38  Administrator
    change step 3 for proper module versioning
    Revision 1.6  2003/12/08 11:46:25  Administrator
    change step 2 for proper module versioning
    Revision 1.5  2003/12/08 11:43:10  Administrator
    change step 1 for proper module versioning
    Revision 1.4  2003/11/30 19:00:43  Administrator
    added Code128/EAN128
    Revision 1.3  2003/11/30 17:07:11  Administrator
    merged into default
=cut