I guess the idea is to up the ante in Amazon's battle against state sales taxes—they've cut off the associates in states they're in conflict with, and now those users can't use the search API at all.

I hope they don't declare war on Missouri next.

I didn't find anything exactly right on the web, but symcbean on stackoverflow had a clever idea for evaluating fractions: turn "2 1/2" into "2+1/2" then use eval.

Try the code.

function convertCK($usIn){
	// convert input numbers with optional units (pounds, inches etc.) to centimeters and kilograms
	$factors = array(
		'f' => 30.48, // feet
		"'" => 30.48,
		'i' => 2.54, // inches
		'"' => 2.54,
		'p' => 0.45359237, // pounds
		'l' => 0.45359237, // lb
		'#' => 0.45359237,
		'o' => 0.0283495231, // ounces
		'g' => 0.001 // grams
	);
	$usIn = trim($usIn);
	// turn spaces in mixed numbers to pluses, for the eval hack
	$usIn = preg_replace ('%(\d)\s+(\d)%', '$1+$2', $usIn);
	preg_match_all('%(?<num>[0-9./+]+)\s*(?<unit>\D*)%', $usIn, $values, PREG_SET_ORDER);
	$ret = 0;
	foreach ($values as $value){
		$unit = strtolower($value['unit']{0});
		$factor = isset($factors[$unit]) ? $factors[$unit] : 1;
		$ret += $factor*eval("return $value[num];");
	}
	return $ret;
}

The code above is simplified by the fact that all the units I care about have unique first letters, but if you wanted more units you could simply add more entries in the factors array and make the $unit = strtolower($value['unit']{0}); line more sophisticated. usIn is used as a variable name to remind me that it is unsafe—it may come from user input and has to be sanitized with the regexp before it can be trusted.

It allows the American notation for tic marks for feet and inches, since getting that wrong can be disastrous.

Most of the size is due to the SVG and HTML formatting, which I don't need, but the biggest advantage is that Unicode font subsetting works. Mostly.

tfpdf, the Unicode-enabled version that comes with fpdf, supports Unicode fonts but they don't show up on the iPhone. Apple's PDF viewer is somehow different from Adobe's and reads the fonts differently. tcpdf does a better job (displays in Adobe Reader but generates an error for the HumaneJenson font): the Droid fonts work on the iPhone, though the DejaVu fonts do not. Try those last links on the iPhone; the built-in Helvetica fonts show up but DejaVu does not. Try refreshing the test page multiple times; it randomly selects fonts to display each time. Some fonts generate errors in Adobe Reader but display, some don't display at all and some don't display on the iPhone. It all seems very random, but at least I have a set of open-source true type fonts that I can include.

It also does most of the things I need: PNG graphics with transparency, form fields like text boxes (I played with that one for weeks with tfpdf, but it never worked the way I wanted it to), rotating text. The API is clunky and poorly documented and I definitely like my routines better, but this is done and someone else maintains it. A huge advantage. I can write my own interface routines to be more elegant if I want.

Using tcpdf

Unlike tfpdf, you have to parse the true type fonts first to create PHP files. In the fonts folder there's a utils folder; copy the contents of that into your font folder then run the script makeallttffonts.php and it will create the necessary files (as above, they're not perfect).

The basic page is similar to fpdf:

define ('K_PATH_FONTS', '/path/to/fonts/'); // some constants are named differently
$pdf = new TCPDF('P', 'in', 'letter');
$pdf->setPrintHeader(false); // it automatically includes a header and footer (just a line by default) unless told otherwise
$pdf->setPrintFooter(false);
$pdf->AddPage();
$pdf->AddFont('DroidSerif-Regular'); // using true type fonts
$pdf->SetFont('DroidSerif-Regular', '', 12);
$pdf->Write(0, 'Hello, world ');
$pdf->Output();

