package PDF::Report;
use strict;
=head1 NAME
PDF::Report - A wrapper written for PDF::API2
=head1 SYNOPSIS
use PDF::Report;
my $pdf = new PDF::Report(%opts);
=head1 DESCRIPTION
This is a wrapper for Alfred Reibenschuh's PDF::API2
Defines methods to create PDF reports
=head1 VERSION
1.34
=cut
our $VERSION = "1.34";
use strict;
use PDF::API2;
### GLOBAL SECTION ############################################################
# Sane defaults
my %DEFAULTS;
$DEFAULTS{PageSize}='letter';
$DEFAULTS{PageOrientation}='Portrait';
$DEFAULTS{Compression}=1;
$DEFAULTS{PdfVersion}=3;
$DEFAULTS{marginX}=30;
$DEFAULTS{marginY}=30;
$DEFAULTS{font}="Helvetica";
$DEFAULTS{size}=12;
my ( $day, $month, $year )= ( localtime( time ) )[3..5];
my $DATE=sprintf "%02d/%02d/%04d", ++$month, $day, 1900 + $year;
# Document info
my @parameterlist=qw(
PageSize
PageWidth
PageHeight
PageOrientation
Compression
PdfVersion
);
### END GLOBALS ###############################################################
### GLOBAL SUBS ###############################################################
=head1 METHODS
=head2 new
my $pdf = new PDF::Report(%opts);
Creates a new pdf report object.
If no %opts are specified the module
will use the factory defaults.
B<Example:>
my $pdf = new PDF::Report(PageSize => "letter",
PageOrientation => "Landscape");
my $pdf = new PDF::Report(File => $file);
%opts:
PageSize - '4A', '2A', 'A0', 'A1', 'A2',
'A3', 'A4', 'A5', 'A6', '4B',
'2B', 'B0', 'B1', 'B2', 'B3',
'B4', 'B5', 'B6', 'LETTER',
'BROADSHEET', 'LEDGER', 'TABLOID',
'LEGAL', 'EXECUTIVE', '36X36'
PageOrientation - 'Portrait', 'Landscape'
=cut
# Create a new PDF document
sub new {
my $class = shift;
my %defaults = @_;
foreach my $dflt (@parameterlist) {
if (defined($defaults{$dflt})) {
$DEFAULTS{$dflt} = $defaults{$dflt}; # Overridden from user
}
}
my $pageWidth;
my $pageHeight;
my $x1;
my $y1;
if ( ref $DEFAULTS{PageSize} eq "ARRAY" ) {
($pageWidth, $pageHeight) = @{$DEFAULTS{PageSize}};
}
else {
# Set the width and height of the page
($x1, $y1, $pageWidth, $pageHeight) =
PDF::API2::Util::page_size($DEFAULTS{PageSize});
}
# Swap w and h if landscape
if (lc($DEFAULTS{PageOrientation})=~/landscape/) {
my $tempW = $pageWidth;
$pageWidth = $pageHeight;
$pageHeight = $tempW;
$tempW = undef;
}
my $MARGINX = $DEFAULTS{marginX};
my $MARGINY = $DEFAULTS{marginY};
# May not need alot of these, will review later
my $self= { #pdf => PDF::API2->new(),
hPos => undef,
vPos => undef,
size => 12, # Default
font => undef, # the font object
PageWidth => $pageWidth,
PageHeight => $pageHeight,
Xmargin => $MARGINX,
Ymargin => $MARGINY,
BodyWidth => $pageWidth - $MARGINX * 2,
BodyHeight => $pageHeight - $MARGINY * 2,
page => undef, # the current page object
page_nbr => 1,
align => 'left',
linewidth => 1,
linespacing => 0,
FtrFontName => 'Helvetica-Bold',
FtrFontSize => 11,
MARGIN_DEBUG => 0,
PDF_API2_VERSION => $PDF::API2::VERSION,
INFO => {
Creator => "None",
Producer => "None",
CreationDate => $DATE,
Title => "Untitled",
Subject => "None",
Author => "Auto-generated",
},
########################################################
# Cache for font object caching -- used by setFont() ###
########################################################
__font_cache => {},
};
if (defined $defaults{File} && length($defaults{File})) {
$self->{pdf} = PDF::API2->open($defaults{File})
or die "$defaults{File} not found: $!\n";
} else {
$self->{pdf} = PDF::API2->new();
}
# Default fonts
$self->{font} = $self->{pdf}->corefont('Helvetica'); # Default font object
#$self->{font}->encode('latin1');
# Set the users options
foreach my $key (keys %defaults) {
$self->{$key}=$defaults{$key};
}
bless $self, $class;
return $self;
}
=head2 newpage
$pdf->newpage($nopage);
Creates a new blank page. Pass $nopage = 1 to toggle page numbering.
=cut
sub newpage {
my $self = shift;
my $no_page_number = shift;
# make a new page
$self->{page} = $self->{pdf}->page;
$self->{page}->mediabox($self->{PageWidth}, $self->{PageHeight});
# Handle the page numbering if this page is to be numbered
my $total = $self->pages;
push(@{$self->{no_page_num}}, $no_page_number);
$self->{page_nbr}++;
return(0);
}
=head2 openpage
$pdf->openpage($index);
If no index is specified, this will open the last page of the document.
=cut
sub openpage {
my $self = shift;
my $index = shift;
my $totpgs = $self->{pdf}->pages;
$index = $totpgs if (!defined $index or
$index =~ /[^\d]/ or
$index > $totpgs);
$self->{page} = $self->{pdf}->openpage($index);
}
=head2 importpage
Import page from another PDF document, see PDF::API2
=cut
sub importpage {
my $self = shift;
my $sourcepdf = shift;
my $sourceindex = shift;
my $targetindex = shift; # can be a page object
# my $source = $self->{pdf}->open($sourcepdf);
$self->{page} = $self->{pdf}->importpage($sourcepdf, $sourceindex,
$targetindex);
}
=head2 clonepage
Clone page within document, see PDF::API2
=cut
sub clonepage {
my $self = shift;
my $sourceindex = shift;
my $targetindex = shift;
$self->{page} = $self->{pdf}->clonepage($sourceindex, $targetindex);
}
=head2 getPageDimensions
($pagewidth, $pageheight) = $pdf->getPageDimensions();
Returns the width and height of the page according to what page size chosen
in "new".
=cut
sub getPageDimensions {
my $self = shift;
return($self->{PageWidth}, $self->{PageHeight});
}
=head2 addRawText
$pdf->addRawText($text, $x, $y, $color, $underline, $indent, $rotate);
Add $text at position $x, $y with $color, $underline, $indent and/or $rotate.
=cut
# This positions string $text at $x, $y
sub addRawText {
my ( $self, $text, $x, $y, $color, $underline, $indent, $rotate ) = @_;
$color = undef if defined $color && !length($color);
$underline = undef if defined $underline && !length($underline);
$indent = undef if defined $indent && !length($indent);
my $txt = $self->{page}->text;
# $txt->font($self->{font}, $self->{size});
# $txt->transform_rel(-translate => [$x, $y], -rotate => $rotate);
# $txt->text($text, -color=>[$color], -underline=>$underline,
# -indent=>$indent);
$txt->textlabel($x, $y, $self->{font}, $self->{size}, $text,
-rotate => $rotate,
-color => $color, -underline=>$underline, -indent=>$indent);
}
=pod
PDF::API2 Removes all space between every word in the string you pass
and then rejoins each word with one space. If you want to use a string with
more than one space between words for formatting purposes, you can either use
the hack below or change PDF::API2 (that's what I did ;). The code below may
or may not work according to what font you are using. I used 2 \xA0 per space
because that worked for the Helvetica font I was using.
B<To use a fixed width string with more than one space between words, you can do something like:>
sub replaceSpace {
my $text = shift;
my $nbsp = "\xA0";
my $new = '';
my @words = split(/ /, $text);
foreach my $word (@words) {
if (length($word)) {
$new.=$word . ' ';
} else {
$new.=$nbsp . $nbsp;
}
}
chop($new);
return $new;
}
=head2 setAddTextPos
$pdf->setAddTextPos($hPos, $vPos);
Set the position on the page. Used by the addText function.
=cut
sub setAddTextPos {
my ($self, $hPos, $vPos) = @_;
$self->{hPos}=$hPos;
$self->{vPos}=$vPos;
}
=head2 getAddTextPos
($hPos, $vPos) = $pdf->getAddTextPos();
Return the (x, y) value of the text position.
=cut
sub getAddTextPos {
my ($self) = @_;
return($self->{hPos}, $self->{vPos});
}
=head2 setAlign
$pdf->setAlign($align);
Set the justification of the text. Used by the addText function.
=cut
sub setAlign {
my $self = shift;
my $align = lc(shift);
if ($align=~m/^left$|^right$|^center$/) {
$self->{align}=$align;
$self->{hPos}=undef; # Clear addText()'s tracking of hPos
}
}
=head2 getAlign
$align = $pdf->getAlign();
Returns the text justification.
=cut
sub getAlign {
my $self= shift @_;
return($self->{align});
}
=head2 wrapText
$newtext = $pdf->wrapText($text, $width);
This is a helper function called by addText, which can be called by itself.
wrapText() wraps $text within $width.
=cut
sub wrapText {
my $self = shift;
my $text = shift;
my $width = shift;
$text = '' if !length($text);
return $text if ($text =~ /\n/); # We don't wrap text with carriage returns
return $text unless defined $width; # If no width was specified, return text
my $txt = $self->{page}->text;
$txt->font($self->{font}, $self->{size});
my $ThisTextWidth=$txt->advancewidth($text);
return $text if ( $ThisTextWidth <= $width);
my $widSpace = $txt->advancewidth('t'); # 't' closest width to a space
my $currentWidth = 0;
my $newText = "";
foreach ( split / /, $text ) {
my $strWidth = $txt->advancewidth($_);
if ( ( $currentWidth + $strWidth ) > $width ) {
$currentWidth = $strWidth + $widSpace;
$newText .= "\n$_ ";
} else {
$currentWidth += $strWidth + $widSpace;
$newText .= "$_ ";
}
}
return $newText;
}
=head2 addText
$pdf->addText($text, $hPos, $textWidth, $textHeight);
Takes $text and prints it to the current page at $hPos. You may just want
to pass this function $text if the text is "pre-wrapped" and setAddTextPos
has been called previously. Pass a $hPos to change the position the text
will be printed on the page. Pass a $textWidth and addText will wrap the
text for you. $textHeight controls the row height.
=cut
sub addText {
my ( $self, $text, $hPos, $textWidth, $textHeight )= @_;
my $txt = $self->{page}->text;
$txt->font($self->{font}, $self->{size});
# Push the margin on for align=left (need to work on align=right)
if ( ($hPos=~/^[0-9]+([.][0-9]+)?$/) && ($self->{align}=~ /^left$/i) ) {
$self->{hPos}=$hPos + $self->{Xmargin};
}
# Establish a proper $self->{hPos} if we don't have one already
if ($self->{hPos} !~ /^[0-9]+([.][0-9]+)?$/) {
if ($self->{align}=~ /^left$/i) {
$self->{hPos} = $self->{Xmargin};
} elsif ($self->{align}=~ /^right$/i) {
$self->{hPos} = $self->{PageWidth} - $self->{Xmargin};
} elsif ($self->{align}=~ /^center$/i) {
$self->{hPos} = int($self->{PageWidth} / 2);
}
}
# If the user did not give us a $textWidth, use the distance
# from $hPos to the right margin as the $textWidth for align=left,
# use the distance from $hPos back to the left margin for align=right
if ( ($textWidth !~ /^[0-9]+$/) && ($self->{align}=~ /^left$/i) ) {
$textWidth = $self->{BodyWidth} - $self->{hPos} + $self->{Xmargin};
} elsif ( ($textWidth !~ /^[0-9]+$/) && ($self->{align}=~ /^right$/i) ) {
$textWidth = $self->{hPos} + $self->{Xmargin};
} elsif ( ($textWidth !~ /^[0-9]+$/) && ($self->{align}=~ /^center$/i) ) {
my $textWidthL=$self->{BodyWidth} - $self->{hPos} + $self->{Xmargin};
my $textWidthR=$self->{hPos} + $self->{Xmargin};
$textWidth = $textWidthL;
if ($textWidthR < $textWidth) { $textWidth = $textWidthR; }
$textWidth = $textWidth * 2;
}
# If $self->{vPos} is not set calculate it (on first text add)
if ( (!defined $self->{vPos} ) || ($self->{vPos} == 0) ) {
$self->{vPos} = $self->{PageHeight} - $self->{Ymargin} - $self->{size};
}
# If the text has no carrige returns we may need to wrap it for the user
if ( $text !~ /\n/ ) {
$text = $self->wrapText($text, $textWidth);
}
if ( $text !~ /\n/ ) {
# Determine the width of this text
my $thistextWidth = $txt->advancewidth($text);
# If align ne 'left' (the default) then we need to recalc the xPos
# for this call to addRawText() -- needs attention
my $xPos=$self->{hPos};
if ($self->{align}=~ /^right$/i) {
$xPos=$self->{hPos} - $thistextWidth;
} elsif ($self->{align}=~ /^center$/i) {
$xPos=$self->{hPos} - $thistextWidth / 2;
}
$self->addRawText($text,$xPos,$self->{vPos});
$thistextWidth = -1 * $thistextWidth if ($self->{align}=~ /^right$/i);
$thistextWidth = -1 * $thistextWidth / 2 if ($self->{align}=~ /^center$/i);
$self->{hPos} += $thistextWidth;
} else {
$text=~ s/\n/\0\n/g; # This copes w/strings of only "\n"
my @lines= split /\n/, $text;
foreach ( @lines ) {
$text= $_;
$text=~ s/\0//;
if (length( $text )) {
$self->addRawText($text, $self->{hPos}, $self->{vPos});
}
if (($self->{vPos} - $self->{size}) < $self->{Ymargin}) {
$self->{vPos} = $self->{PageHeight} - $self->{Ymargin} - $self->{size};
$self->newpage;
} else {
$textHeight = $self->{size} unless $textHeight;
$self->{vPos} -= $self->{size} - $self->{linespacing};
}
}
}
}
=head2 addParagraph
$pdf->addParagraph($text, $hPos, $vPos, $width, $height, $indent, $lead);
Add $text at ($hPos, $vPos) within $width and $height, with $indent.
$indent is the number of spaces at the beginning of the first line.
=cut
sub addParagraph {
my ( $self, $text, $hPos, $vPos, $width, $height, $indent, $lead ) = @_;
my $txt = $self->{page}->text;
$txt->font($self->{font}, $self->{size});
# $txt->paragraph($text, -x => $hPos, -y => $vPos, -w => $width,
# -h => $height, -flindent => $indent, -lead => $lead, -rel => 1);
# 0.40.x
$txt->lead($lead); # Line spacing
$txt->translate($hPos,$vPos);
$txt->paragraph($text, $width, $height, -align=>'justified');
($self->{hPos},$self->{vPos}) = $txt->textpos;
}
# Backwards compatibility for that pesky typo
sub addParagragh {
my ( $self, $text, $hPos, $vPos, $width, $height, $indent, $lead ) = @_;
$self->addParagraph($text, $hPos, $vPos, $width, $height, $indent, $lead);
}
=head2 centerString
$pdf->centerString($a, $b, $yPos, $text);
Centers $text between points $a and $b at position $yPos. Be careful how much
text you try to jam between those points, this function shrinks the text till
it fits!
=cut
sub centerString {
my $self = shift;
my $PointBegin = shift;
my $PointEnd = shift;
my $YPos = shift;
my $String = shift;
my $OldTextSize = $self->getSize;
my $TextSize = $OldTextSize;
my $Area = $PointEnd - $PointBegin;
my $StringWidth;
while (($StringWidth = $self->getStringWidth($String)) > $Area) {
$self->setSize(--$TextSize); ### DECREASE THE FONTSIZE TO MAKE IT FIT
}
my $Offset = ($Area - $StringWidth) / 2;
$self->addRawText("$String",$PointBegin+$Offset,$YPos);
$self->setSize($OldTextSize);
}
=head2 setRowHeight
=cut
sub setRowHeight {
my $self = shift;
my $size = shift; # the fontsize
return (int($size * 1.20));
}
=head2 getStringWidth
$pdf->getStringWidth($String);
Returns the width of $String according to the current font and fontsize being
used.
=cut
# replaces silly $pdf->{pdf}->calcTextWidth calls
sub getStringWidth {
my $self = shift;
my $String = shift;
my $txt = $self->{page}->text;
$txt->font($self->{font}, $self->{size});
return $txt->advancewidth($String);
}
=head2 addImg
$pdf->addImg($file, $x, $y);
Add image $file to the current page at position ($x, $y).
=cut
sub addImg {
my ( $self, $file, $x, $y ) = @_;
$self->addImgScaled($file, $x, $y, 1);
}
=head2 addImgScaled
$pdf->addImgScaled($file, $x, $y, $scale);
Add image $file to the current page at position ($x, $y) scaled to $scale.
=cut
sub addImgScaled {
my ( $self, $file, $x, $y, $scale ) = @_;
my %type = (jpeg => "jpeg",
jpg => "jpeg",
tif => "tiff",
tiff => "tiff",
pnm => "pnm",
gif => "gif",
png => "png",
);
$file =~ /\.(\w+)$/;
my $ext = $1;
my $sub = "image_$type{$ext}";
my $img = $self->{pdf}->$sub($file);
my $gfx = $self->{page}->gfx;
$gfx->image($img, $x, $y, $scale);
}
=head2 setGfxLineWidth
$pdf->setGfxLineWidth($width);
Set the line width drawn on the page.
=cut
sub setGfxLineWidth {
my ( $self, $width ) = @_;
$self->{linewidth} = $width;
}
=head2 getGfxLineWidth
$width = $pdf->getGfxLineWidth();
Returns the current line width.
=cut
sub getGfxLineWidth {
my $self = shift;
return $self->{linewidth};
}
=head2 drawLine
$pdf->drawLine($x1, $y1, $x2, $y2);
Draw a line on the current page starting at ($x1, $y1) and ending
at ($x2, $y2).
=cut
sub drawLine {
my ( $self, $x1, $y1, $x2, $y2 ) = @_;
my $gfx = $self->{page}->gfx;
$gfx->move($x1, $y1);
$gfx->linewidth($self->{linewidth});
$gfx->line($x2, $y2);
$gfx->stroke;
}
=head2 drawRect
$pdf->drawRect($x1, $y1, $x2, $y2);
Draw a rectangle on the current page. Top left corner is represented by
($x1, $y1) and the bottom right corner is ($x2, $y2).
=cut
sub drawRect {
my ( $self, $x1, $y1, $x2, $y2 ) = @_;
my $gfx = $self->{page}->gfx;
$gfx->linewidth($self->{linewidth});
$gfx->rectxy($x1, $y1, $x2, $y2);
$gfx->stroke;
}
=head2 shadeRect
$pdf->shadeRect($x1, $y1, $x2, $y2, $color);
Shade a rectangle with $color. Top left corner is ($x1, $y1) and the bottom
right corner is ($x2, $y2).
=over 4
=item B<Defined color-names are:>
aliceblue, antiquewhite, aqua, aquamarine, azure,
beige, bisque, black, blanchedalmond, blue,
blueviolet, brown, burlywood, cadetblue, chartreuse,
chocolate, coral, cornflowerblue, cornsilk, crimson,
cyan, darkblue, darkcyan, darkgoldenrod, darkgray,
darkgreen, darkgrey, darkkhaki, darkmagenta,
darkolivegreen, darkorange, darkorchid, darkred,
darksalmon, darkseagreen, darkslateblue, darkslategray,
darkslategrey, darkturquoise, darkviolet, deeppink,
deepskyblue, dimgray, dimgrey, dodgerblue, firebrick,
floralwhite, forestgreen, fuchsia, gainsboro, ghostwhite,
gold, goldenrod, gray, grey, green, greenyellow,
honeydew, hotpink, indianred, indigo, ivory, khaki,
lavender, lavenderblush, lawngreen, lemonchiffon,
lightblue, lightcoral, lightcyan, lightgoldenrodyellow,
lightgray, lightgreen, lightgrey, lightpink, lightsalmon,
lightseagreen, lightskyblue, lightslategray,
lightslategrey, lightsteelblue, lightyellow, lime,
limegreen, linen, magenta, maroon, mediumaquamarine,
mediumblue, mediumorchid, mediumpurple, mediumseagreen,
mediumslateblue, mediumspringgreen, mediumturquoise,
mediumvioletred, midnightblue, mintcream, mistyrose,
moccasin, navajowhite, navy, oldlace, olive, olivedrab,
orange, orangered, orchid, palegoldenrod, palegreen,
paleturquoise, palevioletred, papayawhip, peachpuff,
peru, pink, plum, powderblue, purple, red, rosybrown,
royalblue, saddlebrown, salmon, sandybrown, seagreen,
seashell, sienna, silver, skyblue, slateblue, slategray,
slategrey, snow, springgreen, steelblue, tan, teal,
thistle, tomato, turquoise, violet, wheat, white,
whitesmoke, yellow, yellowgreen
or the rgb-hex-notation:
#rgb, #rrggbb, #rrrgggbbb and #rrrrggggbbbb
or the cmyk-hex-notation:
%cmyk, %ccmmyykk, %cccmmmyyykkk and %ccccmmmmyyyykkkk
and additionally the hsv-hex-notation:
!hsv, !hhssvv, !hhhsssvvv and !hhhhssssvvvv
=back
=cut
sub shadeRect {
my ( $self, $x1, $y1, $x2, $y2, $color ) = @_;
my $gfx = $self->{page}->gfx;
$gfx->fillcolor($color);
$gfx->rectxy($x1, $y1, $x2, $y2);
$gfx->fill;
}
=head2 drawPieGraph
$pdf->drawPieGraph($x, $y, $size, $rData, $rLabels);
Method to create a piegraph using a reference to an array of values.
It also takes a reference to an array for labels for each data value. A
legend with all the colors and labels will appear if $rLabels is passed. $x and
$y are the coordinates for the center of the pie and $size is the radius.
=cut
sub drawPieGraph {
my $self = shift;
my $x = shift;
my $y = shift;
my $size = shift;
my $rData = shift;
my $rLabels = shift;
my $circ = 360;
my $a = 0;
my $b = 0;
my @colors = &getcolors();
my $lastclr = $#colors;
my $gfx = $self->{page}->gfx;
# Set up the colors we'll use
my @clr;
foreach my $elem ( 0 .. $#$rData ) {
# push(@clr, $colors[int(rand($#colors))]);
push(@clr, $colors[$elem]);
}
# Add up the numbers
my $total;
foreach my $elem ( 0 .. $#$rData ) {
$total+=$rData->[$elem];
}
# Get the percentages
my @perc;
foreach my $elem ( 0 .. $#$rData ) {
$perc[$elem] = $rData->[$elem] / $total;
}
# Draw a pie
my $cnt = 0;
foreach my $pct (@perc) {
$b+=$circ * $pct;
$b = $circ if $b > $circ;
$gfx->fillcolor($clr[$cnt++]);
$gfx->pie($x, $y, $size, $size, $a, $b);
$gfx->fill;
$a = $b;
}
# Do we print labels?
if (scalar(@{ $rLabels })) {
my $oldfont = $self->getFont();
my $oldsize = $self->getSize();
my $fontsize = 12;
$self->setFont("Times-roman");
$self->setSize($fontsize);
my $colorblocksize = 10;
my $maxsize = 0;
for (0 .. $#$rLabels) {
$maxsize = $self->getStringWidth($rLabels->[$_])
if $self->getStringWidth($rLabels->[$_]) > $maxsize;
}
my $top = $y + ((($#perc + 1) * $fontsize) / 2);
my $left = $x + $size + 8;
$self->drawRect($left, $top,
$x + $size + 8 + $colorblocksize + $maxsize + 3,
$y - ((($#perc + 1) * $fontsize) / 2));
my $pos = $top - 1;
$cnt = 0;
foreach my $nbr (0 .. $#perc) {
$self->shadeRect($left+1, $pos, $left+1+$colorblocksize,
$pos-$colorblocksize, $clr[$cnt++]);
$self->addRawText($rLabels->[$nbr], $left+$colorblocksize+3,
$pos-$colorblocksize);
$pos-=$fontsize;
}
}
}
=head2 getcolors
Returns list of available colours
=cut
sub getcolors {
my @cols=qw(
red yellow blue green aqua bisque black
blueviolet brown burlywood cadetblue chartreuse
chocolate coral cornflowerblue cornsilk crimson
cyan darkblue darkcyan darkgoldenrod darkgray
darkgreen darkgrey darkkhaki darkmagenta
darkolivegreen darkorange darkorchid darkred
darksalmon darkseagreen darkslateblue darkslategray
darkslategrey darkturquoise darkviolet deeppink
deepskyblue dimgrey dodgerblue firebrick
floralwhite forestgreen fuchsia gainsboro ghostwhite
gold goldenrod gray greenyellow
honeydew hotpink indianred indigo ivory khaki
lavender lavenderblush lawngreen lemonchiffon
lightblue lightcoral lightcyan lightgoldenrodyellow
lightgray lightgreen lightgrey lightpink lightsalmon
lightseagreen lightskyblue lightslategray
lightslategrey lightsteelblue lightyellow lime
limegreen linen magenta maroon mediumaquamarine
mediumblue mediumorchid mediumpurple mediumseagreen
mediumslateblue mediumspringgreen mediumturquoise
mediumvioletred midnightblue mintcream mistyrose
moccasin navajowhite navy oldlace olivedrab
orange orangered orchid palegoldenrod palegreen
paleturquoise palevioletred papayawhip peachpuff
peru pink plum powderblue purple rosybrown
royalblue saddlebrown salmon sandybrown seagreen
seashell sienna silver skyblue slateblue slategray
slategrey snow springgreen steelblue tan teal
thistle tomato turquoise violet wheat white
whitesmoke yellowgreen);
return @cols;
}
=head2 drawBarcode
$pdf->drawBarcode($x, $y, $scale, $frame, $type, $code, $extn, $umzn,
$lmzn, $zone, $quzn, $spcr, $ofwt, $fnsz, $text);
This is really not that complicated, trust me! ;) I am pretty unfamiliar with
barcode lingo and types so if I get any of this wrong, lemme know!
This is a very flexible way to draw a barcode on your PDF document.
$x and $y represent the center of the barcode's position on the document.
$scale is the size of the entire barcode 1 being 1:1, which is all you'll
need most likely. $type is the type of barcode which can be codabar, 2of5int,
3of9, code128, or ean13. $code is the alpha-numeric code which the barcode
will represent. $extn is the
extension to the $code, where applicable. $umzn is the upper mending zone and
$lmzn is the lower mending zone. $zone is the the zone or height of the bars.
$quzn is the quiet zone or the space between the frame and the barcode. $spcr
is what to put between each number/character in the text. $ofwt is the
overflow width. $fnsz is the fontsize used for the text. $text is optional
text beneathe the barcode.
=cut
sub drawBarcode {
my $self = shift;
my $x = shift; # x center of barcode image
my $y = shift; # y center of barcode image
my $scale = shift; # scale of barcode image
my $frame = shift; # width of the frame around the quiet zone
# my $font = shift;
my $type = shift; # type of barcode
my $code = shift; # the code
my $extn = shift; # code extension
my $umzn = shift; # upper mending zone
my $lmzn = shift; # lower mending zone
my $zone = shift; # height of the bars
my $quzn = shift; # zone between barcode and frame
my $spcr = shift; # space between numbers
my $ofwt = shift; # overflow
my $fnsz = shift; # fontsize
my $text = shift; # alt text
my $page = $self->{page};
my $gfx = $page->gfx;
my $bSub = "xo_$type";
my $bar = $self->{pdf}->$bSub(
-font => $self->{font},
-type => $type,
-code => $code,
-quzn => $quzn,
-umzn => $umzn,
-lmzn => $lmzn,
-zone => $zone,
-quzn => $quzn,
-spcr => $spcr,
-ofwt => $ofwt,
-fnsz => $fnsz,
-text => $text
);
# $gfx->barcode($bar, $x, $y, $scale, $frame);
$gfx->save;
$gfx->linecap(0);
$gfx->transform( -translate => [$x, $y]);
$gfx->fillcolor('#ffffff');
$gfx->linewidth(0.1);
$gfx->fill;
$gfx->formimage($bar,0,0,$scale);
$gfx->restore;
}
=head2 setFont
$pdf->setFont($font);
Creates a new font object of type $font to be used in the page.
=cut
sub setFont {
my ( $self, $font, $size )= @_;
if (exists $self->{__font_cache}->{$font}) {
$self->{font} = $self->{__font_cache}->{$font};
}
else {
$self->{font} = $self->{pdf}->corefont($font);
$self->{__font_cache}->{$font} = $self->{font};
}
$self->{fontname} = $font;
}
=head2 getFont
$fontname = $pdf->getFont();
Returns the font name currently being used.
=cut
sub getFont {
my $self = shift;
return $self->{fontname};
}
=head2 setSize
$pdf->setSize($size);
Sets the fontsize to $size. Called before setFont().
=cut
sub setSize {
my ( $self, $size ) = @_;
$self->{size} = $size;
}
=head2 getSize
$fontsize = $pdf->getSize();
Returns the font size currently being used.
=cut
sub getSize {
my $self = shift;
return $self->{size};
}
=head2 pages
$pages = $pdf->pages();
The number of pages in the document.
=cut
sub pages {
my $self = shift;
return $self->{pdf}->pages;
}
=head2 setInfo
$pdf->setInfo(%infohash);
Sets the info structure of the document. Valid keys for %infohash:
Creator, Producer, CreationDate, Title, Subject, Author, etc.
=cut
sub setInfo {
my ($self, %info) = @_;
# Over-ride or define %INFO values
foreach my $key (keys %{$self->{INFO}}) {
next unless (exists($info{$key}) && defined($info{$key}));
if (length($info{$key}) and ($info{$key} ne ${$self->{INFO}}{$key})) {
${$self->{INFO}}{$key} = $info{$key};
}
}
my @orig_keys = keys(%{$self->{INFO}});
foreach my $key (keys %info) {
if (! grep /$key/, @orig_keys) {
${$self->{INFO}}{$key} = $info{$key};
}
}
}
=head2 getInfo
%infohash = $pdf->getInfo();
Gets meta-data from the info structure of the document.
Valid keys for %infohash: Creator, Producer, CreationDate,
Title, Subject, Author, etc.
=cut
sub getInfo {
my $self = shift;
my %info = $self->{pdf}->info();
return %info;
}
=head2 saveAs
Saves the document to a file.
# Save the document as "file.pdf"
my $fileName = "file.pdf";
$pdf->saveAs($fileName);
=cut
sub saveAs {
my $self = shift;
my $fileName = shift;
$self->{pdf}->info(%{$self->{INFO}});
$self->{pdf}->saveas($fileName);
$self->{pdf}->end();
}
=head2 Finish
Returns the PDF document as text. Pass your own custom routine to do things
on the footer of the page. Pass 'roman' for Roman Numeral page numbering.
# Hand the document to the web browser
print "Content-type: application/pdf\n\n";
print $pdf->Finish();
=cut
sub Finish {
my $self = shift;
my $callback = shift;
my $total = $self->{page_nbr} - 1;
# Call the callback if one was given to us
if (ref($callback) eq 'CODE') {
&$callback($self, $total);
# This will print a footer if no $callback is passed for backwards
# compatibility
} elsif (defined $callback && $callback !~ /none/i) {
&gen_page_footer($self, $total, $callback);
}
$self->{pdf}->info(%{$self->{INFO}});
my $out = $self->{pdf}->stringify;
return $out;
}
=head2 getPDFAPI2Object
Object method returns underlying PDF::API2 object
=cut
sub getPDFAPI2Object {
my $self = shift;
return $self->{pdf};
}
### PRIVATE SUBS ##############################################################
sub gen_page_footer {
my $self = shift;
my $total = shift;
my $type = shift;
for (my $i = 1; $i <= $total; $i++) {
next if ( $self->{no_page_num}->[$i - 1] );
my $page = $self->{pdf}->openpage($i);
my $txtobj = $page->text;
my $txt;
my $font;
if ($type eq 'roman') {
require Text::Roman;
$font = $self->{pdf}->corefont("Times-roman");
$txt = Text::Roman::int2roman($i). " of " .
Text::Roman::int2roman($total);
} else {
$font = $self->{pdf}->corefont("Helvetica");
$txt = "Page $i of $total";
}
my $size = 10;
$txtobj->font($font, $size);
$txtobj->translate($self->{Xmargin}, 8);
$txtobj->text($txt);
$size = $self->getStringWidth($DATE);
$txtobj->translate($self->{PageWidth} - $self->{Xmargin} - $size, 8);
$txtobj->text($DATE);
}
}
=head1 AUTHOR EMERITUS
Andrew Orr
=head1 MAINTAINER
Aaron TEEJAY Trevena
=head1 BUGS
Please report any bugs or feature requests to C<bug-calendar-model at rt.cpan.org>, or through
the web interface at L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=PDF-Report>. I will be notified, and then you'll
automatically be notified of progress on your bug as I make changes.
=head1 SUPPORT
You can find documentation for this module with the perldoc command.
perldoc PDF::Report
You can also look for information at:
=over 4
=item * RT: CPAN's request tracker (report bugs here)
L<http://rt.cpan.org/NoAuth/Bugs.html?Dist=PDF-Report>
=item * AnnoCPAN: Annotated CPAN documentation
L<http://annocpan.org/dist/PDF-Report>
=item * CPAN Ratings
L<http://cpanratings.perl.org/d/PDF-Report>
=item * METACPAN
L<https://metacpan.org/module/PDF::Report/>
=item * GITHUB
L<https://github.com/hashbangperl/perl-pdf-report>
=back
=head1 SEE ALSO
=over 4
=item PDF::API2
=back
=head1 LICENSE AND COPYRIGHT
Copyright 2008-2010 Andy Orr
Copyright 2013 Aaron Trevena
This program is free software; you can redistribute it and/or modify it
under the terms of either: the GNU General Public License as published
by the Free Software Foundation; or the Artistic License.
See L<http://dev.perl.org/licenses/> for more information.
=cut