Graphics can use URL's directly, which is nice (it uses CURL internally). It's inefficient, in that it reloads the image from the internet each time it's used rather than caching it. If that matters, download the image yourself and pass the file. Images are placed based on their upper left corner, and there's no way to get the size of the image to be able to calculate the center (that's another argument for downloading an image yourself: you can use getimagesize on the resulting file). I wrote a minor hack to use the class's protected methods to center an image (see the result):

class pdf_imageinfo extends TCPDF{
  // adds a function to return the image information
  function lastimageinfo(){
    return $this->images[$this->imagekeys[count($this->imagekeys)-1]];
  }
}

$pdf = new pdf_imageinfo('P', 'in', 'letter');
$pdf->setPrintHeader(false);
$pdf->setPrintFooter(false);
$pdf->AddPage();

markImage($pdf, 'http://bililite.com/images/silk/bug.png', 2, 2);
markImage($pdf, 'http://bililite.nfshost.com/blog/blogfiles/pdf/dice.png', 4, 6);
$pdf->Output();

function markImage($pdf, $url, $x, $y){
  // place an image file $url centered at ($x, $y) with crosshairs
  $pdf->Image($url, -1000); // hide the image. Not too inefficient since we're going to use it anyway, though tcpdf will call cURL each time
  $info = $pdf->lastimageinfo();
  $w = $info['w']/$pdf->GetScaleFactor(); // sizes are in pixels; we want user units
  $h = $info['h']/$pdf->GetScaleFactor();
  $pdf->SetAlpha(1);
  $pdf->Line ($x,$y-$h,$x,$y+$h); // draw crosshairs to show center
  $pdf->Line ($x-$w,$y,$x+$w,$y);
  $pdf->SetAlpha(0.5); // demonstrates using transparency in images
  $pdf->Image($url, $x-$w/2, $y-$h/2);
}

Text is a little different from fpdf. The Text function in fpdf places the baseline of the text, but in tcpdf it's aligned with the top left, unless the calign parameter is set, which is 14 parameters down the list. Since there's no way to specify named parameters in the call that means a long, inconvenient call: $pdf->Text ($x, $y, $s, FALSE,FALSE,TRUE,0,0,'',FALSE,'',0,FALSE,'L');. In addition, there's a cell margin and cell padding that's added, so if you want to precisely place the text you have to set those to zero (margin is defaulted to 0 but padding is not) (these are the same as in CSS: margin surrounds border which surrounds padding).

Rotating is straightforward: call StartTransform, Rotate (in degrees!), then StopTransfom. So to rotate text around the left end of the baseline (see the result):

$pdf = new TCPDF('P', 'in', 'letter');
$pdf->setPrintHeader(false);
$pdf->setPrintFooter(false);
$pdf->AddPage();
$num = 6;
$pdf->SetCellPaddings(0);
$s = 'Hello, world';
// draw crosshairs
$pdf->Line(4,3,4,5);
$pdf->Line(3,4,5,4);
$pdf->Line(4,5,4,7);
$pdf->Line(3,6,5,6);
// Draw rotated text
for ($i = 0; $i < $num; ++$i){
  $angle = 360*$i/$num;
  $color = array (0, 0, 0, 127*$i/$num);
  text ($pdf, $s, 4, 4, $angle, 'DroidSans', 22, $color);
  text ($pdf, 'Hello', 4, 6, $angle, 'Lilly', 7, $color);
}
$pdf->Output();

function text ($pdf, $s, $x, $y, $angle, $font, $size, $color){
  $pdf->StartTransform();
  $pdf->SetFont($font, '', $size);
  $pdf->SetTextColor ($color[0], $color[1], $color[2]);
  $pdf->SetAlpha ( (127-$color[3])/127 ); // change from PHP to PDF units for transparency
  $pdf->Rotate ($angle, $x, $y); // rotate origin
  $pdf->Text ($x, $y, $s, FALSE,FALSE,TRUE,0,0,'',FALSE,'',0,FALSE,'L'); 
  $pdf->StopTransform();	
}

Text fields are straightforward; set the default properties (borders, colors) with SetFormDefaultProp; the documentation for the properties are in the Adobe Javascript manual. Create a text field with TextField, though setting the properties in that function doesn't work for me. One trick is that Reader uses a font size of 0 to indicate that the size should adjust to fit. Unfortunately, tcpdf uses a font size of 0 to indicate no change, but there's a hack: on output it rounds numbers to 2 decimal places. So setting the font size to 0.001 works as well.

The PDF's I'm creating are generally used as printable forms, with underlines for the fillable fields, but with text boxes that can be filled in online. So I want a text field with no border but with the underline overprinted. This does that (see the result):

$s = $_GET['s'];
preg_match_all('%_+|[^_]+%', $s, $matches);
// $matches[0] is the array of text, split into underlines and other
define ('K_PATH_FONTS', '/path/to/fonts/');
$pdf = new TCPDF('P', 'in', 'letter');
$pdf->setPrintHeader(false);
$pdf->setPrintFooter(false);
$pdf->SetCellPaddings(0); // so text aligns precisely
$pdf->SetFont('Helvetica', '', 12); // always use a built-in font for text fields, since there's no way to know what characters will be used
$height = 14/$pdf->GetScaleFactor(); // 14-point line height
$pdf->AddPage();
$pdf->setFormDefaultProp(array('lineWidth'=>0)); // no border
$fieldcount=0;
foreach ($matches[0] as $text){
  if (strpos($text, '_') !== FALSE){
    // It's an underline. Create a text field of the same size
    $x = $pdf->GetX();
    $width = $pdf->GetStringWidth($text);
    $pdf->SetFontSize(0.001); // automagic font size hack
    $pdf->TextField ('text'.($fieldcount++), $width, $height);
    $pdf->SetX($x); // reset the location and font
    $pdf->SetFontSize(12);
  }
  $pdf->Write($height, $text);

}
$pdf->Output();

Now I can go and get the webservices PDF's working correctly!

See the code.

See the sample output.

See the code that produced the sample output.

Path Drawing

Create a "path" by moving a virtual stylus around the page, then draw it or fill it in. The main advantage of using the path drawing routines rather than $pdf->Line is that PDF creates nice line joins at the angles, rather than just overlaying the lines: as opposed to .

MoveTo ($x, $y)

Moves the stylus to ($x, $y) (in user units) without drawing the path from the previous point. $x and $y must be numbers. Paths must start with a MoveTo to set the original stylus location or the result is undefined.

LineTo ($x, $y)

Draw a line from the current stylus location to ($x, $y), which becomes the new stylus location. Note that this only creates the line in the path; it does not actually draw the line on the page.

CurveTo ($x1, $y1, $x2, $y2, $x3, $y3)

Draw a cubic B�zier curve from the current location to ($x3, $y3), using ($x1, $y1) and ($x2, $y2) as control points. See Mike "Pomax" Kamermans's site for more information on drawing with B�zier curves.

ClosePath()

Draw a line from the current location to the last MoveTo point (if not the same) and mark the path as closed so the first and last lines join nicely.

DrawPath($style='D')

Actually draw the path on the page. $style can be:

• 'D' (or an empty string) to draw the path with the current drawing color.
• 'F' to fill the path with the current fill color.
• 'DF' or 'FD' to do both.

Drawing

Image($file, $x=null, $y=null, $w=0, $h=0, $type='', $link='')

Enhanced Image to allow the use of PHP GD images directly, including the alpha channel (using the code from Valentin Schmidt). Uses temporary PNG files, so requires write-access to the current directory.

For example,

$im = imagecreate(110, 20);
$background_color = imagecolorallocate($im, 0, 0, 0);
$text_color = imagecolorallocate($im, 233, 14, 91);
imagestring($im, 1, 5, 5,  "A Simple Text String", $text_color);
$pdf->Image($im);

will insert the image onto the page.

Also enhanced to allow the use of vector-based images; see OpenImage and CloseImage below.

Text($x, $y, $txt, $theta=0)

Enhanced Text to allow rotation of the baseline by $theta radians (counter clockwise).

Rect($x, $y, $w, $h, $style='', $theta=0)

Enhanced Rect to allow rotation of the rectangle by $theta radians (counter clockwise) around the upper left corner.

PlaceImage($file, $x, $y, $w=0, $h=0, $theta=0, $type='')

Similar to Image but puts the image with ($x, $y) at the center rather than the upper left of the image, and rotates the image by $theta radians (counter clockwise) around the center. Unlike Image, does not allow $x=NULL to place the image in the text flow, and does not create links.

Arc($x, $y, $style='', $a, $b=NULL, $theta=0, $lambda1=0, $lambda2=0)

Draw an arc or wedge of an ellipse. ($x, $y) is the center of the ellipse, $a is the semimajor axis (half the width) and $b is the semiminor axis (half the height). If $b===NULL, then $b is set to $a (a circle with radius $a). The ellipse is rotated $theta radians counter clockwise from the horizontal. The arc goes from $lambda1 radians from the major axis (not the horizontal) to $lambda2 radians; if they are equal then the whole ellipse is drawn. $style is the same as for Rect: 'D' to draw the arc, 'F' to fill in the wedge, 'DF' or 'FD' to do both.

The calculations to estimate circles with B�zier curves comes from L. Maisonobe.

Polygon($x, $y, $n, $style='', $a, $b=NULL, $skip=1, $theta=0, $lambda=0)

Draw a regular polygon with $n sides, inscribed in the ellipse that would be drawn with Arc($x, $y, '', $a, $b, $theta). The first vertex is placed at $lambda to the major axis. $skip determines the shape of the polygon: if $skip==1, draw a regular, convex polygon. If $skip>1, draw a star by drawing the lines from each vertex i to i+$skip. The higher $skip is, the tighter the star (up to $n/2).

So $pdf->Polygon(1, 1, 5, 'D', 10, 10, 1) draws a pentagon with a radius of 10, and $pdf->Polygon(1, 1, 5, 'D', 10, 10, 2) draws a five-pointed star with a radius of 10.

Cloverleaf($x, $y, $n, $style='', $a, $b=NULL, $skip=1, $theta=0, $lambda=0)

Same as Polygon, but draws curves with loops at the vertices.

Transparent Drawing

In addition to allowing alpha-channel transparency in images with the enhanced Image, you can use transparent colors for drawing, filling and text. The code is based on that of Martin Hall-May.

SetDrawColor($r, $g=null, $b=null, $alpha=0)

Enhanced SetDrawColor to allow alpha channel transparency. $alpha==0 is opaque and $alpha==127 is fully transparent. Note that this is backward from CSS opacity, which uses 0 for transparent and 1 for opaque.

SetFillColor($r, $g=null, $b=null, $alpha=0)

Enhanced SetFillColor to allow alpha channel transparency. $alpha==0 is opaque and $alpha==127 is fully transparent.

SetTextColor($r, $g=null, $b=null, $alpha=0)

Enhanced SetTextColor to allow alpha channel transparency. $alpha==0 is opaque and $alpha==127 is fully transparent.

Vector-based images

In addition to bitmapped images like JPEG or PNG images (or GD images), PDF supports vector graphics similar to SVG (a class to allow using SVG directly would be useful; I may get the time). Create a new image with OpenImage, then any of the drawing commands will draw into the image being created rather than onto the page. Use Image or PlaceImage to put the image onto the page.

For example,

$pdf = new GraphicsPDF('P', 'in', 'letter'); // use inches for user units
$pdf->OpenImage('star', 2, 2); // create a 2 x 2 image
$pdf->SetFillColor (0, 0, 255);
$pdf->Rect(0, 0, 2, 2, 'F'); // fill it with blue
$pdf->SetFillColor (255);
$pdf->Polygon(1, 1, 5, 'F', 1, 1, 2, 0, deg2rad(90)); // put a white star in the center
$pdf->CloseImage();
$pdf->AddPage();
$pdf->Image('star', 1, 1); // put the image in various sizes
$pdf->Image('star', 3, 1, 0.25);
$pdf->Image('star', 5, 1, 3); 
$pdf->Image('star', 5, 7, 4);
$pdf->Output();

produces this.

OpenImage($name, $w, $h)

Start creating a vector image named $name with width $w and height $h. All drawing code will go into the image, not the page (however, state-changing calls like SetDrawColor and SetLineWidth will carry over to the page).

CloseImage()

Stop recording the current image and return to drawing directly on the page.

Curve Calculations

Arc, Polygon and Cloverleaf involve a fair amount of heavy math, so I exposed methods to return simply the boundary points for the shapes rather than drawing them, to be used for building paths and the like.

Each of these returns an array of arrays. Each subarray has 4, 8 or 0 elements. 0 elements indicates that one shape has ended and another needs to start; think of a six-pointed star consisting of two triangles. 4 elements indicates a line: [x0, y0, x1, y1] is a line from (x0, y0) to (x1, y1). 8 elements indicates a curve: [x0, y0, x1, y1, x2, y2, x3, y3] is a curve from (x0, y0) to (x3, y3) with control points (x1, y1) and (x2, y2).

EllipseCurves($x, $y, $a, $b=NULL, $theta=0, $lambda1=0, $lambda2=0)

Generate the curves for the ellipse that would be drawn by Arc($x, $y, 'D', $a, $b, $theta, $lambda1, $lambda2).

PolygonLines($x, $y, $n, $a, $b=NULL, $skip=1, $theta=0, $lambda=0)

Generate the lines that would be drawn by Polygon($x, $y, 'D', $n, $a, $b, $skip, $theta, $lambda).

CloverleafCurves($x, $y, $n, $a, $b=NULL, $skip=1, $theta=0, $lambda=0)

Generate the curves that would be drawn by Cloverleaf($x, $y, 'D', $n, $a, $b, $skip, $theta, $lambda).

Hope this is useful to someone.

See the code.

Text, the easy part

The easy part is putting the text on the page. Use the same cm command to set the origin (there is another transformation matrix just for text which is useful for long runs of text, but we're just putting in a line at a time), then BT (begin text) to start PDF thinking about text (I don't know why you can't just use the text commands, but this is one of the rules), then (string to print) Tj (Tj for Text just-print-it? I don't know), then ET (end text).

Text, the hard part

If you do this, you'll get nothing showing. That's because we haven't told PDF what font we want to use, and describing fonts is an arcane art that I haven't begun to understand. You can look at the code for FPDF and tFPDF for details. In short, the process is similar to using images:

Define the font

This is called the "font descriptor", and involves listing the drawing commands for each glyph (the printed representation of a character) and the font metrics (the dimensions of each glyph and how they interact with their neighbors). PDF only can handle 256 characters per font, so real Unicode fonts need "composite fonts" with multiple subsets of each font.

Luckily for us, Adobe Reader comes with 14 fonts built-in (and, since Reader is the reference standard for PDF readers, you can count on them being built-in for any reader). These are:

• Courier
• Courier-Bold
• Courier-Oblique
• Courier-BoldOblique
• Helvetica
• Helvetica-Bold
• Helvetica-Oblique
• Helvetica-BoldOblique
• Times-Roman
• Times-Bold
• Times-Italic
• Times-BoldItalic
• Symbol
• ZapfDingbats

For any of these (and they only have the Ascii characters!) the font descriptor is simple:

10 0 obj
<<
/Type /Font
/Subtype /Type1 % they're type 1 fonts. They just are
/BaseFont /Helvetica % or whatever the font name is
>>
endobj

Define a name for the font

In the resource dictionary, determine a name for the font (this is arbitrary, but there's no reason not to use the real font name) in the /XObject subdictionary:

2 0 obj
<<
  % ... other resource definitions
  /Font << 
    /Helvetica 10 0 R % the name of object 6, defined above
    % ... other font descriptors
  >>
>>

Use the font

In the content stream for the page, include the command

/Helvetica 12 Tf

to set the font to Helvetica, 12 point

So the total commands to print Hello World in green 12 point Helvetica at (100,100) is:

q % push the graphics state
1 0 0 1 100 100 cm % translate origin
0 1 0 rg % set the fill color (text is filled, by default)
BT % start text
/Helvetica 12 Tf % set the font
(Hello, World) Tj % draw the text
ET % end text
Q % restore graphic state

Example

See the example.

$pdf = new bililitePDF_4();
$pdf->newpage();
$count = 8;
for ($i = 0; $i < $count; ++$i){
	$pdf->placetext('Hello, world', 'Helvetica-Bold', 30, 200, 600, 2*M_PI*$i/$count, 255*$i/$count, 255*$i/$count, 255*$i/$count);
}
$pdf->placetext('ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz', 'ZapfDingbats', 12, 10, 200);
$pdf->output();

This ends the use of my toy class. All further discussion and development will be with the real FPDF. ]]> http://bililite.nfshost.com/blog/2011/04/01/creating-pdfs-with-php-part-5/feed/ 0 http://bililite.nfshost.com/blog/2011/04/01/creating-pdfs-with-php-part-4/ http://bililite.nfshost.com/blog/2011/04/01/creating-pdfs-with-php-part-4/#comments Fri, 01 Apr 2011 08:10:52 +0000 Danny http://bililite.nfshost.com/blog/?p=1731 Now that we can draw in our PDF, we want to add images. There are two kinds of images, bitmapped and vector. In PDF, images are called XObjects (The X stands for external, meaning defined outside the page). Vector images are easier, since they are just packages of PDF drawing commands, a sort of macro. PDF calls them Forms, since they were originally used to draw the boxes on a printed form.

See the code.

Vector graphics

Using an XObject Form involves three parts:

Define the image

Create a content stream with the drawing commands, like:

6 0 obj
<<
/Subtype /Form % defines the type of image
/Resources 2 0 R % just like the resource dictionary for a page; no reason not to use the same one
/BBox [0 0 40 40] % the bounding box of the image, as [left bottom right top]. No reason not to use [0 0 width height]
/Length 47
>>
stream
5 w
0 0 40 40 re % draw a black box
0 0 0 RG S
endstream
endobj

Define a name for the image

In the resource dictionary, determine a name for the image (this is arbitrary) in the /XObject subdictionary:

2 0 obj
<<
  % ... other resource definitions
  /XObject << 
    /Image1 6 0 R % the name of object 6, defined above
    % ... other images
  >>
>>

Use the image

In the content stream for the page, include the command

/Image1 Do

The question is obvious: how do you tell PDF where on the page to draw the image? The answer is, you don't. The drawing commands draw a box from (0,0) to (40,40), and that's where it's drawn. But you object: that makes them worthless!

The trick is to redefine the coordinate system so that (0,0) ends up where you want. PDF uses affine transformations:

x? = ax+cy+e
y? = bx+dy+f

where x is the x-coordinate in the new coordinate system (where the image "thinks" its drawing) and x? is the x-coordinate in the original coordinate system. So to put the image with the lower left corner (its (0,0) point) at (50,100), you would want to have x? = x+50 and y? = y+100, or a=1 b=0 c=0 d=1 e=50 f=100. The PDF command for that is cm (for coordinate matrix), so the drawing command would be:

1 0 0 1 50 100 cm
/Image1 Do

Coordinate transformations are cumulative, so repeating the translation for another image would push it too far. You want to reset the transformation matrix before each drawing. You could calculate the inverse matrix (for the translation above, it's easy: 1 0 0 1 -50 -100 cm, but other transformations are more complicated) but PDF has an easier way: a graphics state stack. q pushes the current graphics state, including the transformation matrix, and Q pops it, so the final drawing command would be:

q
1 0 0 1 50 100 cm
/Image1 Do
Q

Other transformations are possible, and the work of getting the math right has already been done:

Translation of the origin to (x,y)

As above, 1 0 0 1 x y cm.

Rotation around the origin by angle theta

cos(theta) sin(theta) –sin(theta) cos(theta) 0 0 cm.

Scale (change the size of) the x-direction by a factor xscale and the y-direction by yscale

xscale 0 0 yscale 0 0 cm

These do the transformation around the origin (and doing them in the above order has the expected results; doing the transforms in some other order means translating in scaled units or along rotated axes, which is rarely what you want). More often, we want to place and rotate around the center of the image, so after the transformation, translate backwards half the height and width (in the new coordinate system): 1 0 0 1 -width/2 -height/2 cm.

Bitmapped graphics

Bitmapped images are simply streams of bits, with a given color space (grayscale, CMYK or RGB) and a given number of bits per color component (grayscale has one component, CMYK has four and RGB has three). The easiest to use is RGB, with 8 bits per component, since that translates directly from the PHP image routines.

Using a bitmapped image is exactly the same as for a vector image, except the content stream is different:

7 0 obj
<<
/Subtype /Image % defines the type of image
/Width 50 % no bounding box, just a width and height
/Height 50
/ColorSpace /DeviceRGB
/BitsPerComponent 8
/Length 2500
>>
stream
...generate the bytes
endstream
endobj

And "generate the bytes" for a PHP image is straightforward:

for ($row = 0; $row < $height; ++$row) for ($col = 0; $col < $width; ++$col){
  $colorindex = imagecolorat($im, $col, $row);
  $colors = imagecolorsforindex($im, $colorindex);
  $image->contents .= sprintf('%c%c%c', $colors['red'], $colors['green'], $colors['blue']);
}

There is a huge gotcha here: the image is always scaled to be 1 pixel square. I don't know why; the width and height are there in the image definition, but that's the way it is. So you have to scale the image with width 0 0 height 0 0 cm (or multiply width and height by some scale factor) before displaying with /bitmappedImage1 Do. Then, since the units are now scaled, to place and rotate around the center you have to use 1 0 0 1 -0.5 -0.5 cm (half the original (1x1) sizes). Trust me, this works.

The final code is pretty simple.

Example

See the example.

Create the apple vector image:

$pdf->newForm();
// http://en.wikipedia.org/wiki/File:Apple_logo_black.svg, same as last example but now going into an Xform
$pdf->moveto(28.70919,92.37034);
$pdf->curveto(32.22477,92.37025,36.46696,91.64368,41.43575,90.19065);
$pdf->curveto(46.45132,88.73743999999999,49.77944,88.01088,51.42013,88.01096);
$pdf->curveto(53.52944,88.01088,56.97475,88.83118999999999,61.756057,90.4719);
$pdf->curveto(66.537237,92.11243,70.685667,92.93275,74.201377,92.93284);
$pdf->curveto(79.966907,92.93275,85.099717,91.38587,89.599807,88.29221);
$pdf->curveto(92.130957,86.51088,94.638767,84.09682000000001,97.123244,81.05002);
$pdf->curveto(93.373147,77.862449,90.630967,75.02649,88.896687,72.54219);
$pdf->curveto(85.755967,68.04213,84.185657,63.07338,84.185747,57.63594);
$pdf->curveto(84.185657,51.682770000000005,85.849717,46.31558,89.177937,41.53438);
$pdf->curveto(92.505957,36.75309,96.302824,33.729659999999996,100.56855,32.46407000000001);
$pdf->curveto(98.787204,26.69842,95.834084,20.674989999999994,91.709187,14.393749999999997);
$pdf->curveto(85.474717,4.971879999999999,79.287227,0.26094000000000506,73.146687,0.26094000000000506);
$pdf->curveto(70.709107,0.26094000000000506,67.334107,1.0343799999999987,63.021687,2.581249999999997);
$pdf->curveto(58.755997,4.128129999999999,55.14663,4.9015600000000035,52.19356,4.901570000000007);
$pdf->curveto(49.24038,4.9015600000000035,45.79507,4.104690000000005,41.85763,2.510940000000005);
$pdf->curveto(37.96696,0.8703200000000066,34.8029,0.05001000000000033,32.36544,0.04999999999999716);
$pdf->curveto(25.00603,0.05001000000000033,17.78729,6.284369999999996,10.70919,18.75313);
$pdf->curveto(3.63105,31.081220000000002,0.09199,43.17496,0.092,55.03438);
$pdf->curveto(0.09199,66.04993999999999,2.7873,75.02649,8.1779402,81.96409);
$pdf->curveto(13.61542,88.9015,20.45916,92.37025,28.70919,92.37034);
$pdf->moveto(73.006057,120.07346);
$pdf->curveto(73.193477,119.46397,73.310667,118.92491,73.357627,118.45627);
$pdf->curveto(73.404417,117.98741,73.427857,117.51866,73.427937,117.05002);
$pdf->curveto(73.427857,114.04991,72.724727,110.76867,71.318557,107.20627);
$pdf->curveto(69.912237,103.64367,67.685677,100.33899,64.638877,97.29221);
$pdf->curveto(62.013807,94.71399,59.412247,92.97962,56.83419,92.08909);
$pdf->curveto(55.1935,91.57337,52.70913,91.17493,49.38106,90.89377);
$pdf->curveto(49.47476,98.01868,51.32632,104.18272999999999,54.93575,109.38596);
$pdf->curveto(58.591927,114.58897,64.615367,118.15147,73.006057,120.07346);
$pdf->fill (0,149,182); // biondi blue
$pdf->appendForm('apple', 101, 121);

And if we have these images: smiley.png and smiley2.png we can create bitmapped images:

$im = imagecreatefrompng('smiley.png');
$pdf->appendImage($im);
$im2 = imagecreatefrompng('smiley2.png');
$pdf->appendImage($im2);

And use the images:

$pdf->placeimage('apple', 0, 0, 0, 1, 3); // centered at origin, stretched vertically
$pdf->placeimage('apple', 300, 300); // image placed straight
$pdf->placeimage('apple', 300, 500, M_PI/2); // rotated up 90 degrees
$pdf->placeimage($im, 200, 200); // image placed straight
$pdf->placeimage($im2, 200, 400, deg2rad(60)); // rotated 60 degrees

Transparency

You will notice there is no mention of the alpha channel in the images or other forms of transparency. This is a format from 1993, after all. We were lucky to have transparent colors in our GIFs. But it is possible; see the transparency and alpha channel extensions to FPDF. I just am not going to go into it here.

Compression

The classes presented here allow for gzip compression, but there are better ways to compress images. PDF supports png and jpeg compressed images, as well as color palettes to reduce the bits per pixel. See the FPDF functions Image, _parsejpeg and _parsepng for details.

Continued…

$this->pages[count($this->pages)-1]->contents .= "the command\n";
// we just need some whitespace at the end, but the newline makes it easier to read the resulting PDF

But to make things easier, we can keep track of the last page:

function newpage(){
  parent::newpage();
  $this->currentPage = $this->pages[count($this->pages)-1];
}
// and now adding commands is:
$this->currentPage->contents .= "the command\n";
// this also has the advantage that we can manipulate currentPage to add commands to other content streams

There are lots of commands, all of which are postfix (parameters come before operators). There are no math operators or stack manipulation operators; any calculation has to be done before generating the PDF and numbers inserted directly.

See the code.

Drawing is done by creating a path, then filling or stroking (outlining) it. Some useful commands include:

x y m

Move to point (x, y).

x y l

Draw a straight line from the current point to (x, y).

h

Close the current path by drawing a line back to the last point moved to. You have to explicitly close a path to fill it, and even stroking it looks better if it is closed since PDF will make the last line join the first with an elegant miter. Just drawing a line to the starting point (like 0 0 m 1 0 l 0 1 l 0 0 l) doesn't count.

x1 y1 x2 y2 x3 y3 c

Draw a cubic Bézier curve from the current point to (x3, y3), with (x1, y1) and (x2, y2) as control points. You can play with Bézier curves and manipulate control points to get a feel for them at Mike Kamermans's site.

x y w h re

Draw a closed rectangle from (x, y) with width w and height h. Shorthand for x y m (x + w) y l (x + w) (y + h) l x (y + h) l h. But PDF will do the math for you.

r g b RG

Set the stroking color to (r, g, b) where the color components are fractional, from 0 to 1, unlike PHP where the components go from 0 to 255.

r g b rg

Set the fill color to (r, g, b).

w w

Set the line width for stroking to w.

S

Stroke the current path. The fill and stroke commands discard the current path. That means you can't fill then fill a path; you have to recreate it.

f

Fill the current path.

So extending the basic class to allow drawing is straightforward. The only gotcha is that the coordinate system is backwards: the origin is at the lower left corner and the y axis goes up (like a mathematical graph), unlike PHP imaging and every other computer graphics package I've ever used, where the origin is at the top left.

See a sample page.

How'd you do that cool Apple logo?

Luckily, SVG uses Bézier curves as well, and can be easily read (paths like M 1,2 C 3,4 5,6 7,8 in SVG becomes 1 2 m 3 4 5 6 7 8 c in PDF). You just have to invert the y-values to reflect the reflected coordinate system. So finding a good SVG image lets you create a PDF image:

$pdf->moveto(28.70919,92.37034);
$pdf->curveto(32.22477,92.37025,36.46696,91.64368,41.43575,90.19065);
$pdf->curveto(46.45132,88.73743999999999,49.77944,88.01088,51.42013,88.01096);
$pdf->curveto(53.52944,88.01088,56.97475,88.83118999999999,61.756057,90.4719);
$pdf->curveto(66.537237,92.11243,70.685667,92.93275,74.201377,92.93284);
$pdf->curveto(79.966907,92.93275,85.099717,91.38587,89.599807,88.29221);
$pdf->curveto(92.130957,86.51088,94.638767,84.09682000000001,97.123244,81.05002);
$pdf->curveto(93.373147,77.862449,90.630967,75.02649,88.896687,72.54219);
$pdf->curveto(85.755967,68.04213,84.185657,63.07338,84.185747,57.63594);
$pdf->curveto(84.185657,51.682770000000005,85.849717,46.31558,89.177937,41.53438);
$pdf->curveto(92.505957,36.75309,96.302824,33.729659999999996,100.56855,32.46407000000001);
$pdf->curveto(98.787204,26.69842,95.834084,20.674989999999994,91.709187,14.393749999999997);
$pdf->curveto(85.474717,4.971879999999999,79.287227,0.26094000000000506,73.146687,0.26094000000000506);
$pdf->curveto(70.709107,0.26094000000000506,67.334107,1.0343799999999987,63.021687,2.581249999999997);
$pdf->curveto(58.755997,4.128129999999999,55.14663,4.9015600000000035,52.19356,4.901570000000007);
$pdf->curveto(49.24038,4.9015600000000035,45.79507,4.104690000000005,41.85763,2.510940000000005);
$pdf->curveto(37.96696,0.8703200000000066,34.8029,0.05001000000000033,32.36544,0.04999999999999716);
$pdf->curveto(25.00603,0.05001000000000033,17.78729,6.284369999999996,10.70919,18.75313);
$pdf->curveto(3.63105,31.081220000000002,0.09199,43.17496,0.092,55.03438);
$pdf->curveto(0.09199,66.04993999999999,2.7873,75.02649,8.1779402,81.96409);
$pdf->curveto(13.61542,88.9015,20.45916,92.37025,28.70919,92.37034);
$pdf->moveto(73.006057,120.07346);
$pdf->curveto(73.193477,119.46397,73.310667,118.92491,73.357627,118.45627);
$pdf->curveto(73.404417,117.98741,73.427857,117.51866,73.427937,117.05002);
$pdf->curveto(73.427857,114.04991,72.724727,110.76867,71.318557,107.20627);
$pdf->curveto(69.912237,103.64367,67.685677,100.33899,64.638877,97.29221);
$pdf->curveto(62.013807,94.71399,59.412247,92.97962,56.83419,92.08909);
$pdf->curveto(55.1935,91.57337,52.70913,91.17493,49.38106,90.89377);
$pdf->curveto(49.47476,98.01868,51.32632,104.18272999999999,54.93575,109.38596);
$pdf->curveto(58.591927,114.58897,64.615367,118.15147,73.006057,120.07346);
$pdf->fill (0,149,182); // biondi blue

Yes, the image is trademarked. But I think this use is OK, since I'm acknowledging it as the Apple logo. If Apple's lawyer's find me, I'll be thrilled to be so important.

The code for the rectangle and S-curve is:

// filled rectangle
$pdf->moveto(100, 100);
$pdf->lineto(100,200);
$pdf->lineto(200,200);
$pdf->lineto(200,100);
$pdf->closepath();
$pdf->fill(0,255,0);
// rectangle outline, using the re command
$pdf->rect(100, 100, 100, 100);
$pdf->linewidth(10);
$pdf->stroke(255, 0, 0);
// Bézier curve
$pdf->moveto(200, 250);
$pdf->curveto(100, 200, 300, 200, 200, 150);
$pdf->stroke(0, 0, 0);

I don't need no Bézier curves—I need circles!

Bézier curves are nice mathematically; they're polynomials, easily differentiated and easy to splice together in esthetically pleasing ways. But they're not circles. And you can't get an exact circle with cubic Béziers. The best you can do is approximate a set of arcs and join them together. To get a good approximation, each arc has to be 90 degrees or less. You match the slopes at the endpoints and the curvature at the midpoint, and you can do very well: according to Don Lancaster the worst error is one part in a thousand. If you need better than that, you shouldn't be getting your drafting advice from a pediatrician. The math for an arbitrary arc of an arbitrarily oriented ellipse is straightforward but hairy; L. Maisonobe has the details. Since I'm so nice, I implemented it in PHP:

define ('M_TAU', 2*M_PI); // http://www.math.utah.edu/~palais/pi.html
function ellipsearc ($x, $y, $a, $b=NULL, $theta=0, $lambda1=0, $lambda2=0){
	// get the Bézier points of the elliptical arc with the ellipse centered at $x, $y, with major and minor semi-axes $a and $b,
	// and major axis at $theta to the x-axis,
	// with the arc starting at angle $lambda1 from the major axis (not the x-axis!) and ending at $lambda2
	// all angles are in radians.
	// returns an array of arrays, with each sub-array being a segment
	// of the final curve, with 8 elements, the x and y coordinates of
	// the control points.

	// normalize parameters
	if ($b === NULL) $b = $a;
	while ($lambda1 < 0) $lambda1 += M_TAU;
	while ($lambda1 >= M_TAU)  $lambda1 -= M_TAU;
	while ($lambda2 <= 0) $lambda2 += M_TAU;
	while ($lambda2 > M_TAU)  $lambda2 -= M_TAU;
	if ($lambda2 < $lambda1){
		// goes through 0; split at 0;
		return array_merge(
			ellipsearc($x, $y, $a, $b, $theta, $lambda1, M_TAU),
			ellipsearc($x, $y, $a, $b, $theta, 0, $lambda2)
		);
	}else if ($lambda2 - $lambda1 > M_PI_2){
		// Draw arcs less than 90 degrees, so bisect the arc
		return array_merge(
			ellipsearc($x, $y, $a, $b, $theta, $lambda1, ($lambda2+$lambda1)/2),
			ellipsearc($x, $y, $a, $b, $theta, ($lambda2+$lambda1)/2, $lambda2)
		);
	}
	
	// scale angles.
	$eta1 = scaleangle($lambda1, $a, $b);
	$eta2 = scaleangle($lambda2, $a, $b);
	
	// find the control points
	$x0 = ellipsepoint($x, $y, $a, $b, $theta, $eta1);
	$x3 = ellipsepoint($x, $y, $a, $b, $theta, $eta2);
	$delta = $eta2-$eta1;
	$tan = tan($delta/2);
	$alpha = sin($delta)*(sqrt(4+3*$tan*$tan)-1)/3; // Maisonobe's equation 15
	// formulae from Maisonobe's section 3.4.1
	$x1 = controlpoint($x0, $alpha);
	$x2 = controlpoint($x3, -$alpha);
	return array(array(
		$x0[0], $x0[1],
		$x1[0], $x1[1],
		$x2[0], $x2[1],
		$x3[0], $x3[1]
	));
}
function scaleangle($lambda, $a, $b){
	// parameterized angle from Maisonobe's section 2.2.1
	return atan2(sin($lambda)/$b, cos($lambda)/$a);
}
function ellipsepoint($x, $y, $a, $b, $theta, $eta){
	// parameterization of an ellipse. Maisonobe's equation 3 and 4
	// returns a 4-element array, with the coordinates first then the derivative
	$costheta = cos($theta);
	$sintheta = sin($theta);
	$coseta = cos($eta);
	$sineta = sin($eta);
	return array(
		$x+$a*$costheta*$coseta-$b*$sintheta*$sineta,
		$y+$a*$sintheta*$coseta+$b*$costheta*$sineta,
		  -$a*$costheta*$sineta-$b*$sintheta*$coseta,
		  -$a*$sintheta*$sineta+$b*$costheta*$coseta,
	);
}
function controlpoint($x, $alpha){
	// returns a point (as a 2-element array) that is $alpha from $x [0,1] along the vector $x[2,3]
	return array(
		$x[0]+$alpha*$x[2],
		$x[1]+$alpha*$x[3]	
	);
}

For example, ellipsearc (100, 120, 45) returns the curves for a circle centered at (100,120) with radius 45, ellipsearc (100, 120, 50, 40) gives an ellipse centered at (100,120) with major axis horizontal, with major semiaxis (half the width) 50 and minor semiaxis (half the height) 40. The "major axis" can be shorter than the minor axis; the designation is just of the axis that determines the orientation. ellipsearc (100, 120, 50, 40, deg2rad(60)) gives an ellipse centered at (100,120) with major axis at 60 degrees from the horizontal, with major semiaxis (half the width) 50 and minor semiaxis (half the height) 40. ellipsearc (100, 120, 45, NULL, 0, deg2rad(45), deg2rad(135)) returns the curves for an arc of a circle centered at (100,120) with radius 45, with the arc extending from 45 degrees to 135 degrees.

It returns an array of arrays, like:

[
  [10,10,20,20,30,30,40,40], // a Bézier curve from (10,10) to (40,40) with control points (20,20) and (30, 30)
  [40,40,50,50,60,60,70,70],
  [80,80,90,90,100,100,10,10]
]

So to draw the ellipse from the sample, use

$arcs = ellipsearc (200, 600, 150, 50);
$pdf->moveto($arc[0][0], $arc[0][1]);
foreach ($arcs as $arc) $pdf->curveto($arc[2], $arc[3], $arc[4], $arc[5], $arc[6], $arc[7]);
$pdf->closepath();
$pdf->stroke (0, 127, 127);

And to draw a wedge (e.g. pie chart):

$arcs = ellipsearc (200, 600, 150, 150, 0, 0, deg2rad(60));
$pdf->moveto(200,600); // the center
$pdf->lineto($arc[0][0], $arc[0][1]);
foreach ($arcs as $arc) $pdf->curveto($arc[2], $arc[3], $arc[4], $arc[5], $arc[6], $arc[7]);
$pdf->closepath();
$pdf->fill(0, 127, 127);

Hope this helps someone; it was interesting for me.

Continued…

We need a couple of objects:

Catalog

This serves as the root object and describes the data structures in the document, which for our purposes is just the collection of printed pages. Other things, like the data for interactive forms, Javascript routines and metadata (author, subject, keywords) would go here.

1 0 obj
<<
  /Type /Catalog
  /Pages 0 2 R % reference to object number 2
>>
endobj

One useful optional entry in the catalog is the /OpenAction that can be used to set the zoom level and opening page. /OpenAction [3 0 R /Fit] starts at the page described in object 3 and zooms in to fit the page on the screen.

See the code.

Pages

The collection of pages. This is just an array of references to the actual pages or to sub-collections of pages. The manual talks about organizing the pages in a balanced tree to make skipping around faster, but we're not that fancy. Our tree is flat. It also includes a /Count entry with the total number of pages (which is not the same as the number of items in the array, since the array could contain references to other Pages collections).

2 0 obj
<<
  /Type /Pages
  /Kids [ 4 0 R ] % One page. They were too cute by half, calling the child objects "Kids"
  /Count 1
>>
endobj

Resources

The resource dictionary that assigns names to all the "stuff" we need on the page—images, fonts, "graphic states" (sets of graphic commands to set the color, pen size, line styles, transparency, etc.) and other things. The page-drawing language (called a "content stream" does not refer to objects in the PDF by number (like 2 0 R) but by the name given in the page's resource dictionary. Since our page doesn't have any content, the dictionary is empty:

3 0 obj
<<
>>
endobj

PDF originally required a /ProcSet entry listing the types of commands used on a page, but that's now obsolete; all the commands are always available. fPDF still includes it, though.

Page

A description of a single page. Mostly just a reference to its contents, which is a stream and as such cannot be directly included (the definition could have allowed the page itself to be the content stream, but that would have been too easy), and the page size, as a rectangle of point (1/72 inch) measures that sets the coordinate system for drawing. Also includes references to its parent Pages collection and the resource dictionary (you could have a separate resource dictionary for every page, but I can't imagine why you'd want to ).

4 0 obj
<<
  /Type /Page
  /Parent 2 0 R
  /Resources 3 0 R
  /Contents 5 0 R
  /MediaBox [ 0 0 612 792 ] % letter-size, in points.
>>
endobj

Contents

The actual content stream for drawing the page. We don't do anything, so this is empty:

5 0 obj
<<
  /Length 0
>>
stream
endstream
endobj

We can put these parts together to create a class that produces blank pages:

$pdf = new bililitePDF_1();
$pdf->newPage();
$pdf->output();

And you can see the result here. Or even create multiple pages. 150 lines of code to do nothing! Whoohoo! But it's a start to putting some real content in those pages.

Continued…

define('_SYSTEM_TTFONTS', '/path/to/your/truetype/fonts/'); // Took a bit of experimenting to find the right values for these
define('FPDF_FONTPATH', _SYSTEM_TTFONTS);
putenv('GDFONTPATH='._SYSTEM_TTFONTS); // so we can use GD images as well
$pdf=new tFPDF();
$pdf->AddPage();
$pdf->SetFont('Arial','B',16);
$pdf->Cell(40,10,'Hello World!');
$pdf->Output();

One gotcha is that you need to create the unifont directory within the fonts folder, and copy tFPDF's ttfonts.php file into that.

The result is here.

PDF Syntax

But to do much more you have to know what a PDF file looks like. The language itself is relatively simple (this has been further simplified so I can remember it):

Comments start with % and go to the end of the line. Whitespace is, in general, the only delimiter. There are 6 data types:

Number

Can be real or integer; no exponential notation. E.g.: 1, -1.2

String

Ascii only! This is a format from 1993, after all. Delimited by parentheses, with the backslash as an escape character. It's smart enough to count parenthesis so you technically don't have to escape them if they're matched, but that's not useful in real life for me. I use regular expressions, and regular expressions can't count. Just escape the parentheses. E.g. (Hello, World), (Escaped \(parentheses\) )

(Strings can
contain newlines)

If you want Unicode, the string has to be UTF-16 (big endian) encoded with a byte order mark (!), enclosed in angle brackets: שלום, עולם is <FEFF05E905DC05D505DD002C05E205D505DC05DD>. A pain but it's codable:

function textstring($s){
  // Assumes $s is UTF8
  // use mb strings with explicit encodings to avoid problems with overloaded
  // regular string functions
  if (mb_strlen($s, 'UTF-8') == mb_strlen($s, '8bit')){
    // Ascii
    return '('.str_replace(array('\\', '(', ')',), array ('\\', '\(','\)'), $s).')';
  }else{
    $ret = '';
    $s = mb_convert_encoding ($s, 'UTF-16BE', 'UTF-8');
    foreach (str_split($s) as $char) $ret .= sprintf('%02X', ord($char)); // str_split should not be overloaded according to the manual
    return "<FEFF$ret>";
  }
}

Name

These are the symbols used to represent external objects (like fonts or images) or keywords and indices into associative arrays. A name is a slash followed by "regular characters" which for all intents and purposes means alphanumerics. E.g. /Name, /Image3

Technically, names can include any character if encoded as # then 2-digit hex value, with all characters 8-bit. Programmatically:

define (PDF_DELIMITERS, '()<>{}%#/');
function name ($data){
	$ret = '/';
	foreach(str_split($data) as $c){
		$ord = ord($c);
		if ($ord == 0){
			 // str_split will give nulls for empty strings; ignore them
		}elseif ($ord < 33 /* whitespace and control characters */ || $ord > 126 /* hi bit set */ || strpos(PDF_DELIMITERS, $c) !== FALSE){
			$ret .= sprintf('#%02X', $ord);
		}else{
			$ret .= $c;
		}
	}
	return $ret;
}

Dictionary

An associative array, with the key for each pair being a name and the data being any single data item. Delimited by << and >>, with the key/data pairs just listed (the order is irrelevant). E.g.

<<
  /Name (textbox)
  /Width 20
  /Rules << /Numeric /Yes /Positive /No >> % dictionaries are data and can be nested. 
                % This subdictionary has two entries, /Numeric and /Positive
>>

Programmatically,

function dictionary($arr){
	$ret = "<<\n";
	foreach($arr as $key=>$value) $ret .= this->name($key)." $value\n";
	return "$ret>>\n";
}

Array

A linear list of data, delimited by square brackets. The order matters. E.g. [ 1 2 3 ], [ /First 2 /Third (Fourth) <</dic 1>> ]

That's simply

function pdfarray($arr){
	$ret = "[\n";
	foreach($arr as $value) $ret .= " $value ";
	return "$ret]\n";
}

Stream

A string of bytes, surrounded by the words stream and endstream on lines by themselves, preceded by a dictionary that describes the string. At a minimum the dictionary needs a /Length entry with the length of the string in bytes. Yes, that's redundant in a delimited string, but that's the definition. Adobe Reader is smart enough to figure out the length if you leave out this entry. The bytes are not necessarily Ascii and are not defined by the PDF definition. Pages are streams, with the dictionary providing the metadata about the page and the string being the list of drawing commands (which is its own language). E.g.

<<
  /Length 54
  /Fonts [/F1 /F2 /F3]
  /Width 37
  /Height 92
>> % the following is *not* the actual PDF drawing language
stream
1 2 moveto
4 5 lineto
/F1 setfont
(Hello, World) text
endstream

It's possible to store a compressed string if there's a /Filter entry in the dictionary whose value is the name of the compression algorithm used. The types of algorithms are built-in; there are a couple for image files and zlib for text (that filter name is /FlateDecode for reasons I can't fathom) (Yes, it would make sense to just gzip the whole file rather than pieces, but I'm not in charge). The compression makes the PDF harder to debug, so FPDF includes a function $pdf->SetCompression(false) to not use it. The /Length refers to the final, compressed length.

Programmatically,

function stream($arr, $data){
	if ($this->bCompress){ // assumes this is a flag set somewhere
		$data = gzcompress($data);
		$arr['Filter'] = this->name('FlateDecode');
	}
	$arr['Length'] = strlen($data);
	return this->dictionary($arr)."stream\n$data\nendstream";
}

In an ordinary programming language, you would declare variables to hold the data above. In PDF, these are called "indirect objects" and they are numbered, not named. In fact, they get two numbers, the object number and the "generation number" which is used when the PDF file is updated. Since we're generating PDFs from scratch, all our generation numbers are zero. Indirect objects are assigned with object-number generation-number obj datum endobj. E.g.

1 0 obj
  [ (array) (of) (strings) ]
endobj

creates object 1. You can use an indirect object anywhere data is required, with object-number generation-number R. That's R as in reference. As you may have noticed, PDF uses a lot of reverse Polish notation, from its origins in Postscript and Forth. E.g.

2 0 obj
  <<
    /Words 1 0 R % Use the array we declared above
    /Language 3 0 R % Forward references are fine
  >>
endobj

3 0 obj
  /English
endobj

Streams have to be indirect objects on their own; they can't be members of a dictionary or array. But references to streams are legal. Thus:

% Illegal
1 0 obj
  <<
    /Type /Page
    /Content
      <</Length 11>>
stream
      1 2 lineto
endstream
  >>
endobj

% Legal
2 0 obj
  <<
    /Type /Page
    /Content 3 0 R
  >>
endobj
3 0 obj
<</Length 11>>
stream
      1 2 lineto
endstream
endobj

The object numbers start at 1 and go up (technically they don't need to be continuous, but it's a headache otherwise). Object 0 is a special magic object with generation number 65,535 that acts as the head of a linked list of deleted objects, used for updating PDF files.

PDF File Structure

A PDF file is just a list of indirect objects, with a Catalog dictionary containing a reference to a Pages dictionary that contains an array of references to Page dictionaries that each contain references to their Contents streams, which is the drawing instructions for that page. The Page dictionary also contains a reference to a Resources dictionary, which associates names with other objects like fonts, graphic states and images. The drawing instructions use those names, not the object references.

A logical way to organize this would be just to list the objects and have the reading program parse the file and create an array of objects. PDF assumes that you don't have enough memory for that, so the file itself contains the table of byte offsets of each object and acts as its own internal representation. Thus when creating the PDF, FPDF does something similar to:

function newobject($data){
  $objectNumber = count($this->objectOffsets)+1; // need to start from object 1
  $this->objectOffsets[] = strlen($this->buffer); // keep track of where this object starts in the final file
  $this->buffer .= "$objectNumber 0 obj \n $data \n endobj \n";
}

The actual file starts with a comment with the PDF version number (the ISO standard is 1.7): %PDF-1.7, then the objects (in any order; the object number is determined by the n 0 obj statement). This is followed by the crossreference table (the above mentioned table of byte offsets) that has a fixed byte-level format, to make access faster:

function xref(){
  $numObjects = count($this->objectOffsets) + 1; // include the magic object 0
  $this->xrefOffset = strlen($this->buffer); // we'll need this later
  $this->buffer .= "xref\n";
  $this->buffer .= "0 $numObjects\n";
  $this->buffer .= "0000000000 65535 f \n"; // the magic object 0
  // output the offset, the generation number (always 0) and "n" for "in use"
  // use sprintf to make sure it has exactly the right number of bytes
  foreach ($this->objectOffsets as $offset) $this->buffer .= sprintf("%010d %05d n \n",$offset);
}

After that is the "trailer," a dictionary that tells the PDF reader how many objects there are and which one is the "root," the main Catalog dictionary, and a pointer to the start of the crossreference table, and a comment to mark the end of the file (yes, there's lots of redundancy here):

function trailer(){
  $xrefOffset = $this->xrefOffset;
  $numObjects = count($this->objectOffsets) + 1; // include the magic object 0
  $root = $this->rootObject; // this needs to have been set at some point
  $this->buffer .= 'trailer << ';
  $this->buffer .= "/Size $numObjects ";
  $this->buffer .= "/Root $root 0 R ";
  $this->buffer .= ">>\n";
  $this->buffer .= "startxref\n$xrefOffset\n%%EOF";
}

You can put more information in the trailer dictionary; see page 43 of the PDF spec, table 15.

And then dump the buffer (with the appropriate content header for the web) and you're done!. Of course, this page doesn't say anything about what goes into those objects, but at least it's a start to understanding what FPDF does and debugging the resulting document.

Continued…

<?

$appid = 'your app id here'; // for Bing Search API
$q = $_GET['q'];
if (get_magic_quotes_gpc()) $q = stripslashes($q);
// note that $q is unsafe!
?>

<form method="get" action="">
  <input name="q" type="text" value="<?=htmlentities($q)?>" />
  <input type="submit" value="Search" />
</form>

<?

function sitesearch ($query, $site, $appid, $count=NULL){
  $url = "http://api.search.live.net/json.aspx?AppID=$appid&sources=Web&query=".urlencode("$query site:$site");
  if ($count) $url .= "&web.count=$count";
  $ch = curl_init($url);
  curl_setopt ($ch, CURLOPT_RETURNTRANSFER, TRUE);
  $result = curl_exec($ch);
  curl_close($ch);
  return json_decode($result);
}

function showerrors($errors){
  echo "<p>Search Error<p>\n";
  foreach ($errors as $error) echo "<p><a href='{$error->HelpUrl}'>{$error->Message}</a>\n";
}

function showresponse ($q, $total, $results){
  $count = count($results);
  if ($count==0){
    $resultwords = 'No results';
  }else if ($total > $count){
    $resultwords = "More than $count results";
  }else if ($count == 1){
    $resultwords = '1 result';
  }else{
    $resultwords = "$count results";
  }
  echo "<p>$resultwords found for <strong>".htmlentities($q)."</strong></p>\n";
  if ($count == 0) return;
  echo "<dl>\n";
  foreach ($results as $result) echo "<dt><a href='{$result->Url}'>{$result->Title}</a></dt>\n<dd>{$result->Description}</dd>\n";
  echo "</dl>\n";    
}

if ($q){
  // get search results
  $result = sitesearch ($q, $_SERVER['HTTP_HOST'], $appid, 10);
  if ($result->SearchResponse->Errors){
    showerrors($result->SearchResponse->Errors);
  }else{
    showresponse($q, $result->SearchResponse->Web->Total, $result->SearchResponse->Web->Results);
  }
  $searchURL = 'http://www.bing.com/search?q='.urlencode("$q site:{$_SERVER['HTTP_HOST']}");
  echo "<p><a href='$searchURL'>See all results</a><p>\n";
}

The code works, though I have to say that Google's search gives better results. The advantage of a stable API outweighs that, I think. You can see it in action on the home page.

One incredibly stupid thing for Microsoft to miss though: bing.com is not a valid URL; you have to use www.bing.com. Who does that anymore?