nilsteampassnet / TeamPass

includes/libraries/PasswordLib/Core/Enum.php

Doc Comments +2 added lines, -2 removed lines

@@ -49,7 +49,7 @@ 
      * @param mixed   $value  The value this instance represents
      * @param boolean $strict Not Implemented at this time
      *
-     * @return void
+     * @return Strength
      * @throws UnexpectedValueException If the value is not a constant
      */
     public function __construct($value = null, $strict = false) {
@@ -69,7 +69,7 @@ 
     /**
      * Cast the current object to a string and return its value
      *
-     * @return mixed the current value of the instance
+     * @return string the current value of the instance
      */
     public function __toString() {
         return (string) $this->value;

Spacing +1 added lines, -1 removed lines

@@ -60,7 +60,7 @@
         $this->name  = array_search($value, $validValues);
         if (!$this->name) {
             throw new \UnexpectedValueException(
-                'Value not a const in enum ' . get_class($this)
+                'Value not a const in enum '.get_class($this)
             );
         }
         $this->value = $value;

includes/libraries/PasswordLib/Key/Derivation/PBKDF.php

Doc Comments +1 added lines, -2 removed lines

@@ -35,10 +35,9 @@
     /**
      * Derive a key from the supplied arguments
      *
-     * @param string $password   The password to derive from
      * @param string $salt       The salt string to use
      * @param int    $iterations The number of iterations to use
-     * @param int    $length     The size of the string to generate
+     * @param integer $klen
      *
      * @return string The derived key
      */

includes/libraries/PasswordLib/Password/AbstractPassword.php

Doc Comments +2 added lines, -2 removed lines

@@ -77,7 +77,7 @@ 
      * Build a new instance
      *
      * @param array     $options    An array of options for the password isntance
-     * @param Generator $generator  The random generator to use for seeds
+     * @param \PasswordLib\Random\Generator $generator  The random generator to use for seeds
      *
      * @return void
      */
@@ -124,7 +124,7 @@ 
     /**
      * Set the random number generator to use
      *
-     * @param Generator $generator  The random generator to use for seeds
+     * @param \PasswordLib\Random\Generator $generator  The random generator to use for seeds
      *
      * @return void     
      */

includes/libraries/Pdf/Tfpdf/font/unifont/ttfonts.php

Doc Comments +50 added lines

@@ -74,6 +74,9 @@ 
 	}
 
 
+	/**
+	 * @param string $file
+	 */
 	function getMetrics($file) {
 		$this->filename = $file;
 		$this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file);
@@ -116,6 +119,10 @@ 
 	}
 
 
+	/**
+	 * @param integer[] $x
+	 * @param integer[] $y
+	 */
 	function sub32($x, $y) {
 		$xlo = $x[1];
 		$xhi = $x[0];
@@ -154,11 +161,17 @@ 
 		fseek($this->fh,$this->_pos);
 	}
 
+	/**
+	 * @param integer $delta
+	 */
 	function skip($delta) {
 		$this->_pos = $this->_pos + $delta;
 		fseek($this->fh,$this->_pos);
 	}
 
+	/**
+	 * @param string $tag
+	 */
 	function seek_table($tag, $offset_in_table = 0) {
 		$tpos = $this->get_table_pos($tag);
 		$this->_pos = $tpos[0] + $offset_in_table;
@@ -222,10 +235,17 @@ 
 		return pack("n",$val); 
 	}
 
+	/**
+	 * @param string $value
+	 */
 	function splice($stream, $offset, $value) {
 		return substr($stream,0,$offset) . $value . substr($stream,$offset+strlen($value));
 	}
 
+	/**
+	 * @param string|null $stream
+	 * @param integer $offset
+	 */
 	function _set_ushort($stream, $offset, $value) {
 		$up = pack("n", $value);
 		return $this->splice($stream, $offset, $up);
@@ -247,6 +267,9 @@ 
 		return (fread($this->fh,$length));
 	}
 
+	/**
+	 * @param string $tag
+	 */
 	function get_table($tag) {
 		list($pos, $length) = $this->get_table_pos($tag);
 		if ($length == 0) { die('Truetype font ('.$this->filename.'): error reading table: '.$tag); }
@@ -254,6 +277,10 @@ 
 		return (fread($this->fh,$length));
 	}
 
+	/**
+	 * @param string $tag
+	 * @param null|string $data
+	 */
 	function add($tag, $data) {
 		if ($tag == 'head') {
 			$data = $this->splice($data, 8, "\0\0\0\0");
@@ -491,6 +518,9 @@ 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 
+	/**
+	 * @return string
+	 */
 	function makeSubset($file, &$subset) {
 		$this->filename = $file;
 		$this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file);
@@ -884,6 +914,11 @@ 
 
 	//////////////////////////////////////////////////////////////////////////////////
 
+	/**
+	 * @param integer $numberOfHMetrics
+	 * @param integer $numGlyphs
+	 * @param integer $scale
+	 */
 	function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) {
 		$start = $this->seek_table("hmtx");
 		$aw = 0;
@@ -949,6 +984,9 @@ 
 		$this->charWidths[1] = chr($nCharWidths & 0xFF);
 	}
 
+	/**
+	 * @param integer $numberOfHMetrics
+	 */
 	function getHMetric($numberOfHMetrics, $gid) {
 		$start = $this->seek_table("hmtx");
 		if ($gid < $numberOfHMetrics) {
@@ -964,6 +1002,10 @@ 
 		return $hm;
 	}
 
+	/**
+	 * @param integer $indexToLocFormat
+	 * @param integer $numGlyphs
+	 */
 	function getLOCA($indexToLocFormat, $numGlyphs) {
 		$start = $this->seek_table('loca');
 		$this->glyphPos = array();
@@ -987,6 +1029,10 @@ 
 
 
 	// CMAP Format 4
+
+	/**
+	 * @param integer $unicode_cmap_offset
+	 */
 	function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph ) {
 		$this->maxUniChar = 0;
 		$this->seek($unicode_cmap_offset + 2);
@@ -1032,6 +1078,10 @@ 
 
 
 		// Put the TTF file together
+
+	/**
+	 * @param string $stm
+	 */
 	function endTTFile(&$stm) {
 		$stm = '';
 		$numTables = count($this->otables);

Indentation +985 added lines, -985 removed lines

@@ -69,38 +69,38 @@ 
 var $defaultWidth;
 var $maxStrLenRead;
 
-	function __construct() {
-		$this->maxStrLenRead = 200000;	// Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
-	}
-
-
-	function getMetrics($file) {
-		$this->filename = $file;
-		$this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file);
-		$this->_pos = 0;
-		$this->charWidths = '';
-		$this->glyphPos = array();
-		$this->charToGlyph = array();
-		$this->tables = array();
-		$this->otables = array();
-		$this->ascent = 0;
-		$this->descent = 0;
-		$this->TTCFonts = array();
-		$this->version = $version = $this->read_ulong();
-		if ($version==0x4F54544F) 
-			die("Postscript outlines are not supported");
-		if ($version==0x74746366) 
-			die("ERROR - TrueType Fonts Collections not supported");
-		if (!in_array($version, array(0x00010000,0x74727565)))
-			die("Not a TrueType font: version=".$version);
-		$this->readTableDirectory();
-		$this->extractInfo();
-		fclose($this->fh);
-	}
-
-
-	function readTableDirectory() {
-	    $this->numTables = $this->read_ushort();
+    function __construct() {
+        $this->maxStrLenRead = 200000;	// Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
+    }
+
+
+    function getMetrics($file) {
+        $this->filename = $file;
+        $this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file);
+        $this->_pos = 0;
+        $this->charWidths = '';
+        $this->glyphPos = array();
+        $this->charToGlyph = array();
+        $this->tables = array();
+        $this->otables = array();
+        $this->ascent = 0;
+        $this->descent = 0;
+        $this->TTCFonts = array();
+        $this->version = $version = $this->read_ulong();
+        if ($version==0x4F54544F) 
+            die("Postscript outlines are not supported");
+        if ($version==0x74746366) 
+            die("ERROR - TrueType Fonts Collections not supported");
+        if (!in_array($version, array(0x00010000,0x74727565)))
+            die("Not a TrueType font: version=".$version);
+        $this->readTableDirectory();
+        $this->extractInfo();
+        fclose($this->fh);
+    }
+
+
+    function readTableDirectory() {
+        $this->numTables = $this->read_ushort();
             $this->searchRange = $this->read_ushort();
             $this->entrySelector = $this->read_ushort();
             $this->rangeShift = $this->read_ushort();
@@ -112,154 +112,154 @@ 
                 $record['offset'] = $this->read_ulong();
                 $record['length'] = $this->read_ulong();
                 $this->tables[$record['tag']] = $record;
-		}
-	}
-
-
-	function sub32($x, $y) {
-		$xlo = $x[1];
-		$xhi = $x[0];
-		$ylo = $y[1];
-		$yhi = $y[0];
-		if ($ylo > $xlo) { $xlo += 1 << 16; $yhi += 1; }
-		$reslo = $xlo-$ylo;
-		if ($yhi > $xhi) { $xhi += 1 << 16;  }
-		$reshi = $xhi-$yhi;
-		$reshi = $reshi & 0xFFFF;
-		return array($reshi, $reslo);
-	}
-
-	function calcChecksum($data)  {
-		if (strlen($data) % 4) { $data .= str_repeat("\0",(4-(strlen($data) % 4))); }
-		$hi=0x0000;
-		$lo=0x0000;
-		for($i=0;$i<strlen($data);$i+=4) {
-			$hi += (ord($data[$i])<<8) + ord($data[$i+1]);
-			$lo += (ord($data[$i+2])<<8) + ord($data[$i+3]);
-			$hi += $lo >> 16;
-			$lo = $lo & 0xFFFF;
-			$hi = $hi & 0xFFFF;
-		}
-		return array($hi, $lo);
-	}
-
-	function get_table_pos($tag) {
-		$offset = $this->tables[$tag]['offset'];
-		$length = $this->tables[$tag]['length'];
-		return array($offset, $length);
-	}
-
-	function seek($pos) {
-		$this->_pos = $pos;
-		fseek($this->fh,$this->_pos);
-	}
-
-	function skip($delta) {
-		$this->_pos = $this->_pos + $delta;
-		fseek($this->fh,$this->_pos);
-	}
-
-	function seek_table($tag, $offset_in_table = 0) {
-		$tpos = $this->get_table_pos($tag);
-		$this->_pos = $tpos[0] + $offset_in_table;
-		fseek($this->fh, $this->_pos);
-		return $this->_pos;
-	}
-
-	function read_tag() {
-		$this->_pos += 4;
-		return fread($this->fh,4);
-	}
-
-	function read_short() {
-		$this->_pos += 2;
-		$s = fread($this->fh,2);
-		$a = (ord($s[0])<<8) + ord($s[1]);
-		if ($a & (1 << 15) ) { $a = ($a - (1 << 16)) ; }
-		return $a;
-	}
-
-	function unpack_short($s) {
-		$a = (ord($s[0])<<8) + ord($s[1]);
-		if ($a & (1 << 15) ) { 
-			$a = ($a - (1 << 16)); 
-		}
-		return $a;
-	}
-
-	function read_ushort() {
-		$this->_pos += 2;
-		$s = fread($this->fh,2);
-		return (ord($s[0])<<8) + ord($s[1]);
-	}
-
-	function read_ulong() {
-		$this->_pos += 4;
-		$s = fread($this->fh,4);
-		// if large uInt32 as an integer, PHP converts it to -ve
-		return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
-	}
-
-	function get_ushort($pos) {
-		fseek($this->fh,$pos);
-		$s = fread($this->fh,2);
-		return (ord($s[0])<<8) + ord($s[1]);
-	}
-
-	function get_ulong($pos) {
-		fseek($this->fh,$pos);
-		$s = fread($this->fh,4);
-		// iF large uInt32 as an integer, PHP converts it to -ve
-		return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
-	}
-
-	function pack_short($val) {
-		if ($val<0) { 
-			$val = abs($val);
-			$val = ~$val;
-			$val += 1;
-		}
-		return pack("n",$val); 
-	}
-
-	function splice($stream, $offset, $value) {
-		return substr($stream,0,$offset) . $value . substr($stream,$offset+strlen($value));
-	}
-
-	function _set_ushort($stream, $offset, $value) {
-		$up = pack("n", $value);
-		return $this->splice($stream, $offset, $up);
-	}
-
-	function _set_short($stream, $offset, $val) {
-		if ($val<0) { 
-			$val = abs($val);
-			$val = ~$val;
-			$val += 1;
-		}
-		$up = pack("n",$val); 
-		return $this->splice($stream, $offset, $up);
-	}
-
-	function get_chunk($pos, $length) {
-		fseek($this->fh,$pos);
-		if ($length <1) { return ''; }
-		return (fread($this->fh,$length));
-	}
-
-	function get_table($tag) {
-		list($pos, $length) = $this->get_table_pos($tag);
-		if ($length == 0) { die('Truetype font ('.$this->filename.'): error reading table: '.$tag); }
-		fseek($this->fh,$pos);
-		return (fread($this->fh,$length));
-	}
-
-	function add($tag, $data) {
-		if ($tag == 'head') {
-			$data = $this->splice($data, 8, "\0\0\0\0");
-		}
-		$this->otables[$tag] = $data;
-	}
+        }
+    }
+
+
+    function sub32($x, $y) {
+        $xlo = $x[1];
+        $xhi = $x[0];
+        $ylo = $y[1];
+        $yhi = $y[0];
+        if ($ylo > $xlo) { $xlo += 1 << 16; $yhi += 1; }
+        $reslo = $xlo-$ylo;
+        if ($yhi > $xhi) { $xhi += 1 << 16;  }
+        $reshi = $xhi-$yhi;
+        $reshi = $reshi & 0xFFFF;
+        return array($reshi, $reslo);
+    }
+
+    function calcChecksum($data)  {
+        if (strlen($data) % 4) { $data .= str_repeat("\0",(4-(strlen($data) % 4))); }
+        $hi=0x0000;
+        $lo=0x0000;
+        for($i=0;$i<strlen($data);$i+=4) {
+            $hi += (ord($data[$i])<<8) + ord($data[$i+1]);
+            $lo += (ord($data[$i+2])<<8) + ord($data[$i+3]);
+            $hi += $lo >> 16;
+            $lo = $lo & 0xFFFF;
+            $hi = $hi & 0xFFFF;
+        }
+        return array($hi, $lo);
+    }
+
+    function get_table_pos($tag) {
+        $offset = $this->tables[$tag]['offset'];
+        $length = $this->tables[$tag]['length'];
+        return array($offset, $length);
+    }
+
+    function seek($pos) {
+        $this->_pos = $pos;
+        fseek($this->fh,$this->_pos);
+    }
+
+    function skip($delta) {
+        $this->_pos = $this->_pos + $delta;
+        fseek($this->fh,$this->_pos);
+    }
+
+    function seek_table($tag, $offset_in_table = 0) {
+        $tpos = $this->get_table_pos($tag);
+        $this->_pos = $tpos[0] + $offset_in_table;
+        fseek($this->fh, $this->_pos);
+        return $this->_pos;
+    }
+
+    function read_tag() {
+        $this->_pos += 4;
+        return fread($this->fh,4);
+    }
+
+    function read_short() {
+        $this->_pos += 2;
+        $s = fread($this->fh,2);
+        $a = (ord($s[0])<<8) + ord($s[1]);
+        if ($a & (1 << 15) ) { $a = ($a - (1 << 16)) ; }
+        return $a;
+    }
+
+    function unpack_short($s) {
+        $a = (ord($s[0])<<8) + ord($s[1]);
+        if ($a & (1 << 15) ) { 
+            $a = ($a - (1 << 16)); 
+        }
+        return $a;
+    }
+
+    function read_ushort() {
+        $this->_pos += 2;
+        $s = fread($this->fh,2);
+        return (ord($s[0])<<8) + ord($s[1]);
+    }
+
+    function read_ulong() {
+        $this->_pos += 4;
+        $s = fread($this->fh,4);
+        // if large uInt32 as an integer, PHP converts it to -ve
+        return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
+    }
+
+    function get_ushort($pos) {
+        fseek($this->fh,$pos);
+        $s = fread($this->fh,2);
+        return (ord($s[0])<<8) + ord($s[1]);
+    }
+
+    function get_ulong($pos) {
+        fseek($this->fh,$pos);
+        $s = fread($this->fh,4);
+        // iF large uInt32 as an integer, PHP converts it to -ve
+        return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
+    }
+
+    function pack_short($val) {
+        if ($val<0) { 
+            $val = abs($val);
+            $val = ~$val;
+            $val += 1;
+        }
+        return pack("n",$val); 
+    }
+
+    function splice($stream, $offset, $value) {
+        return substr($stream,0,$offset) . $value . substr($stream,$offset+strlen($value));
+    }
+
+    function _set_ushort($stream, $offset, $value) {
+        $up = pack("n", $value);
+        return $this->splice($stream, $offset, $up);
+    }
+
+    function _set_short($stream, $offset, $val) {
+        if ($val<0) { 
+            $val = abs($val);
+            $val = ~$val;
+            $val += 1;
+        }
+        $up = pack("n",$val); 
+        return $this->splice($stream, $offset, $up);
+    }
+
+    function get_chunk($pos, $length) {
+        fseek($this->fh,$pos);
+        if ($length <1) { return ''; }
+        return (fread($this->fh,$length));
+    }
+
+    function get_table($tag) {
+        list($pos, $length) = $this->get_table_pos($tag);
+        if ($length == 0) { die('Truetype font ('.$this->filename.'): error reading table: '.$tag); }
+        fseek($this->fh,$pos);
+        return (fread($this->fh,$length));
+    }
+
+    function add($tag, $data) {
+        if ($tag == 'head') {
+            $data = $this->splice($data, 8, "\0\0\0\0");
+        }
+        $this->otables[$tag] = $data;
+    }
 
 
 
@@ -268,817 +268,817 @@ 
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-	function extractInfo() {
-		///////////////////////////////////
-		// name - Naming table
-		///////////////////////////////////
-			$this->sFamilyClass = 0;
-			$this->sFamilySubClass = 0;
-
-			$name_offset = $this->seek_table("name");
-			$format = $this->read_ushort();
-			if ($format != 0)
-				die("Unknown name table format ".$format);
-			$numRecords = $this->read_ushort();
-			$string_data_offset = $name_offset + $this->read_ushort();
-			$names = array(1=>'',2=>'',3=>'',4=>'',6=>'');
-			$K = array_keys($names);
-			$nameCount = count($names);
-			for ($i=0;$i<$numRecords; $i++) {
-				$platformId = $this->read_ushort();
-				$encodingId = $this->read_ushort();
-				$languageId = $this->read_ushort();
-				$nameId = $this->read_ushort();
-				$length = $this->read_ushort();
-				$offset = $this->read_ushort();
-				if (!in_array($nameId,$K)) continue;
-				$N = '';
-				if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name
-					$opos = $this->_pos;
-					$this->seek($string_data_offset + $offset);
-					if ($length % 2 != 0)
-						die("PostScript name is UTF-16BE string of odd length");
-					$length /= 2;
-					$N = '';
-					while ($length > 0) {
-						$char = $this->read_ushort();
-						$N .= (chr($char));
-						$length -= 1;
-					}
-					$this->_pos = $opos;
-					$this->seek($opos);
-				}
-				else if ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name
-					$opos = $this->_pos;
-					$N = $this->get_chunk($string_data_offset + $offset, $length);
-					$this->_pos = $opos;
-					$this->seek($opos);
-				}
-				if ($N && $names[$nameId]=='') {
-					$names[$nameId] = $N;
-					$nameCount -= 1;
-					if ($nameCount==0) break;
-				}
-			}
-			if ($names[6])
-				$psName = $names[6];
-			else if ($names[4])
-				$psName = preg_replace('/ /','-',$names[4]);
-			else if ($names[1])
-				$psName = preg_replace('/ /','-',$names[1]);
-			else
-				$psName = '';
-			if (!$psName)
-				die("Could not find PostScript font name");
-			$this->name = $psName;
-			if ($names[1]) { $this->familyName = $names[1]; } else { $this->familyName = $psName; }
-			if ($names[2]) { $this->styleName = $names[2]; } else { $this->styleName = 'Regular'; }
-			if ($names[4]) { $this->fullName = $names[4]; } else { $this->fullName = $psName; }
-			if ($names[3]) { $this->uniqueFontID = $names[3]; } else { $this->uniqueFontID = $psName; }
-			if ($names[6]) { $this->fullName = $names[6]; }
-
-		///////////////////////////////////
-		// head - Font header table
-		///////////////////////////////////
-		$this->seek_table("head");
-		$this->skip(18); 
-		$this->unitsPerEm = $unitsPerEm = $this->read_ushort();
-		$scale = 1000 / $unitsPerEm;
-		$this->skip(16);
-		$xMin = $this->read_short();
-		$yMin = $this->read_short();
-		$xMax = $this->read_short();
-		$yMax = $this->read_short();
-		$this->bbox = array(($xMin*$scale), ($yMin*$scale), ($xMax*$scale), ($yMax*$scale));
-		$this->skip(3*2);
-		$indexToLocFormat = $this->read_ushort();
-		$glyphDataFormat = $this->read_ushort();
-		if ($glyphDataFormat != 0)
-			die('Unknown glyph data format '.$glyphDataFormat);
-
-		///////////////////////////////////
-		// hhea metrics table
-		///////////////////////////////////
-		// ttf2t1 seems to use this value rather than the one in OS/2 - so put in for compatibility
-		if (isset($this->tables["hhea"])) {
-			$this->seek_table("hhea");
-			$this->skip(4);
-			$hheaAscender = $this->read_short();
-			$hheaDescender = $this->read_short();
-			$this->ascent = ($hheaAscender *$scale);
-			$this->descent = ($hheaDescender *$scale);
-		}
-
-		///////////////////////////////////
-		// OS/2 - OS/2 and Windows metrics table
-		///////////////////////////////////
-		if (isset($this->tables["OS/2"])) {
-			$this->seek_table("OS/2");
-			$version = $this->read_ushort();
-			$this->skip(2);
-			$usWeightClass = $this->read_ushort();
-			$this->skip(2);
-			$fsType = $this->read_ushort();
-			if ($fsType == 0x0002 || ($fsType & 0x0300) != 0) {
-				die('ERROR - Font file '.$this->filename.' cannot be embedded due to copyright restrictions.');
-				$this->restrictedUse = true;
-			}
-			$this->skip(20);
-			$sF = $this->read_short();
-			$this->sFamilyClass = ($sF >> 8);
-			$this->sFamilySubClass = ($sF & 0xFF);
-			$this->_pos += 10;  //PANOSE = 10 byte length
-			$panose = fread($this->fh,10);
-			$this->skip(26);
-			$sTypoAscender = $this->read_short();
-			$sTypoDescender = $this->read_short();
-			if (!$this->ascent) $this->ascent = ($sTypoAscender*$scale);
-			if (!$this->descent) $this->descent = ($sTypoDescender*$scale);
-			if ($version > 1) {
-				$this->skip(16);
-				$sCapHeight = $this->read_short();
-				$this->capHeight = ($sCapHeight*$scale);
-			}
-			else {
-				$this->capHeight = $this->ascent;
-			}
-		}
-		else {
-			$usWeightClass = 500;
-			if (!$this->ascent) $this->ascent = ($yMax*$scale);
-			if (!$this->descent) $this->descent = ($yMin*$scale);
-			$this->capHeight = $this->ascent;
-		}
-		$this->stemV = 50 + intval(pow(($usWeightClass / 65.0),2));
-
-		///////////////////////////////////
-		// post - PostScript table
-		///////////////////////////////////
-		$this->seek_table("post");
-		$this->skip(4); 
-		$this->italicAngle = $this->read_short() + $this->read_ushort() / 65536.0;
-		$this->underlinePosition = $this->read_short() * $scale;
-		$this->underlineThickness = $this->read_short() * $scale;
-		$isFixedPitch = $this->read_ulong();
-
-		$this->flags = 4;
-
-		if ($this->italicAngle!= 0) 
-			$this->flags = $this->flags | 64;
-		if ($usWeightClass >= 600)
-			$this->flags = $this->flags | 262144;
-		if ($isFixedPitch)
-			$this->flags = $this->flags | 1;
-
-		///////////////////////////////////
-		// hhea - Horizontal header table
-		///////////////////////////////////
-		$this->seek_table("hhea");
-		$this->skip(32); 
-		$metricDataFormat = $this->read_ushort();
-		if ($metricDataFormat != 0)
-			die('Unknown horizontal metric data format '.$metricDataFormat);
-		$numberOfHMetrics = $this->read_ushort();
-		if ($numberOfHMetrics == 0) 
-			die('Number of horizontal metrics is 0');
-
-		///////////////////////////////////
-		// maxp - Maximum profile table
-		///////////////////////////////////
-		$this->seek_table("maxp");
-		$this->skip(4); 
-		$numGlyphs = $this->read_ushort();
-
-
-		///////////////////////////////////
-		// cmap - Character to glyph index mapping table
-		///////////////////////////////////
-		$cmap_offset = $this->seek_table("cmap");
-		$this->skip(2);
-		$cmapTableCount = $this->read_ushort();
-		$unicode_cmap_offset = 0;
-		for ($i=0;$i<$cmapTableCount;$i++) {
-			$platformID = $this->read_ushort();
-			$encodingID = $this->read_ushort();
-			$offset = $this->read_ulong();
-			$save_pos = $this->_pos;
-			if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
-				$format = $this->get_ushort($cmap_offset + $offset);
-				if ($format == 4) {
-					if (!$unicode_cmap_offset) $unicode_cmap_offset = $cmap_offset + $offset;
-					break;
-				}
-			}
-			$this->seek($save_pos );
-		}
-		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
-
-
-		$glyphToChar = array();
-		$charToGlyph = array();
-		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph );
-
-		///////////////////////////////////
-		// hmtx - Horizontal metrics table
-		///////////////////////////////////
-		$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
-
-	}
+    function extractInfo() {
+        ///////////////////////////////////
+        // name - Naming table
+        ///////////////////////////////////
+            $this->sFamilyClass = 0;
+            $this->sFamilySubClass = 0;
+
+            $name_offset = $this->seek_table("name");
+            $format = $this->read_ushort();
+            if ($format != 0)
+                die("Unknown name table format ".$format);
+            $numRecords = $this->read_ushort();
+            $string_data_offset = $name_offset + $this->read_ushort();
+            $names = array(1=>'',2=>'',3=>'',4=>'',6=>'');
+            $K = array_keys($names);
+            $nameCount = count($names);
+            for ($i=0;$i<$numRecords; $i++) {
+                $platformId = $this->read_ushort();
+                $encodingId = $this->read_ushort();
+                $languageId = $this->read_ushort();
+                $nameId = $this->read_ushort();
+                $length = $this->read_ushort();
+                $offset = $this->read_ushort();
+                if (!in_array($nameId,$K)) continue;
+                $N = '';
+                if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name
+                    $opos = $this->_pos;
+                    $this->seek($string_data_offset + $offset);
+                    if ($length % 2 != 0)
+                        die("PostScript name is UTF-16BE string of odd length");
+                    $length /= 2;
+                    $N = '';
+                    while ($length > 0) {
+                        $char = $this->read_ushort();
+                        $N .= (chr($char));
+                        $length -= 1;
+                    }
+                    $this->_pos = $opos;
+                    $this->seek($opos);
+                }
+                else if ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name
+                    $opos = $this->_pos;
+                    $N = $this->get_chunk($string_data_offset + $offset, $length);
+                    $this->_pos = $opos;
+                    $this->seek($opos);
+                }
+                if ($N && $names[$nameId]=='') {
+                    $names[$nameId] = $N;
+                    $nameCount -= 1;
+                    if ($nameCount==0) break;
+                }
+            }
+            if ($names[6])
+                $psName = $names[6];
+            else if ($names[4])
+                $psName = preg_replace('/ /','-',$names[4]);
+            else if ($names[1])
+                $psName = preg_replace('/ /','-',$names[1]);
+            else
+                $psName = '';
+            if (!$psName)
+                die("Could not find PostScript font name");
+            $this->name = $psName;
+            if ($names[1]) { $this->familyName = $names[1]; } else { $this->familyName = $psName; }
+            if ($names[2]) { $this->styleName = $names[2]; } else { $this->styleName = 'Regular'; }
+            if ($names[4]) { $this->fullName = $names[4]; } else { $this->fullName = $psName; }
+            if ($names[3]) { $this->uniqueFontID = $names[3]; } else { $this->uniqueFontID = $psName; }
+            if ($names[6]) { $this->fullName = $names[6]; }
+
+        ///////////////////////////////////
+        // head - Font header table
+        ///////////////////////////////////
+        $this->seek_table("head");
+        $this->skip(18); 
+        $this->unitsPerEm = $unitsPerEm = $this->read_ushort();
+        $scale = 1000 / $unitsPerEm;
+        $this->skip(16);
+        $xMin = $this->read_short();
+        $yMin = $this->read_short();
+        $xMax = $this->read_short();
+        $yMax = $this->read_short();
+        $this->bbox = array(($xMin*$scale), ($yMin*$scale), ($xMax*$scale), ($yMax*$scale));
+        $this->skip(3*2);
+        $indexToLocFormat = $this->read_ushort();
+        $glyphDataFormat = $this->read_ushort();
+        if ($glyphDataFormat != 0)
+            die('Unknown glyph data format '.$glyphDataFormat);
+
+        ///////////////////////////////////
+        // hhea metrics table
+        ///////////////////////////////////
+        // ttf2t1 seems to use this value rather than the one in OS/2 - so put in for compatibility
+        if (isset($this->tables["hhea"])) {
+            $this->seek_table("hhea");
+            $this->skip(4);
+            $hheaAscender = $this->read_short();
+            $hheaDescender = $this->read_short();
+            $this->ascent = ($hheaAscender *$scale);
+            $this->descent = ($hheaDescender *$scale);
+        }
+
+        ///////////////////////////////////
+        // OS/2 - OS/2 and Windows metrics table
+        ///////////////////////////////////
+        if (isset($this->tables["OS/2"])) {
+            $this->seek_table("OS/2");
+            $version = $this->read_ushort();
+            $this->skip(2);
+            $usWeightClass = $this->read_ushort();
+            $this->skip(2);
+            $fsType = $this->read_ushort();
+            if ($fsType == 0x0002 || ($fsType & 0x0300) != 0) {
+                die('ERROR - Font file '.$this->filename.' cannot be embedded due to copyright restrictions.');
+                $this->restrictedUse = true;
+            }
+            $this->skip(20);
+            $sF = $this->read_short();
+            $this->sFamilyClass = ($sF >> 8);
+            $this->sFamilySubClass = ($sF & 0xFF);
+            $this->_pos += 10;  //PANOSE = 10 byte length
+            $panose = fread($this->fh,10);
+            $this->skip(26);
+            $sTypoAscender = $this->read_short();
+            $sTypoDescender = $this->read_short();
+            if (!$this->ascent) $this->ascent = ($sTypoAscender*$scale);
+            if (!$this->descent) $this->descent = ($sTypoDescender*$scale);
+            if ($version > 1) {
+                $this->skip(16);
+                $sCapHeight = $this->read_short();
+                $this->capHeight = ($sCapHeight*$scale);
+            }
+            else {
+                $this->capHeight = $this->ascent;
+            }
+        }
+        else {
+            $usWeightClass = 500;
+            if (!$this->ascent) $this->ascent = ($yMax*$scale);
+            if (!$this->descent) $this->descent = ($yMin*$scale);
+            $this->capHeight = $this->ascent;
+        }
+        $this->stemV = 50 + intval(pow(($usWeightClass / 65.0),2));
+
+        ///////////////////////////////////
+        // post - PostScript table
+        ///////////////////////////////////
+        $this->seek_table("post");
+        $this->skip(4); 
+        $this->italicAngle = $this->read_short() + $this->read_ushort() / 65536.0;
+        $this->underlinePosition = $this->read_short() * $scale;
+        $this->underlineThickness = $this->read_short() * $scale;
+        $isFixedPitch = $this->read_ulong();
+
+        $this->flags = 4;
+
+        if ($this->italicAngle!= 0) 
+            $this->flags = $this->flags | 64;
+        if ($usWeightClass >= 600)
+            $this->flags = $this->flags | 262144;
+        if ($isFixedPitch)
+            $this->flags = $this->flags | 1;
+
+        ///////////////////////////////////
+        // hhea - Horizontal header table
+        ///////////////////////////////////
+        $this->seek_table("hhea");
+        $this->skip(32); 
+        $metricDataFormat = $this->read_ushort();
+        if ($metricDataFormat != 0)
+            die('Unknown horizontal metric data format '.$metricDataFormat);
+        $numberOfHMetrics = $this->read_ushort();
+        if ($numberOfHMetrics == 0) 
+            die('Number of horizontal metrics is 0');
+
+        ///////////////////////////////////
+        // maxp - Maximum profile table
+        ///////////////////////////////////
+        $this->seek_table("maxp");
+        $this->skip(4); 
+        $numGlyphs = $this->read_ushort();
+
+
+        ///////////////////////////////////
+        // cmap - Character to glyph index mapping table
+        ///////////////////////////////////
+        $cmap_offset = $this->seek_table("cmap");
+        $this->skip(2);
+        $cmapTableCount = $this->read_ushort();
+        $unicode_cmap_offset = 0;
+        for ($i=0;$i<$cmapTableCount;$i++) {
+            $platformID = $this->read_ushort();
+            $encodingID = $this->read_ushort();
+            $offset = $this->read_ulong();
+            $save_pos = $this->_pos;
+            if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
+                $format = $this->get_ushort($cmap_offset + $offset);
+                if ($format == 4) {
+                    if (!$unicode_cmap_offset) $unicode_cmap_offset = $cmap_offset + $offset;
+                    break;
+                }
+            }
+            $this->seek($save_pos );
+        }
+        if (!$unicode_cmap_offset)
+            die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+
+
+        $glyphToChar = array();
+        $charToGlyph = array();
+        $this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph );
+
+        ///////////////////////////////////
+        // hmtx - Horizontal metrics table
+        ///////////////////////////////////
+        $this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
+
+    }
 
 
 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
 
 
-	function makeSubset($file, &$subset) {
-		$this->filename = $file;
-		$this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file);
-		$this->_pos = 0;
-		$this->charWidths = '';
-		$this->glyphPos = array();
-		$this->charToGlyph = array();
-		$this->tables = array();
-		$this->otables = array();
-		$this->ascent = 0;
-		$this->descent = 0;
-		$this->skip(4);
-		$this->maxUni = 0;
-		$this->readTableDirectory();
-
-
-		///////////////////////////////////
-		// head - Font header table
-		///////////////////////////////////
-		$this->seek_table("head");
-		$this->skip(50); 
-		$indexToLocFormat = $this->read_ushort();
-		$glyphDataFormat = $this->read_ushort();
-
-		///////////////////////////////////
-		// hhea - Horizontal header table
-		///////////////////////////////////
-		$this->seek_table("hhea");
-		$this->skip(32); 
-		$metricDataFormat = $this->read_ushort();
-		$orignHmetrics = $numberOfHMetrics = $this->read_ushort();
-
-		///////////////////////////////////
-		// maxp - Maximum profile table
-		///////////////////////////////////
-		$this->seek_table("maxp");
-		$this->skip(4);
-		$numGlyphs = $this->read_ushort();
-
-
-		///////////////////////////////////
-		// cmap - Character to glyph index mapping table
-		///////////////////////////////////
-		$cmap_offset = $this->seek_table("cmap");
-		$this->skip(2);
-		$cmapTableCount = $this->read_ushort();
-		$unicode_cmap_offset = 0;
-		for ($i=0;$i<$cmapTableCount;$i++) {
-			$platformID = $this->read_ushort();
-			$encodingID = $this->read_ushort();
-			$offset = $this->read_ulong();
-			$save_pos = $this->_pos;
-			if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
-				$format = $this->get_ushort($cmap_offset + $offset);
-				if ($format == 4) {
-					$unicode_cmap_offset = $cmap_offset + $offset;
-					break;
-				}
-			}
-			$this->seek($save_pos );
-		}
-
-		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
-
-
-		$glyphToChar = array();
-		$charToGlyph = array();
-		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph );
-
-		$this->charToGlyph = $charToGlyph;
-
-		///////////////////////////////////
-		// hmtx - Horizontal metrics table
-		///////////////////////////////////
-		$scale = 1;	// not used
-		$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
-
-		///////////////////////////////////
-		// loca - Index to location
-		///////////////////////////////////
-		$this->getLOCA($indexToLocFormat, $numGlyphs);
-
-		$subsetglyphs = array(0=>0); 
-		$subsetCharToGlyph = array();
-		foreach($subset AS $code) {
-			if (isset($this->charToGlyph[$code])) {
-				$subsetglyphs[$this->charToGlyph[$code]] = $code;	// Old Glyph ID => Unicode
-				$subsetCharToGlyph[$code] = $this->charToGlyph[$code];	// Unicode to old GlyphID
-
-			}
-			$this->maxUni = max($this->maxUni, $code);
-		}
-
-		list($start,$dummy) = $this->get_table_pos('glyf');
-
-		$glyphSet = array();
-		ksort($subsetglyphs);
-		$n = 0;
-		$fsLastCharIndex = 0;	// maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
-		foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
-			$fsLastCharIndex = max($fsLastCharIndex , $uni);
-			$glyphSet[$originalGlyphIdx] = $n;	// old glyphID to new glyphID
-			$n++;
-		}
-
-		ksort($subsetCharToGlyph);
-		foreach($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
-			$codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx] ;
-		}
-		$this->codeToGlyph = $codeToGlyph;
-
-		ksort($subsetglyphs);
-		foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
-			$this->getGlyphs($originalGlyphIdx, $start, $glyphSet, $subsetglyphs);
-		}
-
-		$numGlyphs = $numberOfHMetrics = count($subsetglyphs );
-
-		//tables copied from the original
-		$tags = array ('name');
-		foreach($tags AS $tag) { $this->add($tag, $this->get_table($tag)); }
-		$tags = array ('cvt ', 'fpgm', 'prep', 'gasp');
-		foreach($tags AS $tag) {
-			if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); }
-		}
-
-		// post - PostScript
-		$opost = $this->get_table('post');
-		$post = "\x00\x03\x00\x00" . substr($opost,4,12) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-		$this->add('post', $post);
-
-		// Sort CID2GID map into segments of contiguous codes
-		ksort($codeToGlyph);
-		unset($codeToGlyph[0]);
-		//unset($codeToGlyph[65535]);
-		$rangeid = 0;
-		$range = array();
-		$prevcid = -2;
-		$prevglidx = -1;
-		// for each character
-		foreach ($codeToGlyph as $cid => $glidx) {
-			if ($cid == ($prevcid + 1) && $glidx == ($prevglidx + 1)) {
-				$range[$rangeid][] = $glidx;
-			} else {
-				// new range
-				$rangeid = $cid;
-				$range[$rangeid] = array();
-				$range[$rangeid][] = $glidx;
-			}
-			$prevcid = $cid;
-			$prevglidx = $glidx;
-		}
-
-		// cmap - Character to glyph mapping - Format 4 (MS / )
-		$segCount = count($range) + 1;	// + 1 Last segment has missing character 0xFFFF
-		$searchRange = 1;
-		$entrySelector = 0;
-		while ($searchRange * 2 <= $segCount ) {
-			$searchRange = $searchRange * 2;
-			$entrySelector = $entrySelector + 1;
-		}
-		$searchRange = $searchRange * 2;
-		$rangeShift = $segCount * 2 - $searchRange;
-		$length = 16 + (8*$segCount ) + ($numGlyphs+1);
-		$cmap = array(0, 1,		// Index : version, number of encoding subtables
-			3, 1,				// Encoding Subtable : platform (MS=3), encoding (Unicode)
-			0, 12,			// Encoding Subtable : offset (hi,lo)
-			4, $length, 0, 		// Format 4 Mapping subtable: format, length, language
-			$segCount*2,
-			$searchRange,
-			$entrySelector,
-			$rangeShift);
-
-		// endCode(s)
-		foreach($range AS $start=>$subrange) {
-			$endCode = $start + (count($subrange)-1);
-			$cmap[] = $endCode;	// endCode(s)
-		}
-		$cmap[] =	0xFFFF;	// endCode of last Segment
-		$cmap[] =	0;	// reservedPad
-
-		// startCode(s)
-		foreach($range AS $start=>$subrange) {
-			$cmap[] = $start;	// startCode(s)
-		}
-		$cmap[] =	0xFFFF;	// startCode of last Segment
-		// idDelta(s) 
-		foreach($range AS $start=>$subrange) {
-			$idDelta = -($start-$subrange[0]);
-			$n += count($subrange);
-			$cmap[] = $idDelta;	// idDelta(s)
-		}
-		$cmap[] =	1;	// idDelta of last Segment
-		// idRangeOffset(s) 
-		foreach($range AS $subrange) {
-			$cmap[] = 0;	// idRangeOffset[segCount]  	Offset in bytes to glyph indexArray, or 0
-
-		}
-		$cmap[] =	0;	// idRangeOffset of last Segment
-		foreach($range AS $subrange) {
-			foreach($subrange AS $glidx) {
-				$cmap[] = $glidx;
-			}
-		}
-		$cmap[] = 0;	// Mapping for last character
-		$cmapstr = '';
-		foreach($cmap AS $cm) { $cmapstr .= pack("n",$cm); }
-		$this->add('cmap', $cmapstr);
-
-
-		// glyf - Glyph data
-		list($glyfOffset,$glyfLength) = $this->get_table_pos('glyf');
-		if ($glyfLength < $this->maxStrLenRead) {
-			$glyphData = $this->get_table('glyf');
-		}
-
-		$offsets = array();
-		$glyf = '';
-		$pos = 0;
-
-		$hmtxstr = '';
-		$xMinT = 0;
-		$yMinT = 0;
-		$xMaxT = 0;
-		$yMaxT = 0;
-		$advanceWidthMax = 0;
-		$minLeftSideBearing = 0;
-		$minRightSideBearing = 0;
-		$xMaxExtent = 0;
-		$maxPoints = 0;			// points in non-compound glyph
-		$maxContours = 0;			// contours in non-compound glyph
-		$maxComponentPoints = 0;	// points in compound glyph
-		$maxComponentContours = 0;	// contours in compound glyph
-		$maxComponentElements = 0;	// number of glyphs referenced at top level
-		$maxComponentDepth = 0;		// levels of recursion, set to 0 if font has only simple glyphs
-		$this->glyphdata = array();
-
-		foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
-			// hmtx - Horizontal Metrics
-			$hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx);	
-			$hmtxstr .= $hm;
-
-			$offsets[] = $pos;
-			$glyphPos = $this->glyphPos[$originalGlyphIdx];
-			$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
-			if ($glyfLength < $this->maxStrLenRead) {
-				$data = substr($glyphData,$glyphPos,$glyphLen);
-			}
-			else {
-				if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset+$glyphPos,$glyphLen);
-				else $data = '';
-			}
-
-			if ($glyphLen > 0) {
-				$up = unpack("n", substr($data,0,2));
-			}
-
-			if ($glyphLen > 2 && ($up[1] & (1 << 15)) ) {	// If number of contours <= -1 i.e. composiste glyph
-				$pos_in_glyph = 10;
-				$flags = GF_MORE;
-				$nComponentElements = 0;
-				while ($flags & GF_MORE) {
-					$nComponentElements += 1;	// number of glyphs referenced at top level
-					$up = unpack("n", substr($data,$pos_in_glyph,2));
-					$flags = $up[1];
-					$up = unpack("n", substr($data,$pos_in_glyph+2,2));
-					$glyphIdx = $up[1];
-					$this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
-					$data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
-					$pos_in_glyph += 4;
-					if ($flags & GF_WORDS) { $pos_in_glyph += 4; }
-					else { $pos_in_glyph += 2; }
-					if ($flags & GF_SCALE) { $pos_in_glyph += 2; }
-					else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; }
-					else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; }
-				}
-				$maxComponentElements = max($maxComponentElements, $nComponentElements);
-			}
-
-			$glyf .= $data;
-			$pos += $glyphLen;
-			if ($pos % 4 != 0) {
-				$padding = 4 - ($pos % 4);
-				$glyf .= str_repeat("\0",$padding);
-				$pos += $padding;
-			}
-		}
-
-		$offsets[] = $pos;
-		$this->add('glyf', $glyf);
-
-		// hmtx - Horizontal Metrics
-		$this->add('hmtx', $hmtxstr);
-
-		// loca - Index to location
-		$locastr = '';
-		if ((($pos + 1) >> 1) > 0xFFFF) {
-			$indexToLocFormat = 1;        // long format
-			foreach($offsets AS $offset) { $locastr .= pack("N",$offset); }
-		}
-		else {
-			$indexToLocFormat = 0;        // short format
-			foreach($offsets AS $offset) { $locastr .= pack("n",($offset/2)); }
-		}
-		$this->add('loca', $locastr);
-
-		// head - Font header
-		$head = $this->get_table('head');
-		$head = $this->_set_ushort($head, 50, $indexToLocFormat);
-		$this->add('head', $head);
-
-
-		// hhea - Horizontal Header
-		$hhea = $this->get_table('hhea');
-		$hhea = $this->_set_ushort($hhea, 34, $numberOfHMetrics);
-		$this->add('hhea', $hhea);
-
-		// maxp - Maximum Profile
-		$maxp = $this->get_table('maxp');
-		$maxp = $this->_set_ushort($maxp, 4, $numGlyphs);
-		$this->add('maxp', $maxp);
-
-
-		// OS/2 - OS/2
-		$os2 = $this->get_table('OS/2');
-		$this->add('OS/2', $os2 );
-
-		fclose($this->fh);
-
-		// Put the TTF file together
-		$stm = '';
-		$this->endTTFile($stm);
-		return $stm ;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////////
-	// Recursively get composite glyph data
-	function getGlyphData($originalGlyphIdx, &$maxdepth, &$depth, &$points, &$contours) {
-		$depth++;
-		$maxdepth = max($maxdepth, $depth);
-		if (count($this->glyphdata[$originalGlyphIdx]['compGlyphs'])) {
-			foreach($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
-				$this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
-			}
-		}
-		else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) {	// simple
-			$contours += $this->glyphdata[$originalGlyphIdx]['nContours'];
-			$points += $this->glyphdata[$originalGlyphIdx]['nPoints'];
-		}
-		$depth--;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////////////
-	// Recursively get composite glyphs
-	function getGlyphs($originalGlyphIdx, &$start, &$glyphSet, &$subsetglyphs) {
-		$glyphPos = $this->glyphPos[$originalGlyphIdx];
-		$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
-		if (!$glyphLen) { 
-			return;
-		}
-		$this->seek($start + $glyphPos);
-		$numberOfContours = $this->read_short();
-		if ($numberOfContours < 0) {
-			$this->skip(8);
-			$flags = GF_MORE;
-			while ($flags & GF_MORE) {
-				$flags = $this->read_ushort();
-				$glyphIdx = $this->read_ushort();
-				if (!isset($glyphSet[$glyphIdx])) {
-					$glyphSet[$glyphIdx] = count($subsetglyphs);	// old glyphID to new glyphID
-					$subsetglyphs[$glyphIdx] = true;
-				}
-				$savepos = ftell($this->fh);
-				$this->getGlyphs($glyphIdx, $start, $glyphSet, $subsetglyphs);
-				$this->seek($savepos);
-				if ($flags & GF_WORDS)
-					$this->skip(4);
-				else
-					$this->skip(2);
-				if ($flags & GF_SCALE)
-					$this->skip(2);
-				else if ($flags & GF_XYSCALE)
-					$this->skip(4);
-				else if ($flags & GF_TWOBYTWO)
-					$this->skip(8);
-			}
-		}
-	}
-
-	//////////////////////////////////////////////////////////////////////////////////
-
-	function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) {
-		$start = $this->seek_table("hmtx");
-		$aw = 0;
-		$this->charWidths = str_pad('', 256*256*2, "\x00");
-		$nCharWidths = 0;
-		if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
-			$data = $this->get_chunk($start,($numberOfHMetrics*4));
-			$arr = unpack("n*", $data);
-		}
-		else { $this->seek($start); }
-		for( $glyph=0; $glyph<$numberOfHMetrics; $glyph++) {
-
-			if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
-				$aw = $arr[($glyph*2)+1];
-			}
-			else {
-				$aw = $this->read_ushort();
-				$lsb = $this->read_ushort();
-			}
-			if (isset($glyphToChar[$glyph]) || $glyph == 0) {
-
-				if ($aw >= (1 << 15) ) { $aw = 0; }	// 1.03 Some (arabic) fonts have -ve values for width
-					// although should be unsigned value - comes out as e.g. 65108 (intended -50)
-				if ($glyph == 0) {
-					$this->defaultWidth = $scale*$aw;
-					continue;
-				}
-				foreach($glyphToChar[$glyph] AS $char) {
-					if ($char != 0 && $char != 65535) {
- 						$w = intval(round($scale*$aw));
-						if ($w == 0) { $w = 65535; }
-						if ($char < 196608) {
-							$this->charWidths[$char*2] = chr($w >> 8);
-							$this->charWidths[$char*2 + 1] = chr($w & 0xFF);
-							$nCharWidths++;
-						}
-					}
-				}
-			}
-		}
-		$data = $this->get_chunk(($start+$numberOfHMetrics*4),($numGlyphs*2));
-		$arr = unpack("n*", $data);
-		$diff = $numGlyphs-$numberOfHMetrics;
-		for( $pos=0; $pos<$diff; $pos++) {
-			$glyph = $pos + $numberOfHMetrics;
-			if (isset($glyphToChar[$glyph])) {
-				foreach($glyphToChar[$glyph] AS $char) {
-					if ($char != 0 && $char != 65535) {
-						$w = intval(round($scale*$aw));
-						if ($w == 0) { $w = 65535; }
-						if ($char < 196608) {
-							$this->charWidths[$char*2] = chr($w >> 8);
-							$this->charWidths[$char*2 + 1] = chr($w & 0xFF);
-							$nCharWidths++;
-						}
-					}
-				}
-			}
-		}
-		// NB 65535 is a set width of 0
-		// First bytes define number of chars in font
-		$this->charWidths[0] = chr($nCharWidths >> 8);
-		$this->charWidths[1] = chr($nCharWidths & 0xFF);
-	}
-
-	function getHMetric($numberOfHMetrics, $gid) {
-		$start = $this->seek_table("hmtx");
-		if ($gid < $numberOfHMetrics) {
-			$this->seek($start+($gid*4));
-			$hm = fread($this->fh,4);
-		}
-		else {
-			$this->seek($start+(($numberOfHMetrics-1)*4));
-			$hm = fread($this->fh,2);
-			$this->seek($start+($numberOfHMetrics*2)+($gid*2));
-			$hm .= fread($this->fh,2);
-		}
-		return $hm;
-	}
-
-	function getLOCA($indexToLocFormat, $numGlyphs) {
-		$start = $this->seek_table('loca');
-		$this->glyphPos = array();
-		if ($indexToLocFormat == 0) {
-			$data = $this->get_chunk($start,($numGlyphs*2)+2);
-			$arr = unpack("n*", $data);
-			for ($n=0; $n<=$numGlyphs; $n++) {
-				$this->glyphPos[] = ($arr[$n+1] * 2);
-			}
-		}
-		else if ($indexToLocFormat == 1) {
-			$data = $this->get_chunk($start,($numGlyphs*4)+4);
-			$arr = unpack("N*", $data);
-			for ($n=0; $n<=$numGlyphs; $n++) {
-				$this->glyphPos[] = ($arr[$n+1]);
-			}
-		}
-		else 
-			die('Unknown location table format '.$indexToLocFormat);
-	}
-
-
-	// CMAP Format 4
-	function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph ) {
-		$this->maxUniChar = 0;
-		$this->seek($unicode_cmap_offset + 2);
-		$length = $this->read_ushort();
-		$limit = $unicode_cmap_offset + $length;
-		$this->skip(2);
-
-		$segCount = $this->read_ushort() / 2;
-		$this->skip(6);
-		$endCount = array();
-		for($i=0; $i<$segCount; $i++) { $endCount[] = $this->read_ushort(); }
-		$this->skip(2);
-		$startCount = array();
-		for($i=0; $i<$segCount; $i++) { $startCount[] = $this->read_ushort(); }
-		$idDelta = array();
-		for($i=0; $i<$segCount; $i++) { $idDelta[] = $this->read_short(); }		// ???? was unsigned short
-		$idRangeOffset_start = $this->_pos;
-		$idRangeOffset = array();
-		for($i=0; $i<$segCount; $i++) { $idRangeOffset[] = $this->read_ushort(); }
-
-		for ($n=0;$n<$segCount;$n++) {
-			$endpoint = ($endCount[$n] + 1);
-			for ($unichar=$startCount[$n];$unichar<$endpoint;$unichar++) {
-				if ($idRangeOffset[$n] == 0)
-					$glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
-				else {
-					$offset = ($unichar - $startCount[$n]) * 2 + $idRangeOffset[$n];
-					$offset = $idRangeOffset_start + 2 * $n + $offset;
-					if ($offset >= $limit)
-						$glyph = 0;
-					else {
-						$glyph = $this->get_ushort($offset);
-						if ($glyph != 0)
-						   $glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
-					}
-				}
-				$charToGlyph[$unichar] = $glyph;
-				if ($unichar < 196608) { $this->maxUniChar = max($unichar,$this->maxUniChar); }
-				$glyphToChar[$glyph][] = $unichar;
-			}
-		}
-	}
-
-
-		// Put the TTF file together
-	function endTTFile(&$stm) {
-		$stm = '';
-		$numTables = count($this->otables);
-		$searchRange = 1;
-		$entrySelector = 0;
-		while ($searchRange * 2 <= $numTables) {
-			$searchRange = $searchRange * 2;
-			$entrySelector = $entrySelector + 1;
-		}
-		$searchRange = $searchRange * 16;
-		$rangeShift = $numTables * 16 - $searchRange;
-
-		// Header
-		if (_TTF_MAC_HEADER) {
-			$stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift));	// Mac
-		}
-		else {
-			$stm .= (pack("Nnnnn", 0x00010000 , $numTables, $searchRange, $entrySelector, $rangeShift));	// Windows
-		}
-
-		// Table directory
-		$tables = $this->otables;
-
-		ksort ($tables); 
-		$offset = 12 + $numTables * 16;
-		foreach ($tables AS $tag=>$data) {
-			if ($tag == 'head') { $head_start = $offset; }
-			$stm .= $tag;
-			$checksum = $this->calcChecksum($data);
-			$stm .= pack("nn", $checksum[0],$checksum[1]);
-			$stm .= pack("NN", $offset, strlen($data));
-			$paddedLength = (strlen($data)+3)&~3;
-			$offset = $offset + $paddedLength;
-		}
-
-		// Table data
-		foreach ($tables AS $tag=>$data) {
-			$data .= "\0\0\0";
-			$stm .= substr($data,0,(strlen($data)&~3));
-		}
-
-		$checksum = $this->calcChecksum($stm);
-		$checksum = $this->sub32(array(0xB1B0,0xAFBA), $checksum);
-		$chk = pack("nn", $checksum[0],$checksum[1]);
-		$stm = $this->splice($stm,($head_start + 8),$chk);
-		return $stm ;
-	}
+    function makeSubset($file, &$subset) {
+        $this->filename = $file;
+        $this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file);
+        $this->_pos = 0;
+        $this->charWidths = '';
+        $this->glyphPos = array();
+        $this->charToGlyph = array();
+        $this->tables = array();
+        $this->otables = array();
+        $this->ascent = 0;
+        $this->descent = 0;
+        $this->skip(4);
+        $this->maxUni = 0;
+        $this->readTableDirectory();
+
+
+        ///////////////////////////////////
+        // head - Font header table
+        ///////////////////////////////////
+        $this->seek_table("head");
+        $this->skip(50); 
+        $indexToLocFormat = $this->read_ushort();
+        $glyphDataFormat = $this->read_ushort();
+
+        ///////////////////////////////////
+        // hhea - Horizontal header table
+        ///////////////////////////////////
+        $this->seek_table("hhea");
+        $this->skip(32); 
+        $metricDataFormat = $this->read_ushort();
+        $orignHmetrics = $numberOfHMetrics = $this->read_ushort();
+
+        ///////////////////////////////////
+        // maxp - Maximum profile table
+        ///////////////////////////////////
+        $this->seek_table("maxp");
+        $this->skip(4);
+        $numGlyphs = $this->read_ushort();
+
+
+        ///////////////////////////////////
+        // cmap - Character to glyph index mapping table
+        ///////////////////////////////////
+        $cmap_offset = $this->seek_table("cmap");
+        $this->skip(2);
+        $cmapTableCount = $this->read_ushort();
+        $unicode_cmap_offset = 0;
+        for ($i=0;$i<$cmapTableCount;$i++) {
+            $platformID = $this->read_ushort();
+            $encodingID = $this->read_ushort();
+            $offset = $this->read_ulong();
+            $save_pos = $this->_pos;
+            if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
+                $format = $this->get_ushort($cmap_offset + $offset);
+                if ($format == 4) {
+                    $unicode_cmap_offset = $cmap_offset + $offset;
+                    break;
+                }
+            }
+            $this->seek($save_pos );
+        }
+
+        if (!$unicode_cmap_offset)
+            die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+
+
+        $glyphToChar = array();
+        $charToGlyph = array();
+        $this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph );
+
+        $this->charToGlyph = $charToGlyph;
+
+        ///////////////////////////////////
+        // hmtx - Horizontal metrics table
+        ///////////////////////////////////
+        $scale = 1;	// not used
+        $this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
+
+        ///////////////////////////////////
+        // loca - Index to location
+        ///////////////////////////////////
+        $this->getLOCA($indexToLocFormat, $numGlyphs);
+
+        $subsetglyphs = array(0=>0); 
+        $subsetCharToGlyph = array();
+        foreach($subset AS $code) {
+            if (isset($this->charToGlyph[$code])) {
+                $subsetglyphs[$this->charToGlyph[$code]] = $code;	// Old Glyph ID => Unicode
+                $subsetCharToGlyph[$code] = $this->charToGlyph[$code];	// Unicode to old GlyphID
+
+            }
+            $this->maxUni = max($this->maxUni, $code);
+        }
+
+        list($start,$dummy) = $this->get_table_pos('glyf');
+
+        $glyphSet = array();
+        ksort($subsetglyphs);
+        $n = 0;
+        $fsLastCharIndex = 0;	// maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
+        foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
+            $fsLastCharIndex = max($fsLastCharIndex , $uni);
+            $glyphSet[$originalGlyphIdx] = $n;	// old glyphID to new glyphID
+            $n++;
+        }
+
+        ksort($subsetCharToGlyph);
+        foreach($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
+            $codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx] ;
+        }
+        $this->codeToGlyph = $codeToGlyph;
+
+        ksort($subsetglyphs);
+        foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
+            $this->getGlyphs($originalGlyphIdx, $start, $glyphSet, $subsetglyphs);
+        }
+
+        $numGlyphs = $numberOfHMetrics = count($subsetglyphs );
+
+        //tables copied from the original
+        $tags = array ('name');
+        foreach($tags AS $tag) { $this->add($tag, $this->get_table($tag)); }
+        $tags = array ('cvt ', 'fpgm', 'prep', 'gasp');
+        foreach($tags AS $tag) {
+            if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); }
+        }
+
+        // post - PostScript
+        $opost = $this->get_table('post');
+        $post = "\x00\x03\x00\x00" . substr($opost,4,12) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+        $this->add('post', $post);
+
+        // Sort CID2GID map into segments of contiguous codes
+        ksort($codeToGlyph);
+        unset($codeToGlyph[0]);
+        //unset($codeToGlyph[65535]);
+        $rangeid = 0;
+        $range = array();
+        $prevcid = -2;
+        $prevglidx = -1;
+        // for each character
+        foreach ($codeToGlyph as $cid => $glidx) {
+            if ($cid == ($prevcid + 1) && $glidx == ($prevglidx + 1)) {
+                $range[$rangeid][] = $glidx;
+            } else {
+                // new range
+                $rangeid = $cid;
+                $range[$rangeid] = array();
+                $range[$rangeid][] = $glidx;
+            }
+            $prevcid = $cid;
+            $prevglidx = $glidx;
+        }
+
+        // cmap - Character to glyph mapping - Format 4 (MS / )
+        $segCount = count($range) + 1;	// + 1 Last segment has missing character 0xFFFF
+        $searchRange = 1;
+        $entrySelector = 0;
+        while ($searchRange * 2 <= $segCount ) {
+            $searchRange = $searchRange * 2;
+            $entrySelector = $entrySelector + 1;
+        }
+        $searchRange = $searchRange * 2;
+        $rangeShift = $segCount * 2 - $searchRange;
+        $length = 16 + (8*$segCount ) + ($numGlyphs+1);
+        $cmap = array(0, 1,		// Index : version, number of encoding subtables
+            3, 1,				// Encoding Subtable : platform (MS=3), encoding (Unicode)
+            0, 12,			// Encoding Subtable : offset (hi,lo)
+            4, $length, 0, 		// Format 4 Mapping subtable: format, length, language
+            $segCount*2,
+            $searchRange,
+            $entrySelector,
+            $rangeShift);
+
+        // endCode(s)
+        foreach($range AS $start=>$subrange) {
+            $endCode = $start + (count($subrange)-1);
+            $cmap[] = $endCode;	// endCode(s)
+        }
+        $cmap[] =	0xFFFF;	// endCode of last Segment
+        $cmap[] =	0;	// reservedPad
+
+        // startCode(s)
+        foreach($range AS $start=>$subrange) {
+            $cmap[] = $start;	// startCode(s)
+        }
+        $cmap[] =	0xFFFF;	// startCode of last Segment
+        // idDelta(s) 
+        foreach($range AS $start=>$subrange) {
+            $idDelta = -($start-$subrange[0]);
+            $n += count($subrange);
+            $cmap[] = $idDelta;	// idDelta(s)
+        }
+        $cmap[] =	1;	// idDelta of last Segment
+        // idRangeOffset(s) 
+        foreach($range AS $subrange) {
+            $cmap[] = 0;	// idRangeOffset[segCount]  	Offset in bytes to glyph indexArray, or 0
+
+        }
+        $cmap[] =	0;	// idRangeOffset of last Segment
+        foreach($range AS $subrange) {
+            foreach($subrange AS $glidx) {
+                $cmap[] = $glidx;
+            }
+        }
+        $cmap[] = 0;	// Mapping for last character
+        $cmapstr = '';
+        foreach($cmap AS $cm) { $cmapstr .= pack("n",$cm); }
+        $this->add('cmap', $cmapstr);
+
+
+        // glyf - Glyph data
+        list($glyfOffset,$glyfLength) = $this->get_table_pos('glyf');
+        if ($glyfLength < $this->maxStrLenRead) {
+            $glyphData = $this->get_table('glyf');
+        }
+
+        $offsets = array();
+        $glyf = '';
+        $pos = 0;
+
+        $hmtxstr = '';
+        $xMinT = 0;
+        $yMinT = 0;
+        $xMaxT = 0;
+        $yMaxT = 0;
+        $advanceWidthMax = 0;
+        $minLeftSideBearing = 0;
+        $minRightSideBearing = 0;
+        $xMaxExtent = 0;
+        $maxPoints = 0;			// points in non-compound glyph
+        $maxContours = 0;			// contours in non-compound glyph
+        $maxComponentPoints = 0;	// points in compound glyph
+        $maxComponentContours = 0;	// contours in compound glyph
+        $maxComponentElements = 0;	// number of glyphs referenced at top level
+        $maxComponentDepth = 0;		// levels of recursion, set to 0 if font has only simple glyphs
+        $this->glyphdata = array();
+
+        foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
+            // hmtx - Horizontal Metrics
+            $hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx);	
+            $hmtxstr .= $hm;
+
+            $offsets[] = $pos;
+            $glyphPos = $this->glyphPos[$originalGlyphIdx];
+            $glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
+            if ($glyfLength < $this->maxStrLenRead) {
+                $data = substr($glyphData,$glyphPos,$glyphLen);
+            }
+            else {
+                if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset+$glyphPos,$glyphLen);
+                else $data = '';
+            }
+
+            if ($glyphLen > 0) {
+                $up = unpack("n", substr($data,0,2));
+            }
+
+            if ($glyphLen > 2 && ($up[1] & (1 << 15)) ) {	// If number of contours <= -1 i.e. composiste glyph
+                $pos_in_glyph = 10;
+                $flags = GF_MORE;
+                $nComponentElements = 0;
+                while ($flags & GF_MORE) {
+                    $nComponentElements += 1;	// number of glyphs referenced at top level
+                    $up = unpack("n", substr($data,$pos_in_glyph,2));
+                    $flags = $up[1];
+                    $up = unpack("n", substr($data,$pos_in_glyph+2,2));
+                    $glyphIdx = $up[1];
+                    $this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
+                    $data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
+                    $pos_in_glyph += 4;
+                    if ($flags & GF_WORDS) { $pos_in_glyph += 4; }
+                    else { $pos_in_glyph += 2; }
+                    if ($flags & GF_SCALE) { $pos_in_glyph += 2; }
+                    else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; }
+                    else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; }
+                }
+                $maxComponentElements = max($maxComponentElements, $nComponentElements);
+            }
+
+            $glyf .= $data;
+            $pos += $glyphLen;
+            if ($pos % 4 != 0) {
+                $padding = 4 - ($pos % 4);
+                $glyf .= str_repeat("\0",$padding);
+                $pos += $padding;
+            }
+        }
+
+        $offsets[] = $pos;
+        $this->add('glyf', $glyf);
+
+        // hmtx - Horizontal Metrics
+        $this->add('hmtx', $hmtxstr);
+
+        // loca - Index to location
+        $locastr = '';
+        if ((($pos + 1) >> 1) > 0xFFFF) {
+            $indexToLocFormat = 1;        // long format
+            foreach($offsets AS $offset) { $locastr .= pack("N",$offset); }
+        }
+        else {
+            $indexToLocFormat = 0;        // short format
+            foreach($offsets AS $offset) { $locastr .= pack("n",($offset/2)); }
+        }
+        $this->add('loca', $locastr);
+
+        // head - Font header
+        $head = $this->get_table('head');
+        $head = $this->_set_ushort($head, 50, $indexToLocFormat);
+        $this->add('head', $head);
+
+
+        // hhea - Horizontal Header
+        $hhea = $this->get_table('hhea');
+        $hhea = $this->_set_ushort($hhea, 34, $numberOfHMetrics);
+        $this->add('hhea', $hhea);
+
+        // maxp - Maximum Profile
+        $maxp = $this->get_table('maxp');
+        $maxp = $this->_set_ushort($maxp, 4, $numGlyphs);
+        $this->add('maxp', $maxp);
+
+
+        // OS/2 - OS/2
+        $os2 = $this->get_table('OS/2');
+        $this->add('OS/2', $os2 );
+
+        fclose($this->fh);
+
+        // Put the TTF file together
+        $stm = '';
+        $this->endTTFile($stm);
+        return $stm ;
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Recursively get composite glyph data
+    function getGlyphData($originalGlyphIdx, &$maxdepth, &$depth, &$points, &$contours) {
+        $depth++;
+        $maxdepth = max($maxdepth, $depth);
+        if (count($this->glyphdata[$originalGlyphIdx]['compGlyphs'])) {
+            foreach($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
+                $this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
+            }
+        }
+        else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) {	// simple
+            $contours += $this->glyphdata[$originalGlyphIdx]['nContours'];
+            $points += $this->glyphdata[$originalGlyphIdx]['nPoints'];
+        }
+        $depth--;
+    }
+
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Recursively get composite glyphs
+    function getGlyphs($originalGlyphIdx, &$start, &$glyphSet, &$subsetglyphs) {
+        $glyphPos = $this->glyphPos[$originalGlyphIdx];
+        $glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
+        if (!$glyphLen) { 
+            return;
+        }
+        $this->seek($start + $glyphPos);
+        $numberOfContours = $this->read_short();
+        if ($numberOfContours < 0) {
+            $this->skip(8);
+            $flags = GF_MORE;
+            while ($flags & GF_MORE) {
+                $flags = $this->read_ushort();
+                $glyphIdx = $this->read_ushort();
+                if (!isset($glyphSet[$glyphIdx])) {
+                    $glyphSet[$glyphIdx] = count($subsetglyphs);	// old glyphID to new glyphID
+                    $subsetglyphs[$glyphIdx] = true;
+                }
+                $savepos = ftell($this->fh);
+                $this->getGlyphs($glyphIdx, $start, $glyphSet, $subsetglyphs);
+                $this->seek($savepos);
+                if ($flags & GF_WORDS)
+                    $this->skip(4);
+                else
+                    $this->skip(2);
+                if ($flags & GF_SCALE)
+                    $this->skip(2);
+                else if ($flags & GF_XYSCALE)
+                    $this->skip(4);
+                else if ($flags & GF_TWOBYTWO)
+                    $this->skip(8);
+            }
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+
+    function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) {
+        $start = $this->seek_table("hmtx");
+        $aw = 0;
+        $this->charWidths = str_pad('', 256*256*2, "\x00");
+        $nCharWidths = 0;
+        if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
+            $data = $this->get_chunk($start,($numberOfHMetrics*4));
+            $arr = unpack("n*", $data);
+        }
+        else { $this->seek($start); }
+        for( $glyph=0; $glyph<$numberOfHMetrics; $glyph++) {
+
+            if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
+                $aw = $arr[($glyph*2)+1];
+            }
+            else {
+                $aw = $this->read_ushort();
+                $lsb = $this->read_ushort();
+            }
+            if (isset($glyphToChar[$glyph]) || $glyph == 0) {
+
+                if ($aw >= (1 << 15) ) { $aw = 0; }	// 1.03 Some (arabic) fonts have -ve values for width
+                    // although should be unsigned value - comes out as e.g. 65108 (intended -50)
+                if ($glyph == 0) {
+                    $this->defaultWidth = $scale*$aw;
+                    continue;
+                }
+                foreach($glyphToChar[$glyph] AS $char) {
+                    if ($char != 0 && $char != 65535) {
+                            $w = intval(round($scale*$aw));
+                        if ($w == 0) { $w = 65535; }
+                        if ($char < 196608) {
+                            $this->charWidths[$char*2] = chr($w >> 8);
+                            $this->charWidths[$char*2 + 1] = chr($w & 0xFF);
+                            $nCharWidths++;
+                        }
+                    }
+                }
+            }
+        }
+        $data = $this->get_chunk(($start+$numberOfHMetrics*4),($numGlyphs*2));
+        $arr = unpack("n*", $data);
+        $diff = $numGlyphs-$numberOfHMetrics;
+        for( $pos=0; $pos<$diff; $pos++) {
+            $glyph = $pos + $numberOfHMetrics;
+            if (isset($glyphToChar[$glyph])) {
+                foreach($glyphToChar[$glyph] AS $char) {
+                    if ($char != 0 && $char != 65535) {
+                        $w = intval(round($scale*$aw));
+                        if ($w == 0) { $w = 65535; }
+                        if ($char < 196608) {
+                            $this->charWidths[$char*2] = chr($w >> 8);
+                            $this->charWidths[$char*2 + 1] = chr($w & 0xFF);
+                            $nCharWidths++;
+                        }
+                    }
+                }
+            }
+        }
+        // NB 65535 is a set width of 0
+        // First bytes define number of chars in font
+        $this->charWidths[0] = chr($nCharWidths >> 8);
+        $this->charWidths[1] = chr($nCharWidths & 0xFF);
+    }
+
+    function getHMetric($numberOfHMetrics, $gid) {
+        $start = $this->seek_table("hmtx");
+        if ($gid < $numberOfHMetrics) {
+            $this->seek($start+($gid*4));
+            $hm = fread($this->fh,4);
+        }
+        else {
+            $this->seek($start+(($numberOfHMetrics-1)*4));
+            $hm = fread($this->fh,2);
+            $this->seek($start+($numberOfHMetrics*2)+($gid*2));
+            $hm .= fread($this->fh,2);
+        }
+        return $hm;
+    }
+
+    function getLOCA($indexToLocFormat, $numGlyphs) {
+        $start = $this->seek_table('loca');
+        $this->glyphPos = array();
+        if ($indexToLocFormat == 0) {
+            $data = $this->get_chunk($start,($numGlyphs*2)+2);
+            $arr = unpack("n*", $data);
+            for ($n=0; $n<=$numGlyphs; $n++) {
+                $this->glyphPos[] = ($arr[$n+1] * 2);
+            }
+        }
+        else if ($indexToLocFormat == 1) {
+            $data = $this->get_chunk($start,($numGlyphs*4)+4);
+            $arr = unpack("N*", $data);
+            for ($n=0; $n<=$numGlyphs; $n++) {
+                $this->glyphPos[] = ($arr[$n+1]);
+            }
+        }
+        else 
+            die('Unknown location table format '.$indexToLocFormat);
+    }
+
+
+    // CMAP Format 4
+    function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph ) {
+        $this->maxUniChar = 0;
+        $this->seek($unicode_cmap_offset + 2);
+        $length = $this->read_ushort();
+        $limit = $unicode_cmap_offset + $length;
+        $this->skip(2);
+
+        $segCount = $this->read_ushort() / 2;
+        $this->skip(6);
+        $endCount = array();
+        for($i=0; $i<$segCount; $i++) { $endCount[] = $this->read_ushort(); }
+        $this->skip(2);
+        $startCount = array();
+        for($i=0; $i<$segCount; $i++) { $startCount[] = $this->read_ushort(); }
+        $idDelta = array();
+        for($i=0; $i<$segCount; $i++) { $idDelta[] = $this->read_short(); }		// ???? was unsigned short
+        $idRangeOffset_start = $this->_pos;
+        $idRangeOffset = array();
+        for($i=0; $i<$segCount; $i++) { $idRangeOffset[] = $this->read_ushort(); }
+
+        for ($n=0;$n<$segCount;$n++) {
+            $endpoint = ($endCount[$n] + 1);
+            for ($unichar=$startCount[$n];$unichar<$endpoint;$unichar++) {
+                if ($idRangeOffset[$n] == 0)
+                    $glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
+                else {
+                    $offset = ($unichar - $startCount[$n]) * 2 + $idRangeOffset[$n];
+                    $offset = $idRangeOffset_start + 2 * $n + $offset;
+                    if ($offset >= $limit)
+                        $glyph = 0;
+                    else {
+                        $glyph = $this->get_ushort($offset);
+                        if ($glyph != 0)
+                            $glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
+                    }
+                }
+                $charToGlyph[$unichar] = $glyph;
+                if ($unichar < 196608) { $this->maxUniChar = max($unichar,$this->maxUniChar); }
+                $glyphToChar[$glyph][] = $unichar;
+            }
+        }
+    }
+
+
+        // Put the TTF file together
+    function endTTFile(&$stm) {
+        $stm = '';
+        $numTables = count($this->otables);
+        $searchRange = 1;
+        $entrySelector = 0;
+        while ($searchRange * 2 <= $numTables) {
+            $searchRange = $searchRange * 2;
+            $entrySelector = $entrySelector + 1;
+        }
+        $searchRange = $searchRange * 16;
+        $rangeShift = $numTables * 16 - $searchRange;
+
+        // Header
+        if (_TTF_MAC_HEADER) {
+            $stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift));	// Mac
+        }
+        else {
+            $stm .= (pack("Nnnnn", 0x00010000 , $numTables, $searchRange, $entrySelector, $rangeShift));	// Windows
+        }
+
+        // Table directory
+        $tables = $this->otables;
+
+        ksort ($tables); 
+        $offset = 12 + $numTables * 16;
+        foreach ($tables AS $tag=>$data) {
+            if ($tag == 'head') { $head_start = $offset; }
+            $stm .= $tag;
+            $checksum = $this->calcChecksum($data);
+            $stm .= pack("nn", $checksum[0],$checksum[1]);
+            $stm .= pack("NN", $offset, strlen($data));
+            $paddedLength = (strlen($data)+3)&~3;
+            $offset = $offset + $paddedLength;
+        }
+
+        // Table data
+        foreach ($tables AS $tag=>$data) {
+            $data .= "\0\0\0";
+            $stm .= substr($data,0,(strlen($data)&~3));
+        }
+
+        $checksum = $this->calcChecksum($stm);
+        $checksum = $this->sub32(array(0xB1B0,0xAFBA), $checksum);
+        $chk = pack("nn", $checksum[0],$checksum[1]);
+        $stm = $this->splice($stm,($head_start + 8),$chk);
+        return $stm ;
+    }
 
 
 

Spacing +197 added lines, -197 removed lines

@@ -27,11 +27,11 @@ 
 
 
 // TrueType Font Glyph operators
-define("GF_WORDS",(1 << 0));
-define("GF_SCALE",(1 << 3));
-define("GF_MORE",(1 << 5));
-define("GF_XYSCALE",(1 << 6));
-define("GF_TWOBYTWO",(1 << 7));
+define("GF_WORDS", (1 << 0));
+define("GF_SCALE", (1 << 3));
+define("GF_MORE", (1 << 5));
+define("GF_XYSCALE", (1 << 6));
+define("GF_TWOBYTWO", (1 << 7));
 
 
 
@@ -70,13 +70,13 @@ 
 var $maxStrLenRead;
 
 	function __construct() {
-		$this->maxStrLenRead = 200000;	// Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
+		$this->maxStrLenRead = 200000; // Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
 	}
 
 
 	function getMetrics($file) {
 		$this->filename = $file;
-		$this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file);
+		$this->fh = fopen($file, 'rb') or die('Can\'t open file '.$file);
 		$this->_pos = 0;
 		$this->charWidths = '';
 		$this->glyphPos = array();
@@ -87,11 +87,11 @@ 
 		$this->descent = 0;
 		$this->TTCFonts = array();
 		$this->version = $version = $this->read_ulong();
-		if ($version==0x4F54544F) 
+		if ($version == 0x4F54544F) 
 			die("Postscript outlines are not supported");
-		if ($version==0x74746366) 
+		if ($version == 0x74746366) 
 			die("ERROR - TrueType Fonts Collections not supported");
-		if (!in_array($version, array(0x00010000,0x74727565)))
+		if (!in_array($version, array(0x00010000, 0x74727565)))
 			die("Not a TrueType font: version=".$version);
 		$this->readTableDirectory();
 		$this->extractInfo();
@@ -105,10 +105,10 @@ 
             $this->entrySelector = $this->read_ushort();
             $this->rangeShift = $this->read_ushort();
             $this->tables = array();	
-            for ($i=0;$i<$this->numTables;$i++) {
+            for ($i = 0; $i < $this->numTables; $i++) {
                 $record = array();
                 $record['tag'] = $this->read_tag();
-                $record['checksum'] = array($this->read_ushort(),$this->read_ushort());
+                $record['checksum'] = array($this->read_ushort(), $this->read_ushort());
                 $record['offset'] = $this->read_ulong();
                 $record['length'] = $this->read_ulong();
                 $this->tables[$record['tag']] = $record;
@@ -122,20 +122,20 @@ 
 		$ylo = $y[1];
 		$yhi = $y[0];
 		if ($ylo > $xlo) { $xlo += 1 << 16; $yhi += 1; }
-		$reslo = $xlo-$ylo;
-		if ($yhi > $xhi) { $xhi += 1 << 16;  }
-		$reshi = $xhi-$yhi;
+		$reslo = $xlo - $ylo;
+		if ($yhi > $xhi) { $xhi += 1 << 16; }
+		$reshi = $xhi - $yhi;
 		$reshi = $reshi & 0xFFFF;
 		return array($reshi, $reslo);
 	}
 
-	function calcChecksum($data)  {
-		if (strlen($data) % 4) { $data .= str_repeat("\0",(4-(strlen($data) % 4))); }
-		$hi=0x0000;
-		$lo=0x0000;
-		for($i=0;$i<strlen($data);$i+=4) {
-			$hi += (ord($data[$i])<<8) + ord($data[$i+1]);
-			$lo += (ord($data[$i+2])<<8) + ord($data[$i+3]);
+	function calcChecksum($data) {
+		if (strlen($data) % 4) { $data .= str_repeat("\0", (4 - (strlen($data) % 4))); }
+		$hi = 0x0000;
+		$lo = 0x0000;
+		for ($i = 0; $i < strlen($data); $i += 4) {
+			$hi += (ord($data[$i]) << 8) + ord($data[$i + 1]);
+			$lo += (ord($data[$i + 2]) << 8) + ord($data[$i + 3]);
 			$hi += $lo >> 16;
 			$lo = $lo & 0xFFFF;
 			$hi = $hi & 0xFFFF;
@@ -151,12 +151,12 @@ 
 
 	function seek($pos) {
 		$this->_pos = $pos;
-		fseek($this->fh,$this->_pos);
+		fseek($this->fh, $this->_pos);
 	}
 
 	function skip($delta) {
 		$this->_pos = $this->_pos + $delta;
-		fseek($this->fh,$this->_pos);
+		fseek($this->fh, $this->_pos);
 	}
 
 	function seek_table($tag, $offset_in_table = 0) {
@@ -168,20 +168,20 @@ 
 
 	function read_tag() {
 		$this->_pos += 4;
-		return fread($this->fh,4);
+		return fread($this->fh, 4);
 	}
 
 	function read_short() {
 		$this->_pos += 2;
-		$s = fread($this->fh,2);
-		$a = (ord($s[0])<<8) + ord($s[1]);
-		if ($a & (1 << 15) ) { $a = ($a - (1 << 16)) ; }
+		$s = fread($this->fh, 2);
+		$a = (ord($s[0]) << 8) + ord($s[1]);
+		if ($a & (1 << 15)) { $a = ($a - (1 << 16)); }
 		return $a;
 	}
 
 	function unpack_short($s) {
-		$a = (ord($s[0])<<8) + ord($s[1]);
-		if ($a & (1 << 15) ) { 
+		$a = (ord($s[0]) << 8) + ord($s[1]);
+		if ($a & (1 << 15)) { 
 			$a = ($a - (1 << 16)); 
 		}
 		return $a;
@@ -189,41 +189,41 @@ 
 
 	function read_ushort() {
 		$this->_pos += 2;
-		$s = fread($this->fh,2);
-		return (ord($s[0])<<8) + ord($s[1]);
+		$s = fread($this->fh, 2);
+		return (ord($s[0]) << 8) + ord($s[1]);
 	}
 
 	function read_ulong() {
 		$this->_pos += 4;
-		$s = fread($this->fh,4);
+		$s = fread($this->fh, 4);
 		// if large uInt32 as an integer, PHP converts it to -ve
-		return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
+		return (ord($s[0]) * 16777216) + (ord($s[1]) << 16) + (ord($s[2]) << 8) + ord($s[3]); // 	16777216  = 1<<24
 	}
 
 	function get_ushort($pos) {
-		fseek($this->fh,$pos);
-		$s = fread($this->fh,2);
-		return (ord($s[0])<<8) + ord($s[1]);
+		fseek($this->fh, $pos);
+		$s = fread($this->fh, 2);
+		return (ord($s[0]) << 8) + ord($s[1]);
 	}
 
 	function get_ulong($pos) {
-		fseek($this->fh,$pos);
-		$s = fread($this->fh,4);
+		fseek($this->fh, $pos);
+		$s = fread($this->fh, 4);
 		// iF large uInt32 as an integer, PHP converts it to -ve
-		return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
+		return (ord($s[0]) * 16777216) + (ord($s[1]) << 16) + (ord($s[2]) << 8) + ord($s[3]); // 	16777216  = 1<<24
 	}
 
 	function pack_short($val) {
-		if ($val<0) { 
+		if ($val < 0) { 
 			$val = abs($val);
 			$val = ~$val;
 			$val += 1;
 		}
-		return pack("n",$val); 
+		return pack("n", $val); 
 	}
 
 	function splice($stream, $offset, $value) {
-		return substr($stream,0,$offset) . $value . substr($stream,$offset+strlen($value));
+		return substr($stream, 0, $offset).$value.substr($stream, $offset + strlen($value));
 	}
 
 	function _set_ushort($stream, $offset, $value) {
@@ -232,26 +232,26 @@ 
 	}
 
 	function _set_short($stream, $offset, $val) {
-		if ($val<0) { 
+		if ($val < 0) { 
 			$val = abs($val);
 			$val = ~$val;
 			$val += 1;
 		}
-		$up = pack("n",$val); 
+		$up = pack("n", $val); 
 		return $this->splice($stream, $offset, $up);
 	}
 
 	function get_chunk($pos, $length) {
-		fseek($this->fh,$pos);
-		if ($length <1) { return ''; }
-		return (fread($this->fh,$length));
+		fseek($this->fh, $pos);
+		if ($length < 1) { return ''; }
+		return (fread($this->fh, $length));
 	}
 
 	function get_table($tag) {
 		list($pos, $length) = $this->get_table_pos($tag);
 		if ($length == 0) { die('Truetype font ('.$this->filename.'): error reading table: '.$tag); }
-		fseek($this->fh,$pos);
-		return (fread($this->fh,$length));
+		fseek($this->fh, $pos);
+		return (fread($this->fh, $length));
 	}
 
 	function add($tag, $data) {
@@ -281,17 +281,17 @@ 
 				die("Unknown name table format ".$format);
 			$numRecords = $this->read_ushort();
 			$string_data_offset = $name_offset + $this->read_ushort();
-			$names = array(1=>'',2=>'',3=>'',4=>'',6=>'');
+			$names = array(1=>'', 2=>'', 3=>'', 4=>'', 6=>'');
 			$K = array_keys($names);
 			$nameCount = count($names);
-			for ($i=0;$i<$numRecords; $i++) {
+			for ($i = 0; $i < $numRecords; $i++) {
 				$platformId = $this->read_ushort();
 				$encodingId = $this->read_ushort();
 				$languageId = $this->read_ushort();
 				$nameId = $this->read_ushort();
 				$length = $this->read_ushort();
 				$offset = $this->read_ushort();
-				if (!in_array($nameId,$K)) continue;
+				if (!in_array($nameId, $K)) continue;
 				$N = '';
 				if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name
 					$opos = $this->_pos;
@@ -314,18 +314,18 @@ 
 					$this->_pos = $opos;
 					$this->seek($opos);
 				}
-				if ($N && $names[$nameId]=='') {
+				if ($N && $names[$nameId] == '') {
 					$names[$nameId] = $N;
 					$nameCount -= 1;
-					if ($nameCount==0) break;
+					if ($nameCount == 0) break;
 				}
 			}
 			if ($names[6])
 				$psName = $names[6];
 			else if ($names[4])
-				$psName = preg_replace('/ /','-',$names[4]);
+				$psName = preg_replace('/ /', '-', $names[4]);
 			else if ($names[1])
-				$psName = preg_replace('/ /','-',$names[1]);
+				$psName = preg_replace('/ /', '-', $names[1]);
 			else
 				$psName = '';
 			if (!$psName)
@@ -349,8 +349,8 @@ 
 		$yMin = $this->read_short();
 		$xMax = $this->read_short();
 		$yMax = $this->read_short();
-		$this->bbox = array(($xMin*$scale), ($yMin*$scale), ($xMax*$scale), ($yMax*$scale));
-		$this->skip(3*2);
+		$this->bbox = array(($xMin * $scale), ($yMin * $scale), ($xMax * $scale), ($yMax * $scale));
+		$this->skip(3 * 2);
 		$indexToLocFormat = $this->read_ushort();
 		$glyphDataFormat = $this->read_ushort();
 		if ($glyphDataFormat != 0)
@@ -365,8 +365,8 @@ 
 			$this->skip(4);
 			$hheaAscender = $this->read_short();
 			$hheaDescender = $this->read_short();
-			$this->ascent = ($hheaAscender *$scale);
-			$this->descent = ($hheaDescender *$scale);
+			$this->ascent = ($hheaAscender * $scale);
+			$this->descent = ($hheaDescender * $scale);
 		}
 
 		///////////////////////////////////
@@ -387,17 +387,17 @@ 
 			$sF = $this->read_short();
 			$this->sFamilyClass = ($sF >> 8);
 			$this->sFamilySubClass = ($sF & 0xFF);
-			$this->_pos += 10;  //PANOSE = 10 byte length
-			$panose = fread($this->fh,10);
+			$this->_pos += 10; //PANOSE = 10 byte length
+			$panose = fread($this->fh, 10);
 			$this->skip(26);
 			$sTypoAscender = $this->read_short();
 			$sTypoDescender = $this->read_short();
-			if (!$this->ascent) $this->ascent = ($sTypoAscender*$scale);
-			if (!$this->descent) $this->descent = ($sTypoDescender*$scale);
+			if (!$this->ascent) $this->ascent = ($sTypoAscender * $scale);
+			if (!$this->descent) $this->descent = ($sTypoDescender * $scale);
 			if ($version > 1) {
 				$this->skip(16);
 				$sCapHeight = $this->read_short();
-				$this->capHeight = ($sCapHeight*$scale);
+				$this->capHeight = ($sCapHeight * $scale);
 			}
 			else {
 				$this->capHeight = $this->ascent;
@@ -405,11 +405,11 @@ 
 		}
 		else {
 			$usWeightClass = 500;
-			if (!$this->ascent) $this->ascent = ($yMax*$scale);
-			if (!$this->descent) $this->descent = ($yMin*$scale);
+			if (!$this->ascent) $this->ascent = ($yMax * $scale);
+			if (!$this->descent) $this->descent = ($yMin * $scale);
 			$this->capHeight = $this->ascent;
 		}
-		$this->stemV = 50 + intval(pow(($usWeightClass / 65.0),2));
+		$this->stemV = 50 + intval(pow(($usWeightClass / 65.0), 2));
 
 		///////////////////////////////////
 		// post - PostScript table
@@ -423,7 +423,7 @@ 
 
 		$this->flags = 4;
 
-		if ($this->italicAngle!= 0) 
+		if ($this->italicAngle != 0) 
 			$this->flags = $this->flags | 64;
 		if ($usWeightClass >= 600)
 			$this->flags = $this->flags | 262144;
@@ -457,7 +457,7 @@ 
 		$this->skip(2);
 		$cmapTableCount = $this->read_ushort();
 		$unicode_cmap_offset = 0;
-		for ($i=0;$i<$cmapTableCount;$i++) {
+		for ($i = 0; $i < $cmapTableCount; $i++) {
 			$platformID = $this->read_ushort();
 			$encodingID = $this->read_ushort();
 			$offset = $this->read_ulong();
@@ -469,15 +469,15 @@ 
 					break;
 				}
 			}
-			$this->seek($save_pos );
+			$this->seek($save_pos);
 		}
 		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+			die('Font ('.$this->filename.') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
 
 
 		$glyphToChar = array();
 		$charToGlyph = array();
-		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph );
+		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
 
 		///////////////////////////////////
 		// hmtx - Horizontal metrics table
@@ -493,7 +493,7 @@ 
 
 	function makeSubset($file, &$subset) {
 		$this->filename = $file;
-		$this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file);
+		$this->fh = fopen($file, 'rb') or die('Can\'t open file '.$file);
 		$this->_pos = 0;
 		$this->charWidths = '';
 		$this->glyphPos = array();
@@ -538,7 +538,7 @@ 
 		$this->skip(2);
 		$cmapTableCount = $this->read_ushort();
 		$unicode_cmap_offset = 0;
-		for ($i=0;$i<$cmapTableCount;$i++) {
+		for ($i = 0; $i < $cmapTableCount; $i++) {
 			$platformID = $this->read_ushort();
 			$encodingID = $this->read_ushort();
 			$offset = $this->read_ulong();
@@ -550,23 +550,23 @@ 
 					break;
 				}
 			}
-			$this->seek($save_pos );
+			$this->seek($save_pos);
 		}
 
 		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+			die('Font ('.$this->filename.') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
 
 
 		$glyphToChar = array();
 		$charToGlyph = array();
-		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph );
+		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
 
 		$this->charToGlyph = $charToGlyph;
 
 		///////////////////////////////////
 		// hmtx - Horizontal metrics table
 		///////////////////////////////////
-		$scale = 1;	// not used
+		$scale = 1; // not used
 		$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
 
 		///////////////////////////////////
@@ -576,51 +576,51 @@ 
 
 		$subsetglyphs = array(0=>0); 
 		$subsetCharToGlyph = array();
-		foreach($subset AS $code) {
+		foreach ($subset AS $code) {
 			if (isset($this->charToGlyph[$code])) {
-				$subsetglyphs[$this->charToGlyph[$code]] = $code;	// Old Glyph ID => Unicode
-				$subsetCharToGlyph[$code] = $this->charToGlyph[$code];	// Unicode to old GlyphID
+				$subsetglyphs[$this->charToGlyph[$code]] = $code; // Old Glyph ID => Unicode
+				$subsetCharToGlyph[$code] = $this->charToGlyph[$code]; // Unicode to old GlyphID
 
 			}
 			$this->maxUni = max($this->maxUni, $code);
 		}
 
-		list($start,$dummy) = $this->get_table_pos('glyf');
+		list($start, $dummy) = $this->get_table_pos('glyf');
 
 		$glyphSet = array();
 		ksort($subsetglyphs);
 		$n = 0;
-		$fsLastCharIndex = 0;	// maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
-		foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
-			$fsLastCharIndex = max($fsLastCharIndex , $uni);
-			$glyphSet[$originalGlyphIdx] = $n;	// old glyphID to new glyphID
+		$fsLastCharIndex = 0; // maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
+		foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
+			$fsLastCharIndex = max($fsLastCharIndex, $uni);
+			$glyphSet[$originalGlyphIdx] = $n; // old glyphID to new glyphID
 			$n++;
 		}
 
 		ksort($subsetCharToGlyph);
-		foreach($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
-			$codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx] ;
+		foreach ($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
+			$codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx];
 		}
 		$this->codeToGlyph = $codeToGlyph;
 
 		ksort($subsetglyphs);
-		foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
+		foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
 			$this->getGlyphs($originalGlyphIdx, $start, $glyphSet, $subsetglyphs);
 		}
 
-		$numGlyphs = $numberOfHMetrics = count($subsetglyphs );
+		$numGlyphs = $numberOfHMetrics = count($subsetglyphs);
 
 		//tables copied from the original
-		$tags = array ('name');
-		foreach($tags AS $tag) { $this->add($tag, $this->get_table($tag)); }
-		$tags = array ('cvt ', 'fpgm', 'prep', 'gasp');
-		foreach($tags AS $tag) {
+		$tags = array('name');
+		foreach ($tags AS $tag) { $this->add($tag, $this->get_table($tag)); }
+		$tags = array('cvt ', 'fpgm', 'prep', 'gasp');
+		foreach ($tags AS $tag) {
 			if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); }
 		}
 
 		// post - PostScript
 		$opost = $this->get_table('post');
-		$post = "\x00\x03\x00\x00" . substr($opost,4,12) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+		$post = "\x00\x03\x00\x00".substr($opost, 4, 12)."\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
 		$this->add('post', $post);
 
 		// Sort CID2GID map into segments of contiguous codes
@@ -646,64 +646,64 @@ 
 		}
 
 		// cmap - Character to glyph mapping - Format 4 (MS / )
-		$segCount = count($range) + 1;	// + 1 Last segment has missing character 0xFFFF
+		$segCount = count($range) + 1; // + 1 Last segment has missing character 0xFFFF
 		$searchRange = 1;
 		$entrySelector = 0;
-		while ($searchRange * 2 <= $segCount ) {
+		while ($searchRange * 2 <= $segCount) {
 			$searchRange = $searchRange * 2;
 			$entrySelector = $entrySelector + 1;
 		}
 		$searchRange = $searchRange * 2;
 		$rangeShift = $segCount * 2 - $searchRange;
-		$length = 16 + (8*$segCount ) + ($numGlyphs+1);
-		$cmap = array(0, 1,		// Index : version, number of encoding subtables
-			3, 1,				// Encoding Subtable : platform (MS=3), encoding (Unicode)
-			0, 12,			// Encoding Subtable : offset (hi,lo)
-			4, $length, 0, 		// Format 4 Mapping subtable: format, length, language
-			$segCount*2,
+		$length = 16 + (8 * $segCount) + ($numGlyphs + 1);
+		$cmap = array(0, 1, // Index : version, number of encoding subtables
+			3, 1, // Encoding Subtable : platform (MS=3), encoding (Unicode)
+			0, 12, // Encoding Subtable : offset (hi,lo)
+			4, $length, 0, // Format 4 Mapping subtable: format, length, language
+			$segCount * 2,
 			$searchRange,
 			$entrySelector,
 			$rangeShift);
 
 		// endCode(s)
-		foreach($range AS $start=>$subrange) {
-			$endCode = $start + (count($subrange)-1);
-			$cmap[] = $endCode;	// endCode(s)
+		foreach ($range AS $start=>$subrange) {
+			$endCode = $start + (count($subrange) - 1);
+			$cmap[] = $endCode; // endCode(s)
 		}
-		$cmap[] =	0xFFFF;	// endCode of last Segment
-		$cmap[] =	0;	// reservedPad
+		$cmap[] = 0xFFFF; // endCode of last Segment
+		$cmap[] = 0; // reservedPad
 
 		// startCode(s)
-		foreach($range AS $start=>$subrange) {
-			$cmap[] = $start;	// startCode(s)
+		foreach ($range AS $start=>$subrange) {
+			$cmap[] = $start; // startCode(s)
 		}
-		$cmap[] =	0xFFFF;	// startCode of last Segment
+		$cmap[] = 0xFFFF; // startCode of last Segment
 		// idDelta(s) 
-		foreach($range AS $start=>$subrange) {
-			$idDelta = -($start-$subrange[0]);
+		foreach ($range AS $start=>$subrange) {
+			$idDelta = -($start - $subrange[0]);
 			$n += count($subrange);
-			$cmap[] = $idDelta;	// idDelta(s)
+			$cmap[] = $idDelta; // idDelta(s)
 		}
-		$cmap[] =	1;	// idDelta of last Segment
+		$cmap[] = 1; // idDelta of last Segment
 		// idRangeOffset(s) 
-		foreach($range AS $subrange) {
-			$cmap[] = 0;	// idRangeOffset[segCount]  	Offset in bytes to glyph indexArray, or 0
+		foreach ($range AS $subrange) {
+			$cmap[] = 0; // idRangeOffset[segCount]  	Offset in bytes to glyph indexArray, or 0
 
 		}
-		$cmap[] =	0;	// idRangeOffset of last Segment
-		foreach($range AS $subrange) {
-			foreach($subrange AS $glidx) {
+		$cmap[] = 0; // idRangeOffset of last Segment
+		foreach ($range AS $subrange) {
+			foreach ($subrange AS $glidx) {
 				$cmap[] = $glidx;
 			}
 		}
-		$cmap[] = 0;	// Mapping for last character
+		$cmap[] = 0; // Mapping for last character
 		$cmapstr = '';
-		foreach($cmap AS $cm) { $cmapstr .= pack("n",$cm); }
+		foreach ($cmap AS $cm) { $cmapstr .= pack("n", $cm); }
 		$this->add('cmap', $cmapstr);
 
 
 		// glyf - Glyph data
-		list($glyfOffset,$glyfLength) = $this->get_table_pos('glyf');
+		list($glyfOffset, $glyfLength) = $this->get_table_pos('glyf');
 		if ($glyfLength < $this->maxStrLenRead) {
 			$glyphData = $this->get_table('glyf');
 		}
@@ -721,15 +721,15 @@ 
 		$minLeftSideBearing = 0;
 		$minRightSideBearing = 0;
 		$xMaxExtent = 0;
-		$maxPoints = 0;			// points in non-compound glyph
-		$maxContours = 0;			// contours in non-compound glyph
-		$maxComponentPoints = 0;	// points in compound glyph
-		$maxComponentContours = 0;	// contours in compound glyph
-		$maxComponentElements = 0;	// number of glyphs referenced at top level
-		$maxComponentDepth = 0;		// levels of recursion, set to 0 if font has only simple glyphs
+		$maxPoints = 0; // points in non-compound glyph
+		$maxContours = 0; // contours in non-compound glyph
+		$maxComponentPoints = 0; // points in compound glyph
+		$maxComponentContours = 0; // contours in compound glyph
+		$maxComponentElements = 0; // number of glyphs referenced at top level
+		$maxComponentDepth = 0; // levels of recursion, set to 0 if font has only simple glyphs
 		$this->glyphdata = array();
 
-		foreach($subsetglyphs AS $originalGlyphIdx => $uni) {
+		foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
 			// hmtx - Horizontal Metrics
 			$hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx);	
 			$hmtxstr .= $hm;
@@ -738,26 +738,26 @@ 
 			$glyphPos = $this->glyphPos[$originalGlyphIdx];
 			$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
 			if ($glyfLength < $this->maxStrLenRead) {
-				$data = substr($glyphData,$glyphPos,$glyphLen);
+				$data = substr($glyphData, $glyphPos, $glyphLen);
 			}
 			else {
-				if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset+$glyphPos,$glyphLen);
+				if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset + $glyphPos, $glyphLen);
 				else $data = '';
 			}
 
 			if ($glyphLen > 0) {
-				$up = unpack("n", substr($data,0,2));
+				$up = unpack("n", substr($data, 0, 2));
 			}
 
-			if ($glyphLen > 2 && ($up[1] & (1 << 15)) ) {	// If number of contours <= -1 i.e. composiste glyph
+			if ($glyphLen > 2 && ($up[1] & (1 << 15))) {	// If number of contours <= -1 i.e. composiste glyph
 				$pos_in_glyph = 10;
 				$flags = GF_MORE;
 				$nComponentElements = 0;
 				while ($flags & GF_MORE) {
-					$nComponentElements += 1;	// number of glyphs referenced at top level
-					$up = unpack("n", substr($data,$pos_in_glyph,2));
+					$nComponentElements += 1; // number of glyphs referenced at top level
+					$up = unpack("n", substr($data, $pos_in_glyph, 2));
 					$flags = $up[1];
-					$up = unpack("n", substr($data,$pos_in_glyph+2,2));
+					$up = unpack("n", substr($data, $pos_in_glyph + 2, 2));
 					$glyphIdx = $up[1];
 					$this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
 					$data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
@@ -775,7 +775,7 @@ 
 			$pos += $glyphLen;
 			if ($pos % 4 != 0) {
 				$padding = 4 - ($pos % 4);
-				$glyf .= str_repeat("\0",$padding);
+				$glyf .= str_repeat("\0", $padding);
 				$pos += $padding;
 			}
 		}
@@ -789,12 +789,12 @@ 
 		// loca - Index to location
 		$locastr = '';
 		if ((($pos + 1) >> 1) > 0xFFFF) {
-			$indexToLocFormat = 1;        // long format
-			foreach($offsets AS $offset) { $locastr .= pack("N",$offset); }
+			$indexToLocFormat = 1; // long format
+			foreach ($offsets AS $offset) { $locastr .= pack("N", $offset); }
 		}
 		else {
-			$indexToLocFormat = 0;        // short format
-			foreach($offsets AS $offset) { $locastr .= pack("n",($offset/2)); }
+			$indexToLocFormat = 0; // short format
+			foreach ($offsets AS $offset) { $locastr .= pack("n", ($offset / 2)); }
 		}
 		$this->add('loca', $locastr);
 
@@ -817,14 +817,14 @@ 
 
 		// OS/2 - OS/2
 		$os2 = $this->get_table('OS/2');
-		$this->add('OS/2', $os2 );
+		$this->add('OS/2', $os2);
 
 		fclose($this->fh);
 
 		// Put the TTF file together
 		$stm = '';
 		$this->endTTFile($stm);
-		return $stm ;
+		return $stm;
 	}
 
 	//////////////////////////////////////////////////////////////////////////////////
@@ -833,7 +833,7 @@ 
 		$depth++;
 		$maxdepth = max($maxdepth, $depth);
 		if (count($this->glyphdata[$originalGlyphIdx]['compGlyphs'])) {
-			foreach($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
+			foreach ($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
 				$this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
 			}
 		}
@@ -862,7 +862,7 @@ 
 				$flags = $this->read_ushort();
 				$glyphIdx = $this->read_ushort();
 				if (!isset($glyphSet[$glyphIdx])) {
-					$glyphSet[$glyphIdx] = count($subsetglyphs);	// old glyphID to new glyphID
+					$glyphSet[$glyphIdx] = count($subsetglyphs); // old glyphID to new glyphID
 					$subsetglyphs[$glyphIdx] = true;
 				}
 				$savepos = ftell($this->fh);
@@ -887,17 +887,17 @@ 
 	function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) {
 		$start = $this->seek_table("hmtx");
 		$aw = 0;
-		$this->charWidths = str_pad('', 256*256*2, "\x00");
+		$this->charWidths = str_pad('', 256 * 256 * 2, "\x00");
 		$nCharWidths = 0;
-		if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
-			$data = $this->get_chunk($start,($numberOfHMetrics*4));
+		if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
+			$data = $this->get_chunk($start, ($numberOfHMetrics * 4));
 			$arr = unpack("n*", $data);
 		}
 		else { $this->seek($start); }
-		for( $glyph=0; $glyph<$numberOfHMetrics; $glyph++) {
+		for ($glyph = 0; $glyph < $numberOfHMetrics; $glyph++) {
 
-			if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
-				$aw = $arr[($glyph*2)+1];
+			if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
+				$aw = $arr[($glyph * 2) + 1];
 			}
 			else {
 				$aw = $this->read_ushort();
@@ -905,38 +905,38 @@ 
 			}
 			if (isset($glyphToChar[$glyph]) || $glyph == 0) {
 
-				if ($aw >= (1 << 15) ) { $aw = 0; }	// 1.03 Some (arabic) fonts have -ve values for width
+				if ($aw >= (1 << 15)) { $aw = 0; }	// 1.03 Some (arabic) fonts have -ve values for width
 					// although should be unsigned value - comes out as e.g. 65108 (intended -50)
 				if ($glyph == 0) {
-					$this->defaultWidth = $scale*$aw;
+					$this->defaultWidth = $scale * $aw;
 					continue;
 				}
-				foreach($glyphToChar[$glyph] AS $char) {
+				foreach ($glyphToChar[$glyph] AS $char) {
 					if ($char != 0 && $char != 65535) {
- 						$w = intval(round($scale*$aw));
+ 						$w = intval(round($scale * $aw));
 						if ($w == 0) { $w = 65535; }
 						if ($char < 196608) {
-							$this->charWidths[$char*2] = chr($w >> 8);
-							$this->charWidths[$char*2 + 1] = chr($w & 0xFF);
+							$this->charWidths[$char * 2] = chr($w >> 8);
+							$this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
 							$nCharWidths++;
 						}
 					}
 				}
 			}
 		}
-		$data = $this->get_chunk(($start+$numberOfHMetrics*4),($numGlyphs*2));
+		$data = $this->get_chunk(($start + $numberOfHMetrics * 4), ($numGlyphs * 2));
 		$arr = unpack("n*", $data);
-		$diff = $numGlyphs-$numberOfHMetrics;
-		for( $pos=0; $pos<$diff; $pos++) {
+		$diff = $numGlyphs - $numberOfHMetrics;
+		for ($pos = 0; $pos < $diff; $pos++) {
 			$glyph = $pos + $numberOfHMetrics;
 			if (isset($glyphToChar[$glyph])) {
-				foreach($glyphToChar[$glyph] AS $char) {
+				foreach ($glyphToChar[$glyph] AS $char) {
 					if ($char != 0 && $char != 65535) {
-						$w = intval(round($scale*$aw));
+						$w = intval(round($scale * $aw));
 						if ($w == 0) { $w = 65535; }
 						if ($char < 196608) {
-							$this->charWidths[$char*2] = chr($w >> 8);
-							$this->charWidths[$char*2 + 1] = chr($w & 0xFF);
+							$this->charWidths[$char * 2] = chr($w >> 8);
+							$this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
 							$nCharWidths++;
 						}
 					}
@@ -952,14 +952,14 @@ 
 	function getHMetric($numberOfHMetrics, $gid) {
 		$start = $this->seek_table("hmtx");
 		if ($gid < $numberOfHMetrics) {
-			$this->seek($start+($gid*4));
-			$hm = fread($this->fh,4);
+			$this->seek($start + ($gid * 4));
+			$hm = fread($this->fh, 4);
 		}
 		else {
-			$this->seek($start+(($numberOfHMetrics-1)*4));
-			$hm = fread($this->fh,2);
-			$this->seek($start+($numberOfHMetrics*2)+($gid*2));
-			$hm .= fread($this->fh,2);
+			$this->seek($start + (($numberOfHMetrics - 1) * 4));
+			$hm = fread($this->fh, 2);
+			$this->seek($start + ($numberOfHMetrics * 2) + ($gid * 2));
+			$hm .= fread($this->fh, 2);
 		}
 		return $hm;
 	}
@@ -968,17 +968,17 @@ 
 		$start = $this->seek_table('loca');
 		$this->glyphPos = array();
 		if ($indexToLocFormat == 0) {
-			$data = $this->get_chunk($start,($numGlyphs*2)+2);
+			$data = $this->get_chunk($start, ($numGlyphs * 2) + 2);
 			$arr = unpack("n*", $data);
-			for ($n=0; $n<=$numGlyphs; $n++) {
-				$this->glyphPos[] = ($arr[$n+1] * 2);
+			for ($n = 0; $n <= $numGlyphs; $n++) {
+				$this->glyphPos[] = ($arr[$n + 1] * 2);
 			}
 		}
 		else if ($indexToLocFormat == 1) {
-			$data = $this->get_chunk($start,($numGlyphs*4)+4);
+			$data = $this->get_chunk($start, ($numGlyphs * 4) + 4);
 			$arr = unpack("N*", $data);
-			for ($n=0; $n<=$numGlyphs; $n++) {
-				$this->glyphPos[] = ($arr[$n+1]);
+			for ($n = 0; $n <= $numGlyphs; $n++) {
+				$this->glyphPos[] = ($arr[$n + 1]);
 			}
 		}
 		else 
@@ -987,7 +987,7 @@ 
 
 
 	// CMAP Format 4
-	function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph ) {
+	function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph) {
 		$this->maxUniChar = 0;
 		$this->seek($unicode_cmap_offset + 2);
 		$length = $this->read_ushort();
@@ -997,19 +997,19 @@ 
 		$segCount = $this->read_ushort() / 2;
 		$this->skip(6);
 		$endCount = array();
-		for($i=0; $i<$segCount; $i++) { $endCount[] = $this->read_ushort(); }
+		for ($i = 0; $i < $segCount; $i++) { $endCount[] = $this->read_ushort(); }
 		$this->skip(2);
 		$startCount = array();
-		for($i=0; $i<$segCount; $i++) { $startCount[] = $this->read_ushort(); }
+		for ($i = 0; $i < $segCount; $i++) { $startCount[] = $this->read_ushort(); }
 		$idDelta = array();
-		for($i=0; $i<$segCount; $i++) { $idDelta[] = $this->read_short(); }		// ???? was unsigned short
+		for ($i = 0; $i < $segCount; $i++) { $idDelta[] = $this->read_short(); }		// ???? was unsigned short
 		$idRangeOffset_start = $this->_pos;
 		$idRangeOffset = array();
-		for($i=0; $i<$segCount; $i++) { $idRangeOffset[] = $this->read_ushort(); }
+		for ($i = 0; $i < $segCount; $i++) { $idRangeOffset[] = $this->read_ushort(); }
 
-		for ($n=0;$n<$segCount;$n++) {
+		for ($n = 0; $n < $segCount; $n++) {
 			$endpoint = ($endCount[$n] + 1);
-			for ($unichar=$startCount[$n];$unichar<$endpoint;$unichar++) {
+			for ($unichar = $startCount[$n]; $unichar < $endpoint; $unichar++) {
 				if ($idRangeOffset[$n] == 0)
 					$glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
 				else {
@@ -1024,7 +1024,7 @@ 
 					}
 				}
 				$charToGlyph[$unichar] = $glyph;
-				if ($unichar < 196608) { $this->maxUniChar = max($unichar,$this->maxUniChar); }
+				if ($unichar < 196608) { $this->maxUniChar = max($unichar, $this->maxUniChar); }
 				$glyphToChar[$glyph][] = $unichar;
 			}
 		}
@@ -1046,38 +1046,38 @@ 
 
 		// Header
 		if (_TTF_MAC_HEADER) {
-			$stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift));	// Mac
+			$stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift)); // Mac
 		}
 		else {
-			$stm .= (pack("Nnnnn", 0x00010000 , $numTables, $searchRange, $entrySelector, $rangeShift));	// Windows
+			$stm .= (pack("Nnnnn", 0x00010000, $numTables, $searchRange, $entrySelector, $rangeShift)); // Windows
 		}
 
 		// Table directory
 		$tables = $this->otables;
 
-		ksort ($tables); 
+		ksort($tables); 
 		$offset = 12 + $numTables * 16;
 		foreach ($tables AS $tag=>$data) {
 			if ($tag == 'head') { $head_start = $offset; }
 			$stm .= $tag;
 			$checksum = $this->calcChecksum($data);
-			$stm .= pack("nn", $checksum[0],$checksum[1]);
+			$stm .= pack("nn", $checksum[0], $checksum[1]);
 			$stm .= pack("NN", $offset, strlen($data));
-			$paddedLength = (strlen($data)+3)&~3;
+			$paddedLength = (strlen($data) + 3) & ~3;
 			$offset = $offset + $paddedLength;
 		}
 
 		// Table data
 		foreach ($tables AS $tag=>$data) {
 			$data .= "\0\0\0";
-			$stm .= substr($data,0,(strlen($data)&~3));
+			$stm .= substr($data, 0, (strlen($data) & ~3));
 		}
 
 		$checksum = $this->calcChecksum($stm);
-		$checksum = $this->sub32(array(0xB1B0,0xAFBA), $checksum);
-		$chk = pack("nn", $checksum[0],$checksum[1]);
-		$stm = $this->splice($stm,($head_start + 8),$chk);
-		return $stm ;
+		$checksum = $this->sub32(array(0xB1B0, 0xAFBA), $checksum);
+		$chk = pack("nn", $checksum[0], $checksum[1]);
+		$stm = $this->splice($stm, ($head_start + 8), $chk);
+		return $stm;
 	}
 
 

Braces +113 added lines, -92 removed lines

@@ -87,12 +87,15 @@ 
 		$this->descent = 0;
 		$this->TTCFonts = array();
 		$this->version = $version = $this->read_ulong();
-		if ($version==0x4F54544F) 
-			die("Postscript outlines are not supported");
-		if ($version==0x74746366) 
-			die("ERROR - TrueType Fonts Collections not supported");
-		if (!in_array($version, array(0x00010000,0x74727565)))
-			die("Not a TrueType font: version=".$version);
+		if ($version==0x4F54544F) {
+					die("Postscript outlines are not supported");
+		}
+		if ($version==0x74746366) {
+					die("ERROR - TrueType Fonts Collections not supported");
+		}
+		if (!in_array($version, array(0x00010000,0x74727565))) {
+					die("Not a TrueType font: version=".$version);
+		}
 		$this->readTableDirectory();
 		$this->extractInfo();
 		fclose($this->fh);
@@ -277,8 +280,9 @@ 
 
 			$name_offset = $this->seek_table("name");
 			$format = $this->read_ushort();
-			if ($format != 0)
-				die("Unknown name table format ".$format);
+			if ($format != 0) {
+							die("Unknown name table format ".$format);
+			}
 			$numRecords = $this->read_ushort();
 			$string_data_offset = $name_offset + $this->read_ushort();
 			$names = array(1=>'',2=>'',3=>'',4=>'',6=>'');
@@ -291,13 +295,16 @@ 
 				$nameId = $this->read_ushort();
 				$length = $this->read_ushort();
 				$offset = $this->read_ushort();
-				if (!in_array($nameId,$K)) continue;
+				if (!in_array($nameId,$K)) {
+				    continue;
+				}
 				$N = '';
 				if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name
 					$opos = $this->_pos;
 					$this->seek($string_data_offset + $offset);
-					if ($length % 2 != 0)
-						die("PostScript name is UTF-16BE string of odd length");
+					if ($length % 2 != 0) {
+											die("PostScript name is UTF-16BE string of odd length");
+					}
 					$length /= 2;
 					$N = '';
 					while ($length > 0) {
@@ -307,8 +314,7 @@ 
 					}
 					$this->_pos = $opos;
 					$this->seek($opos);
-				}
-				else if ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name
+				} else if ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name
 					$opos = $this->_pos;
 					$N = $this->get_chunk($string_data_offset + $offset, $length);
 					$this->_pos = $opos;
@@ -317,19 +323,23 @@ 
 				if ($N && $names[$nameId]=='') {
 					$names[$nameId] = $N;
 					$nameCount -= 1;
-					if ($nameCount==0) break;
+					if ($nameCount==0) {
+					    break;
+					}
 				}
 			}
-			if ($names[6])
-				$psName = $names[6];
-			else if ($names[4])
-				$psName = preg_replace('/ /','-',$names[4]);
-			else if ($names[1])
-				$psName = preg_replace('/ /','-',$names[1]);
-			else
-				$psName = '';
-			if (!$psName)
-				die("Could not find PostScript font name");
+			if ($names[6]) {
+							$psName = $names[6];
+			} else if ($names[4]) {
+							$psName = preg_replace('/ /','-',$names[4]);
+			} else if ($names[1]) {
+							$psName = preg_replace('/ /','-',$names[1]);
+			} else {
+							$psName = '';
+			}
+			if (!$psName) {
+							die("Could not find PostScript font name");
+			}
 			$this->name = $psName;
 			if ($names[1]) { $this->familyName = $names[1]; } else { $this->familyName = $psName; }
 			if ($names[2]) { $this->styleName = $names[2]; } else { $this->styleName = 'Regular'; }
@@ -353,8 +363,9 @@ 
 		$this->skip(3*2);
 		$indexToLocFormat = $this->read_ushort();
 		$glyphDataFormat = $this->read_ushort();
-		if ($glyphDataFormat != 0)
-			die('Unknown glyph data format '.$glyphDataFormat);
+		if ($glyphDataFormat != 0) {
+					die('Unknown glyph data format '.$glyphDataFormat);
+		}
 
 		///////////////////////////////////
 		// hhea metrics table
@@ -392,21 +403,27 @@ 
 			$this->skip(26);
 			$sTypoAscender = $this->read_short();
 			$sTypoDescender = $this->read_short();
-			if (!$this->ascent) $this->ascent = ($sTypoAscender*$scale);
-			if (!$this->descent) $this->descent = ($sTypoDescender*$scale);
+			if (!$this->ascent) {
+			    $this->ascent = ($sTypoAscender*$scale);
+			}
+			if (!$this->descent) {
+			    $this->descent = ($sTypoDescender*$scale);
+			}
 			if ($version > 1) {
 				$this->skip(16);
 				$sCapHeight = $this->read_short();
 				$this->capHeight = ($sCapHeight*$scale);
-			}
-			else {
+			} else {
 				$this->capHeight = $this->ascent;
 			}
-		}
-		else {
+		} else {
 			$usWeightClass = 500;
-			if (!$this->ascent) $this->ascent = ($yMax*$scale);
-			if (!$this->descent) $this->descent = ($yMin*$scale);
+			if (!$this->ascent) {
+			    $this->ascent = ($yMax*$scale);
+			}
+			if (!$this->descent) {
+			    $this->descent = ($yMin*$scale);
+			}
 			$this->capHeight = $this->ascent;
 		}
 		$this->stemV = 50 + intval(pow(($usWeightClass / 65.0),2));
@@ -423,12 +440,15 @@ 
 
 		$this->flags = 4;
 
-		if ($this->italicAngle!= 0) 
-			$this->flags = $this->flags | 64;
-		if ($usWeightClass >= 600)
-			$this->flags = $this->flags | 262144;
-		if ($isFixedPitch)
-			$this->flags = $this->flags | 1;
+		if ($this->italicAngle!= 0) {
+					$this->flags = $this->flags | 64;
+		}
+		if ($usWeightClass >= 600) {
+					$this->flags = $this->flags | 262144;
+		}
+		if ($isFixedPitch) {
+					$this->flags = $this->flags | 1;
+		}
 
 		///////////////////////////////////
 		// hhea - Horizontal header table
@@ -436,11 +456,13 @@ 
 		$this->seek_table("hhea");
 		$this->skip(32); 
 		$metricDataFormat = $this->read_ushort();
-		if ($metricDataFormat != 0)
-			die('Unknown horizontal metric data format '.$metricDataFormat);
+		if ($metricDataFormat != 0) {
+					die('Unknown horizontal metric data format '.$metricDataFormat);
+		}
 		$numberOfHMetrics = $this->read_ushort();
-		if ($numberOfHMetrics == 0) 
-			die('Number of horizontal metrics is 0');
+		if ($numberOfHMetrics == 0) {
+					die('Number of horizontal metrics is 0');
+		}
 
 		///////////////////////////////////
 		// maxp - Maximum profile table
@@ -465,14 +487,17 @@ 
 			if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
 				$format = $this->get_ushort($cmap_offset + $offset);
 				if ($format == 4) {
-					if (!$unicode_cmap_offset) $unicode_cmap_offset = $cmap_offset + $offset;
+					if (!$unicode_cmap_offset) {
+					    $unicode_cmap_offset = $cmap_offset + $offset;
+					}
 					break;
 				}
 			}
 			$this->seek($save_pos );
 		}
-		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+		if (!$unicode_cmap_offset) {
+					die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+		}
 
 
 		$glyphToChar = array();
@@ -553,8 +578,9 @@ 
 			$this->seek($save_pos );
 		}
 
-		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+		if (!$unicode_cmap_offset) {
+					die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+		}
 
 
 		$glyphToChar = array();
@@ -739,10 +765,12 @@ 
 			$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
 			if ($glyfLength < $this->maxStrLenRead) {
 				$data = substr($glyphData,$glyphPos,$glyphLen);
-			}
-			else {
-				if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset+$glyphPos,$glyphLen);
-				else $data = '';
+			} else {
+				if ($glyphLen > 0) {
+				    $data = $this->get_chunk($glyfOffset+$glyphPos,$glyphLen);
+				} else {
+				    $data = '';
+				}
 			}
 
 			if ($glyphLen > 0) {
@@ -762,11 +790,8 @@ 
 					$this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
 					$data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
 					$pos_in_glyph += 4;
-					if ($flags & GF_WORDS) { $pos_in_glyph += 4; }
-					else { $pos_in_glyph += 2; }
-					if ($flags & GF_SCALE) { $pos_in_glyph += 2; }
-					else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; }
-					else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; }
+					if ($flags & GF_WORDS) { $pos_in_glyph += 4; } else { $pos_in_glyph += 2; }
+					if ($flags & GF_SCALE) { $pos_in_glyph += 2; } else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; } else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; }
 				}
 				$maxComponentElements = max($maxComponentElements, $nComponentElements);
 			}
@@ -791,8 +816,7 @@ 
 		if ((($pos + 1) >> 1) > 0xFFFF) {
 			$indexToLocFormat = 1;        // long format
 			foreach($offsets AS $offset) { $locastr .= pack("N",$offset); }
-		}
-		else {
+		} else {
 			$indexToLocFormat = 0;        // short format
 			foreach($offsets AS $offset) { $locastr .= pack("n",($offset/2)); }
 		}
@@ -836,8 +860,7 @@ 
 			foreach($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
 				$this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
 			}
-		}
-		else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) {	// simple
+		} else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) {	// simple
 			$contours += $this->glyphdata[$originalGlyphIdx]['nContours'];
 			$points += $this->glyphdata[$originalGlyphIdx]['nPoints'];
 		}
@@ -868,16 +891,18 @@ 
 				$savepos = ftell($this->fh);
 				$this->getGlyphs($glyphIdx, $start, $glyphSet, $subsetglyphs);
 				$this->seek($savepos);
-				if ($flags & GF_WORDS)
-					$this->skip(4);
-				else
-					$this->skip(2);
-				if ($flags & GF_SCALE)
-					$this->skip(2);
-				else if ($flags & GF_XYSCALE)
-					$this->skip(4);
-				else if ($flags & GF_TWOBYTWO)
-					$this->skip(8);
+				if ($flags & GF_WORDS) {
+									$this->skip(4);
+				} else {
+									$this->skip(2);
+				}
+				if ($flags & GF_SCALE) {
+									$this->skip(2);
+				} else if ($flags & GF_XYSCALE) {
+									$this->skip(4);
+				} else if ($flags & GF_TWOBYTWO) {
+									$this->skip(8);
+				}
 			}
 		}
 	}
@@ -892,14 +917,12 @@ 
 		if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
 			$data = $this->get_chunk($start,($numberOfHMetrics*4));
 			$arr = unpack("n*", $data);
-		}
-		else { $this->seek($start); }
+		} else { $this->seek($start); }
 		for( $glyph=0; $glyph<$numberOfHMetrics; $glyph++) {
 
 			if (($numberOfHMetrics*4) < $this->maxStrLenRead) {
 				$aw = $arr[($glyph*2)+1];
-			}
-			else {
+			} else {
 				$aw = $this->read_ushort();
 				$lsb = $this->read_ushort();
 			}
@@ -954,8 +977,7 @@ 
 		if ($gid < $numberOfHMetrics) {
 			$this->seek($start+($gid*4));
 			$hm = fread($this->fh,4);
-		}
-		else {
+		} else {
 			$this->seek($start+(($numberOfHMetrics-1)*4));
 			$hm = fread($this->fh,2);
 			$this->seek($start+($numberOfHMetrics*2)+($gid*2));
@@ -973,16 +995,15 @@ 
 			for ($n=0; $n<=$numGlyphs; $n++) {
 				$this->glyphPos[] = ($arr[$n+1] * 2);
 			}
-		}
-		else if ($indexToLocFormat == 1) {
+		} else if ($indexToLocFormat == 1) {
 			$data = $this->get_chunk($start,($numGlyphs*4)+4);
 			$arr = unpack("N*", $data);
 			for ($n=0; $n<=$numGlyphs; $n++) {
 				$this->glyphPos[] = ($arr[$n+1]);
 			}
+		} else {
+					die('Unknown location table format '.$indexToLocFormat);
 		}
-		else 
-			die('Unknown location table format '.$indexToLocFormat);
 	}
 
 
@@ -1010,17 +1031,18 @@ 
 		for ($n=0;$n<$segCount;$n++) {
 			$endpoint = ($endCount[$n] + 1);
 			for ($unichar=$startCount[$n];$unichar<$endpoint;$unichar++) {
-				if ($idRangeOffset[$n] == 0)
-					$glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
-				else {
+				if ($idRangeOffset[$n] == 0) {
+									$glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
+				} else {
 					$offset = ($unichar - $startCount[$n]) * 2 + $idRangeOffset[$n];
 					$offset = $idRangeOffset_start + 2 * $n + $offset;
-					if ($offset >= $limit)
-						$glyph = 0;
-					else {
+					if ($offset >= $limit) {
+											$glyph = 0;
+					} else {
 						$glyph = $this->get_ushort($offset);
-						if ($glyph != 0)
-						   $glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
+						if ($glyph != 0) {
+												   $glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
+						}
 					}
 				}
 				$charToGlyph[$unichar] = $glyph;
@@ -1047,8 +1069,7 @@ 
 		// Header
 		if (_TTF_MAC_HEADER) {
 			$stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift));	// Mac
-		}
-		else {
+		} else {
 			$stm .= (pack("Nnnnn", 0x00010000 , $numTables, $searchRange, $entrySelector, $rangeShift));	// Windows
 		}
 

includes/libraries/Pdf/Tfpdf/fpdf.php

Doc Comments +5 added lines

@@ -120,6 +120,7 @@ 
 
     /**
     * Compute key depending on object number where the encrypted data is stored
+    * @param integer $n
     */
     function _objectkey($n)
     {
@@ -168,6 +169,8 @@ 
 
     /**
     * Compute O value
+    * @param string $user_pass
+    * @param string $owner_pass
     */
     function _Ovalue($user_pass, $owner_pass)
     {
@@ -186,6 +189,8 @@ 
 
     /**
     * Compute encryption key
+    * @param string $user_pass
+    * @param integer $protection
     */
     function _generateencryptionkey($user_pass, $owner_pass, $protection)
     {

Indentation +19 added lines, -19 removed lines

@@ -69,15 +69,15 @@ 
     var $enc_obj_id;         //encryption object id
 
     /**
-    * Function to set permissions as well as user and owner passwords
-    *
-    * - permissions is an array with values taken from the following list:
-    *   copy, print, modify, annot-forms
-    *   If a value is present it means that the permission is granted
-    * - If a user password is set, user will be prompted before document is opened
-    * - If an owner password is set, document can be opened in privilege mode with no
-    *   restriction if that password is entered
-    */
+     * Function to set permissions as well as user and owner passwords
+     *
+     * - permissions is an array with values taken from the following list:
+     *   copy, print, modify, annot-forms
+     *   If a value is present it means that the permission is granted
+     * - If a user password is set, user will be prompted before document is opened
+     * - If an owner password is set, document can be opened in privilege mode with no
+     *   restriction if that password is entered
+     */
     function SetProtection($permissions=array(), $user_pass='', $owner_pass=null)
     {
         $options = array('print' => 4, 'modify' => 8, 'copy' => 16, 'annot-forms' => 32 );
@@ -119,8 +119,8 @@ 
     }
 
     /**
-    * Compute key depending on object number where the encrypted data is stored
-    */
+     * Compute key depending on object number where the encrypted data is stored
+     */
     function _objectkey($n)
     {
         return substr($this->_md5_16($this->encryption_key.pack('VXxx',$n)),0,10);
@@ -159,16 +159,16 @@ 
     }
 
     /**
-    * Get MD5 as binary string
-    */
+     * Get MD5 as binary string
+     */
     function _md5_16($string)
     {
         return pack('H*',md5($string));
     }
 
     /**
-    * Compute O value
-    */
+     * Compute O value
+     */
     function _Ovalue($user_pass, $owner_pass)
     {
         $tmp = $this->_md5_16($owner_pass);
@@ -177,16 +177,16 @@ 
     }
 
     /**
-    * Compute U value
-    */
+     * Compute U value
+     */
     function _Uvalue()
     {
         return RC4($this->encryption_key, $this->padding);
     }
 
     /**
-    * Compute encryption key
-    */
+     * Compute encryption key
+     */
     function _generateencryptionkey($user_pass, $owner_pass, $protection)
     {
         // Pad passwords

Spacing +31 added lines, -31 removed lines

@@ -13,7 +13,7 @@ 
 
 require('tfpdf.class.php');
 
-if(function_exists('mcrypt_encrypt'))
+if (function_exists('mcrypt_encrypt'))
 {
     function RC4($key, $data)
     {
@@ -26,12 +26,12 @@ 
     {
         static $last_key, $last_state;
 
-        if($key != $last_key)
+        if ($key != $last_key)
         {
-            $k = str_repeat($key, 256/strlen($key)+1);
+            $k = str_repeat($key, 256 / strlen($key) + 1);
             $state = range(0, 255);
             $j = 0;
-            for ($i=0; $i<256; $i++){
+            for ($i = 0; $i < 256; $i++) {
                 $t = $state[$i];
                 $j = ($j + $t + ord($k[$i])) % 256;
                 $state[$i] = $state[$j];
@@ -47,13 +47,13 @@ 
         $a = 0;
         $b = 0;
         $out = '';
-        for ($i=0; $i<$len; $i++){
-            $a = ($a+1) % 256;
+        for ($i = 0; $i < $len; $i++) {
+            $a = ($a + 1) % 256;
             $t = $state[$a];
-            $b = ($b+$t) % 256;
+            $b = ($b + $t) % 256;
             $state[$a] = $state[$b];
             $state[$b] = $t;
-            $k = $state[($state[$a]+$state[$b]) % 256];
+            $k = $state[($state[$a] + $state[$b]) % 256];
             $out .= chr(ord($data[$i]) ^ $k);
         }
         return $out;
@@ -62,11 +62,11 @@ 
 
 class FPDF_Protection extends tFPDF
 {
-    var $encrypted = false;  //whether document is protected
-    var $Uvalue;             //U entry in pdf document
-    var $Ovalue;             //O entry in pdf document
-    var $Pvalue;             //P entry in pdf document
-    var $enc_obj_id;         //encryption object id
+    var $encrypted = false; //whether document is protected
+    var $Uvalue; //U entry in pdf document
+    var $Ovalue; //O entry in pdf document
+    var $Pvalue; //P entry in pdf document
+    var $enc_obj_id; //encryption object id
 
     /**
     * Function to set permissions as well as user and owner passwords
@@ -78,11 +78,11 @@ 
     * - If an owner password is set, document can be opened in privilege mode with no
     *   restriction if that password is entered
     */
-    function SetProtection($permissions=array(), $user_pass='', $owner_pass=null)
+    function SetProtection($permissions = array(), $user_pass = '', $owner_pass = null)
     {
-        $options = array('print' => 4, 'modify' => 8, 'copy' => 16, 'annot-forms' => 32 );
+        $options = array('print' => 4, 'modify' => 8, 'copy' => 16, 'annot-forms' => 32);
         $protection = 192;
-        foreach($permissions as $permission)
+        foreach ($permissions as $permission)
         {
             if (!isset($options[$permission]))
                 $this->Error('Incorrect permission: '.$permission);
@@ -123,7 +123,7 @@ 
     */
     function _objectkey($n)
     {
-        return substr($this->_md5_16($this->encryption_key.pack('VXxx',$n)),0,10);
+        return substr($this->_md5_16($this->encryption_key.pack('VXxx', $n)), 0, 10);
     }
 
     function _putresources()
@@ -163,7 +163,7 @@ 
     */
     function _md5_16($string)
     {
-        return pack('H*',md5($string));
+        return pack('H*', md5($string));
     }
 
     /**
@@ -172,7 +172,7 @@ 
     function _Ovalue($user_pass, $owner_pass)
     {
         $tmp = $this->_md5_16($owner_pass);
-        $owner_RC4_key = substr($tmp,0,5);
+        $owner_RC4_key = substr($tmp, 0, 5);
         return RC4($owner_RC4_key, $user_pass);
     }
 
@@ -190,28 +190,28 @@ 
     function _generateencryptionkey($user_pass, $owner_pass, $protection)
     {
         // Pad passwords
-        $user_pass = substr($user_pass.$this->padding,0,32);
-        $owner_pass = substr($owner_pass.$this->padding,0,32);
+        $user_pass = substr($user_pass.$this->padding, 0, 32);
+        $owner_pass = substr($owner_pass.$this->padding, 0, 32);
         // Compute O value
-        $this->Ovalue = $this->_Ovalue($user_pass,$owner_pass);
+        $this->Ovalue = $this->_Ovalue($user_pass, $owner_pass);
         // Compute encyption key
         $tmp = $this->_md5_16($user_pass.$this->Ovalue.chr($protection)."\xFF\xFF\xFF");
-        $this->encryption_key = substr($tmp,0,5);
+        $this->encryption_key = substr($tmp, 0, 5);
         // Compute U value
         $this->Uvalue = $this->_Uvalue();
         // Compute P value
-        $this->Pvalue = -(($protection^255)+1);
+        $this->Pvalue = -(($protection ^ 255) + 1);
     }
 
     function Header()
     {
         global $LANG, $k;
-        $this->SetFont('helvetica','B',12);
+        $this->SetFont('helvetica', 'B', 12);
         // Teampass
-        $this->Cell(100,10, "Teampass" ,0,0,'L', 0);
+        $this->Cell(100, 10, "Teampass", 0, 0, 'L', 0);
         //
-        $this->SetFont('helvetica','B',12);
-        $this->Cell(0,10,$LANG['print_out_pdf_title'],0,0,'L');
+        $this->SetFont('helvetica', 'B', 12);
+        $this->Cell(0, 10, $LANG['print_out_pdf_title'], 0, 0, 'L');
         // Line break
         $this->Ln(10);
     }
@@ -222,10 +222,10 @@ 
         // Position at 1.5 cm from bottom
         $this->SetY(-15);
         // Arial italic 8
-        $this->SetFont('helvetica','I',8);
+        $this->SetFont('helvetica', 'I', 8);
         // info
-        $this->Cell(0,10,$LANG['pdf_del_date']." ".date($_SESSION['settings']['date_format']." ".$_SESSION['settings']['time_format'], time()).' '.$LANG['by'].' '.$_SESSION['login'],0,0,'C');
+        $this->Cell(0, 10, $LANG['pdf_del_date']." ".date($_SESSION['settings']['date_format']." ".$_SESSION['settings']['time_format'], time()).' '.$LANG['by'].' '.$_SESSION['login'], 0, 0, 'C');
         // Page number
-        $this->Cell(0,10,$LANG['pages'].' '.$this->PageNo().'/{nb}',0,0,'R');
+        $this->Cell(0, 10, $LANG['pages'].' '.$this->PageNo().'/{nb}', 0, 0, 'R');
     }
 }

Braces +15 added lines, -12 removed lines

@@ -19,8 +19,7 @@ 
     {
         return mcrypt_encrypt(MCRYPT_ARCFOUR, $key, $data, MCRYPT_MODE_STREAM, '');
     }
-}
-else
+} else
 {
     function RC4($key, $data)
     {
@@ -39,9 +38,9 @@ 
             }
             $last_key = $key;
             $last_state = $state;
+        } else {
+                    $state = $last_state;
         }
-        else
-            $state = $last_state;
 
         $len = strlen($data);
         $a = 0;
@@ -84,12 +83,14 @@ 
         $protection = 192;
         foreach($permissions as $permission)
         {
-            if (!isset($options[$permission]))
-                $this->Error('Incorrect permission: '.$permission);
+            if (!isset($options[$permission])) {
+                            $this->Error('Incorrect permission: '.$permission);
+            }
             $protection += $options[$permission];
         }
-        if ($owner_pass === null)
-            $owner_pass = uniqid(rand());
+        if ($owner_pass === null) {
+                    $owner_pass = uniqid(rand());
+        }
         $this->encrypted = true;
         $this->padding = "\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08".
                         "\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A";
@@ -104,8 +105,9 @@ 
 
     function _putstream($s)
     {
-        if ($this->encrypted)
-            $s = RC4($this->_objectkey($this->n), $s);
+        if ($this->encrypted) {
+                    $s = RC4($this->_objectkey($this->n), $s);
+        }
         parent::_putstream($s);
     }
 
@@ -113,8 +115,9 @@ 
     {
         //if (!$this->_isascii($s))
         //    $s = $this->_UTF8toUTF16($s);
-        if ($this->encrypted)
-            $s = RC4($this->_objectkey($this->n), $s);
+        if ($this->encrypted) {
+                    $s = RC4($this->_objectkey($this->n), $s);
+        }
         return '('.$this->_escape($s).')';
     }
 

includes/libraries/Pdf/Tfpdf/tfpdf.class.php

Doc Comments +39 added lines

@@ -170,6 +170,10 @@ 
     $this->PDFVersion = '1.3';
 }
 
+/**
+ * @param double $left
+ * @param double $top
+ */
 function SetMargins($left, $top, $right=null)
 {
     // Set left, top and right margins
@@ -200,6 +204,9 @@ 
     $this->rMargin = $margin;
 }
 
+/**
+ * @param boolean $auto
+ */
 function SetAutoPageBreak($auto, $margin=0)
 {
     // Set auto page break mode and triggering margin
@@ -208,6 +215,9 @@ 
     $this->PageBreakTrigger = $this->h-$margin;
 }
 
+/**
+ * @param string $zoom
+ */
 function SetDisplayMode($zoom, $layout='default')
 {
     // Set display mode in viewer
@@ -221,6 +231,9 @@ 
         $this->Error('Incorrect layout display mode: '.$layout);
 }
 
+/**
+ * @param boolean $compress
+ */
 function SetCompression($compress)
 {
     // Set page compression
@@ -473,6 +486,9 @@ 
     $this->_out(sprintf('%.2F %.2F %.2F %.2F re %s',$x*$this->k,($this->h-$y)*$this->k,$w*$this->k,-$h*$this->k,$op));
 }
 
+/**
+ * @param string $family
+ */
 function AddFont($family, $style='', $file='', $uni=false)
 {
     // Add a TrueType, OpenType or Type1 font
@@ -584,6 +600,9 @@ 
     }
 }
 
+/**
+ * @param string $family
+ */
 function SetFont($family, $style='', $size=0)
 {
     // Select a font; size given in points
@@ -665,6 +684,10 @@ 
     $this->links[$link] = array($page, $y);
 }
 
+/**
+ * @param double $y
+ * @param string $link
+ */
 function Link($x, $y, $w, $h, $link)
 {
     // Put a link on the page
@@ -1072,6 +1095,9 @@ 
     }
 }
 
+/**
+ * @param integer $h
+ */
 function Ln($h=null)
 {
     // Line feed; default value is last cell height
@@ -1305,6 +1331,10 @@ 
     }
 }
 
+/**
+ * @param string $orientation
+ * @param string $size
+ */
 function _beginpage($orientation, $size)
 {
     $this->page++;
@@ -1350,6 +1380,9 @@ 
     $this->state = 1;
 }
 
+/**
+ * @param string $font
+ */
 function _loadfont($font)
 {
     // Load a font definition file from the font directory
@@ -1437,6 +1470,9 @@ 
     return array('w'=>$a[0], 'h'=>$a[1], 'cs'=>$colspace, 'bpc'=>$bpc, 'f'=>'DCTDecode', 'data'=>$data);
 }
 
+/**
+ * @param string $file
+ */
 function _parsepng($file)
 {
     // Extract info from a PNG file
@@ -1973,6 +2009,9 @@ 
     }
 }
 
+/**
+ * @param integer $maxUni
+ */
 function _putTTfontwidths(&$font, $maxUni) {
     if (file_exists($font['unifilename'].'.cw127.php')) {
         include($font['unifilename'].'.cw127.php') ;

Indentation +22 added lines, -22 removed lines

@@ -481,12 +481,12 @@ 
     if($style=='IB')
         $style='BI';
     if($file=='') {
-       if ($uni) {
+        if ($uni) {
         $file = str_replace(' ','',$family).strtolower($style).'.ttf';
-       }
-       else {
+        }
+        else {
         $file = str_replace(' ','',$family).strtolower($style).'.php';
-       }
+        }
     }
     $fontkey = $family.$style;
     if(isset($this->fonts[$fontkey]))
@@ -1750,7 +1750,7 @@ 
     }
     foreach($this->FontFiles as $file=>$info)
     {
-       if (!isset($info['type']) || $info['type']!='TTF') {
+        if (!isset($info['type']) || $info['type']!='TTF') {
         // Font file embedding
         $this->_newobj();
         $this->FontFiles[$file]['n']=$this->n;
@@ -1785,7 +1785,7 @@ 
         $this->_out('>>');
         $this->_putstream($font);
         $this->_out('endobj');
-       }
+        }
     }
     foreach($this->fonts as $k=>$font)
     {
@@ -2263,29 +2263,29 @@ 
 
 // Converts UTF-8 strings to codepoints array
 function UTF8StringToArray($str) {
-   $out = array();
-   $len = strlen($str);
-   for ($i = 0; $i < $len; $i++) {
+    $out = array();
+    $len = strlen($str);
+    for ($i = 0; $i < $len; $i++) {
     $uni = -1;
-      $h = ord($str[$i]);
-      if ( $h <= 0x7F )
-         $uni = $h;
-      elseif ( $h >= 0xC2 ) {
-         if ( ($h <= 0xDF) && ($i < $len -1) )
+        $h = ord($str[$i]);
+        if ( $h <= 0x7F )
+            $uni = $h;
+        elseif ( $h >= 0xC2 ) {
+            if ( ($h <= 0xDF) && ($i < $len -1) )
             $uni = ($h & 0x1F) << 6 | (ord($str[++$i]) & 0x3F);
-         elseif ( ($h <= 0xEF) && ($i < $len -2) )
+            elseif ( ($h <= 0xEF) && ($i < $len -2) )
             $uni = ($h & 0x0F) << 12 | (ord($str[++$i]) & 0x3F) << 6
-                                       | (ord($str[++$i]) & 0x3F);
-         elseif ( ($h <= 0xF4) && ($i < $len -3) )
+                                        | (ord($str[++$i]) & 0x3F);
+            elseif ( ($h <= 0xF4) && ($i < $len -3) )
             $uni = ($h & 0x0F) << 18 | (ord($str[++$i]) & 0x3F) << 12
-                                       | (ord($str[++$i]) & 0x3F) << 6
-                                       | (ord($str[++$i]) & 0x3F);
-      }
+                                        | (ord($str[++$i]) & 0x3F) << 6
+                                        | (ord($str[++$i]) & 0x3F);
+        }
     if ($uni >= 0) {
         $out[] = $uni;
     }
-   }
-   return $out;
+    }
+    return $out;
 }
 
 

Spacing +615 added lines, -615 removed lines

@@ -8,75 +8,75 @@ 
 * License:  LGPL                                                               *
 *******************************************************************************/
 
-define('tFPDF_VERSION','1.24');
+define('tFPDF_VERSION', '1.24');
 
 class tFPDF
 {
 
 var $unifontSubset;
-var $page;               // current page number
-var $n;                  // current object number
-var $offsets;            // array of object offsets
-var $buffer;             // buffer holding in-memory PDF
-var $pages;              // array containing pages
-var $state;              // current document state
-var $compress;           // compression flag
-var $k;                  // scale factor (number of points in user unit)
-var $DefOrientation;     // default orientation
-var $CurOrientation;     // current orientation
-var $StdPageSizes;       // standard page sizes
-var $DefPageSize;        // default page size
-var $CurPageSize;        // current page size
-var $PageSizes;          // used for pages with non default sizes or orientations
-var $wPt, $hPt;          // dimensions of current page in points
-var $w, $h;              // dimensions of current page in user unit
-var $lMargin;            // left margin
-var $tMargin;            // top margin
-var $rMargin;            // right margin
-var $bMargin;            // page break margin
-var $cMargin;            // cell margin
-var $x, $y;              // current position in user unit
-var $lasth;              // height of last printed cell
-var $LineWidth;          // line width in user unit
-var $fontpath;           // path containing fonts
-var $CoreFonts;          // array of core font names
-var $fonts;              // array of used fonts
-var $FontFiles;          // array of font files
-var $diffs;              // array of encoding differences
-var $FontFamily;         // current font family
-var $FontStyle;          // current font style
-var $underline;          // underlining flag
-var $CurrentFont;        // current font info
-var $FontSizePt;         // current font size in points
-var $FontSize;           // current font size in user unit
-var $DrawColor;          // commands for drawing color
-var $FillColor;          // commands for filling color
-var $TextColor;          // commands for text color
-var $ColorFlag;          // indicates whether fill and text colors are different
-var $ws;                 // word spacing
-var $images;             // array of used images
-var $PageLinks;          // array of links in pages
-var $links;              // array of internal links
-var $AutoPageBreak;      // automatic page breaking
-var $PageBreakTrigger;   // threshold used to trigger page breaks
-var $InHeader;           // flag set when processing header
-var $InFooter;           // flag set when processing footer
-var $ZoomMode;           // zoom display mode
-var $LayoutMode;         // layout display mode
-var $title;              // title
-var $subject;            // subject
-var $author;             // author
-var $keywords;           // keywords
-var $creator;            // creator
-var $AliasNbPages;       // alias for total number of pages
-var $PDFVersion;         // PDF version number
+var $page; // current page number
+var $n; // current object number
+var $offsets; // array of object offsets
+var $buffer; // buffer holding in-memory PDF
+var $pages; // array containing pages
+var $state; // current document state
+var $compress; // compression flag
+var $k; // scale factor (number of points in user unit)
+var $DefOrientation; // default orientation
+var $CurOrientation; // current orientation
+var $StdPageSizes; // standard page sizes
+var $DefPageSize; // default page size
+var $CurPageSize; // current page size
+var $PageSizes; // used for pages with non default sizes or orientations
+var $wPt, $hPt; // dimensions of current page in points
+var $w, $h; // dimensions of current page in user unit
+var $lMargin; // left margin
+var $tMargin; // top margin
+var $rMargin; // right margin
+var $bMargin; // page break margin
+var $cMargin; // cell margin
+var $x, $y; // current position in user unit
+var $lasth; // height of last printed cell
+var $LineWidth; // line width in user unit
+var $fontpath; // path containing fonts
+var $CoreFonts; // array of core font names
+var $fonts; // array of used fonts
+var $FontFiles; // array of font files
+var $diffs; // array of encoding differences
+var $FontFamily; // current font family
+var $FontStyle; // current font style
+var $underline; // underlining flag
+var $CurrentFont; // current font info
+var $FontSizePt; // current font size in points
+var $FontSize; // current font size in user unit
+var $DrawColor; // commands for drawing color
+var $FillColor; // commands for filling color
+var $TextColor; // commands for text color
+var $ColorFlag; // indicates whether fill and text colors are different
+var $ws; // word spacing
+var $images; // array of used images
+var $PageLinks; // array of links in pages
+var $links; // array of internal links
+var $AutoPageBreak; // automatic page breaking
+var $PageBreakTrigger; // threshold used to trigger page breaks
+var $InHeader; // flag set when processing header
+var $InFooter; // flag set when processing footer
+var $ZoomMode; // zoom display mode
+var $LayoutMode; // layout display mode
+var $title; // title
+var $subject; // subject
+var $author; // author
+var $keywords; // keywords
+var $creator; // creator
+var $AliasNbPages; // alias for total number of pages
+var $PDFVersion; // PDF version number
 
 /*******************************************************************************
 *                                                                              *
 *                               Public methods                                 *
 *                                                                              *
 *******************************************************************************/
-function __construct($orientation='P', $unit='mm', $size='A4', $footer_text_1 = "Page")
+function __construct($orientation = 'P', $unit = 'mm', $size = 'A4', $footer_text_1 = "Page")
 {
     // Some checks
     $this->_dochecks();
@@ -105,44 +105,44 @@ 
     $this->ColorFlag = false;
     $this->ws = 0;
     // Font path
-    if(defined('FPDF_FONTPATH'))
+    if (defined('FPDF_FONTPATH'))
     {
         $this->fontpath = FPDF_FONTPATH;
-        if(substr($this->fontpath,-1)!='/' && substr($this->fontpath,-1)!='\\')
+        if (substr($this->fontpath, -1) != '/' && substr($this->fontpath, -1) != '\\')
             $this->fontpath .= '/';
     }
-    elseif(is_dir(dirname(__FILE__).'/font'))
+    elseif (is_dir(dirname(__FILE__).'/font'))
         $this->fontpath = dirname(__FILE__).'/font/';
     else
         $this->fontpath = '';
     // Core fonts
     $this->CoreFonts = array('courier', 'helvetica', 'times', 'symbol', 'zapfdingbats');
     // Scale factor
-    if($unit=='pt')
+    if ($unit == 'pt')
         $this->k = 1;
-    elseif($unit=='mm')
-        $this->k = 72/25.4;
-    elseif($unit=='cm')
-        $this->k = 72/2.54;
-    elseif($unit=='in')
+    elseif ($unit == 'mm')
+        $this->k = 72 / 25.4;
+    elseif ($unit == 'cm')
+        $this->k = 72 / 2.54;
+    elseif ($unit == 'in')
         $this->k = 72;
     else
         $this->Error('Incorrect unit: '.$unit);
     // Page sizes
-    $this->StdPageSizes = array('a3'=>array(841.89,1190.55), 'a4'=>array(595.28,841.89), 'a5'=>array(420.94,595.28),
-        'letter'=>array(612,792), 'legal'=>array(612,1008));
+    $this->StdPageSizes = array('a3'=>array(841.89, 1190.55), 'a4'=>array(595.28, 841.89), 'a5'=>array(420.94, 595.28),
+        'letter'=>array(612, 792), 'legal'=>array(612, 1008));
     $size = $this->_getpagesize($size);
     $this->DefPageSize = $size;
     $this->CurPageSize = $size;
     // Page orientation
     $orientation = strtolower($orientation);
-    if($orientation=='p' || $orientation=='portrait')
+    if ($orientation == 'p' || $orientation == 'portrait')
     {
         $this->DefOrientation = 'P';
         $this->w = $size[0];
         $this->h = $size[1];
     }
-    elseif($orientation=='l' || $orientation=='landscape')
+    elseif ($orientation == 'l' || $orientation == 'landscape')
     {
         $this->DefOrientation = 'L';
         $this->w = $size[1];
@@ -151,17 +151,17 @@ 
     else
         $this->Error('Incorrect orientation: '.$orientation);
     $this->CurOrientation = $this->DefOrientation;
-    $this->wPt = $this->w*$this->k;
-    $this->hPt = $this->h*$this->k;
+    $this->wPt = $this->w * $this->k;
+    $this->hPt = $this->h * $this->k;
     // Page margins (1 cm)
-    $margin = 28.35/$this->k;
-    $this->SetMargins($margin,$margin);
+    $margin = 28.35 / $this->k;
+    $this->SetMargins($margin, $margin);
     // Interior cell margin (1 mm)
-    $this->cMargin = $margin/10;
+    $this->cMargin = $margin / 10;
     // Line width (0.2 mm)
-    $this->LineWidth = .567/$this->k;
+    $this->LineWidth = .567 / $this->k;
     // Automatic page break
-    $this->SetAutoPageBreak(true,2*$margin);
+    $this->SetAutoPageBreak(true, 2 * $margin);
     // Default display mode
     $this->SetDisplayMode('default');
     // Enable compression
@@ -170,12 +170,12 @@ 
     $this->PDFVersion = '1.3';
 }
 
-function SetMargins($left, $top, $right=null)
+function SetMargins($left, $top, $right = null)
 {
     // Set left, top and right margins
     $this->lMargin = $left;
     $this->tMargin = $top;
-    if($right===null)
+    if ($right === null)
         $right = $left;
     $this->rMargin = $right;
 }
@@ -184,7 +184,7 @@ 
 {
     // Set left margin
     $this->lMargin = $margin;
-    if($this->page>0 && $this->x<$margin)
+    if ($this->page > 0 && $this->x < $margin)
         $this->x = $margin;
 }
 
@@ -200,22 +200,22 @@ 
     $this->rMargin = $margin;
 }
 
-function SetAutoPageBreak($auto, $margin=0)
+function SetAutoPageBreak($auto, $margin = 0)
 {
     // Set auto page break mode and triggering margin
     $this->AutoPageBreak = $auto;
     $this->bMargin = $margin;
-    $this->PageBreakTrigger = $this->h-$margin;
+    $this->PageBreakTrigger = $this->h - $margin;
 }
 
-function SetDisplayMode($zoom, $layout='default')
+function SetDisplayMode($zoom, $layout = 'default')
 {
     // Set display mode in viewer
-    if($zoom=='fullpage' || $zoom=='fullwidth' || $zoom=='real' || $zoom=='default' || !is_string($zoom))
+    if ($zoom == 'fullpage' || $zoom == 'fullwidth' || $zoom == 'real' || $zoom == 'default' || !is_string($zoom))
         $this->ZoomMode = $zoom;
     else
         $this->Error('Incorrect zoom display mode: '.$zoom);
-    if($layout=='single' || $layout=='continuous' || $layout=='two' || $layout=='default')
+    if ($layout == 'single' || $layout == 'continuous' || $layout == 'two' || $layout == 'default')
         $this->LayoutMode = $layout;
     else
         $this->Error('Incorrect layout display mode: '.$layout);
@@ -224,53 +224,53 @@ 
 function SetCompression($compress)
 {
     // Set page compression
-    if(function_exists('gzcompress'))
+    if (function_exists('gzcompress'))
         $this->compress = $compress;
     else
         $this->compress = false;
 }
 
-function SetTitle($title, $isUTF8=false)
+function SetTitle($title, $isUTF8 = false)
 {
     // Title of document
-    if($isUTF8)
+    if ($isUTF8)
         $title = $this->_UTF8toUTF16($title);
     $this->title = $title;
 }
 
-function SetSubject($subject, $isUTF8=false)
+function SetSubject($subject, $isUTF8 = false)
 {
     // Subject of document
-    if($isUTF8)
+    if ($isUTF8)
         $subject = $this->_UTF8toUTF16($subject);
     $this->subject = $subject;
 }
 
-function SetAuthor($author, $isUTF8=false)
+function SetAuthor($author, $isUTF8 = false)
 {
     // Author of document
-    if($isUTF8)
+    if ($isUTF8)
         $author = $this->_UTF8toUTF16($author);
     $this->author = $author;
 }
 
-function SetKeywords($keywords, $isUTF8=false)
+function SetKeywords($keywords, $isUTF8 = false)
 {
     // Keywords of document
-    if($isUTF8)
+    if ($isUTF8)
         $keywords = $this->_UTF8toUTF16($keywords);
     $this->keywords = $keywords;
 }
 
-function SetCreator($creator, $isUTF8=false)
+function SetCreator($creator, $isUTF8 = false)
 {
     // Creator of document
-    if($isUTF8)
+    if ($isUTF8)
         $creator = $this->_UTF8toUTF16($creator);
     $this->creator = $creator;
 }
 
-function AliasNbPages($alias='{nb}')
+function AliasNbPages($alias = '{nb}')
 {
     // Define an alias for total number of pages
     $this->AliasNbPages = $alias;
@@ -291,9 +291,9 @@ 
 function Close()
 {
     // Terminate document
-    if($this->state==3)
+    if ($this->state == 3)
         return;
-    if($this->page==0)
+    if ($this->page == 0)
         $this->AddPage();
     // Page footer
     $this->InFooter = true;
@@ -305,10 +305,10 @@ 
     $this->_enddoc();
 }
 
-function AddPage($orientation='', $size='')
+function AddPage($orientation = '', $size = '')
 {
     // Start a new page
-    if($this->state==0)
+    if ($this->state == 0)
         $this->Open();
     $family = $this->FontFamily;
     $style = $this->FontStyle.($this->underline ? 'U' : '');
@@ -318,7 +318,7 @@ 
     $fc = $this->FillColor;
     $tc = $this->TextColor;
     $cf = $this->ColorFlag;
-    if($this->page>0)
+    if ($this->page > 0)
     {
         // Page footer
         $this->InFooter = true;
@@ -328,21 +328,21 @@ 
         $this->_endpage();
     }
     // Start new page
-    $this->_beginpage($orientation,$size);
+    $this->_beginpage($orientation, $size);
     // Set line cap style to square
     $this->_out('2 J');
     // Set line width
     $this->LineWidth = $lw;
-    $this->_out(sprintf('%.2F w',$lw*$this->k));
+    $this->_out(sprintf('%.2F w', $lw * $this->k));
     // Set font
-    if($family)
-        $this->SetFont($family,$style,$fontsize);
+    if ($family)
+        $this->SetFont($family, $style, $fontsize);
     // Set colors
     $this->DrawColor = $dc;
-    if($dc!='0 G')
+    if ($dc != '0 G')
         $this->_out($dc);
     $this->FillColor = $fc;
-    if($fc!='0 g')
+    if ($fc != '0 g')
         $this->_out($fc);
     $this->TextColor = $tc;
     $this->ColorFlag = $cf;
@@ -351,21 +351,21 @@ 
     $this->Header();
     $this->InHeader = false;
     // Restore line width
-    if($this->LineWidth!=$lw)
+    if ($this->LineWidth != $lw)
     {
         $this->LineWidth = $lw;
-        $this->_out(sprintf('%.2F w',$lw*$this->k));
+        $this->_out(sprintf('%.2F w', $lw * $this->k));
     }
     // Restore font
-    if($family)
-        $this->SetFont($family,$style,$fontsize);
+    if ($family)
+        $this->SetFont($family, $style, $fontsize);
     // Restore colors
-    if($this->DrawColor!=$dc)
+    if ($this->DrawColor != $dc)
     {
         $this->DrawColor = $dc;
         $this->_out($dc);
     }
-    if($this->FillColor!=$fc)
+    if ($this->FillColor != $fc)
     {
         $this->FillColor = $fc;
         $this->_out($fc);
@@ -390,127 +390,127 @@ 
     return $this->page;
 }
 
-function SetDrawColor($r, $g=null, $b=null)
+function SetDrawColor($r, $g = null, $b = null)
 {
     // Set color for all stroking operations
-    if(($r==0 && $g==0 && $b==0) || $g===null)
-        $this->DrawColor = sprintf('%.3F G',$r/255);
+    if (($r == 0 && $g == 0 && $b == 0) || $g === null)
+        $this->DrawColor = sprintf('%.3F G', $r / 255);
     else
-        $this->DrawColor = sprintf('%.3F %.3F %.3F RG',$r/255,$g/255,$b/255);
-    if($this->page>0)
+        $this->DrawColor = sprintf('%.3F %.3F %.3F RG', $r / 255, $g / 255, $b / 255);
+    if ($this->page > 0)
         $this->_out($this->DrawColor);
 }
 
-function SetFillColor($r, $g=null, $b=null)
+function SetFillColor($r, $g = null, $b = null)
 {
     // Set color for all filling operations
-    if(($r==0 && $g==0 && $b==0) || $g===null)
-        $this->FillColor = sprintf('%.3F g',$r/255);
+    if (($r == 0 && $g == 0 && $b == 0) || $g === null)
+        $this->FillColor = sprintf('%.3F g', $r / 255);
     else
-        $this->FillColor = sprintf('%.3F %.3F %.3F rg',$r/255,$g/255,$b/255);
-    $this->ColorFlag = ($this->FillColor!=$this->TextColor);
-    if($this->page>0)
+        $this->FillColor = sprintf('%.3F %.3F %.3F rg', $r / 255, $g / 255, $b / 255);
+    $this->ColorFlag = ($this->FillColor != $this->TextColor);
+    if ($this->page > 0)
         $this->_out($this->FillColor);
 }
 
-function SetTextColor($r, $g=null, $b=null)
+function SetTextColor($r, $g = null, $b = null)
 {
     // Set color for text
-    if(($r==0 && $g==0 && $b==0) || $g===null)
-        $this->TextColor = sprintf('%.3F g',$r/255);
+    if (($r == 0 && $g == 0 && $b == 0) || $g === null)
+        $this->TextColor = sprintf('%.3F g', $r / 255);
     else
-        $this->TextColor = sprintf('%.3F %.3F %.3F rg',$r/255,$g/255,$b/255);
-    $this->ColorFlag = ($this->FillColor!=$this->TextColor);
+        $this->TextColor = sprintf('%.3F %.3F %.3F rg', $r / 255, $g / 255, $b / 255);
+    $this->ColorFlag = ($this->FillColor != $this->TextColor);
 }
 
 function GetStringWidth($s)
 {
     // Get width of a string in the current font
-    $s = (string)$s;
+    $s = (string) $s;
     $cw = &$this->CurrentFont['cw'];
-    $w=0;
+    $w = 0;
     if ($this->unifontSubset) {
         $unicode = $this->UTF8StringToArray($s);
-        foreach($unicode as $char) {
-            if (isset($cw[$char])) { $w += (ord($cw[2*$char])<<8) + ord($cw[2*$char+1]); }
-            else if($char>0 && $char<128 && isset($cw[chr($char)])) { $w += $cw[chr($char)]; }
-            else if(isset($this->CurrentFont['desc']['MissingWidth'])) { $w += $this->CurrentFont['desc']['MissingWidth']; }
-            else if(isset($this->CurrentFont['MissingWidth'])) { $w += $this->CurrentFont['MissingWidth']; }
+        foreach ($unicode as $char) {
+            if (isset($cw[$char])) { $w += (ord($cw[2 * $char]) << 8) + ord($cw[2 * $char + 1]); }
+            else if ($char > 0 && $char < 128 && isset($cw[chr($char)])) { $w += $cw[chr($char)]; }
+            else if (isset($this->CurrentFont['desc']['MissingWidth'])) { $w += $this->CurrentFont['desc']['MissingWidth']; }
+            else if (isset($this->CurrentFont['MissingWidth'])) { $w += $this->CurrentFont['MissingWidth']; }
             else { $w += 500; }
         }
     }
     else {
         $l = strlen($s);
-        for($i=0;$i<$l;$i++)
+        for ($i = 0; $i < $l; $i++)
             $w += $cw[$s[$i]];
     }
-    return $w*$this->FontSize/1000;
+    return $w * $this->FontSize / 1000;
 }
 
 function SetLineWidth($width)
 {
     // Set line width
     $this->LineWidth = $width;
-    if($this->page>0)
-        $this->_out(sprintf('%.2F w',$width*$this->k));
+    if ($this->page > 0)
+        $this->_out(sprintf('%.2F w', $width * $this->k));
 }
 
 function Line($x1, $y1, $x2, $y2)
 {
     // Draw a line
-    $this->_out(sprintf('%.2F %.2F m %.2F %.2F l S',$x1*$this->k,($this->h-$y1)*$this->k,$x2*$this->k,($this->h-$y2)*$this->k));
+    $this->_out(sprintf('%.2F %.2F m %.2F %.2F l S', $x1 * $this->k, ($this->h - $y1) * $this->k, $x2 * $this->k, ($this->h - $y2) * $this->k));
 }
 
-function Rect($x, $y, $w, $h, $style='')
+function Rect($x, $y, $w, $h, $style = '')
 {
     // Draw a rectangle
-    if($style=='F')
+    if ($style == 'F')
         $op = 'f';
-    elseif($style=='FD' || $style=='DF')
+    elseif ($style == 'FD' || $style == 'DF')
         $op = 'B';
     else
         $op = 'S';
-    $this->_out(sprintf('%.2F %.2F %.2F %.2F re %s',$x*$this->k,($this->h-$y)*$this->k,$w*$this->k,-$h*$this->k,$op));
+    $this->_out(sprintf('%.2F %.2F %.2F %.2F re %s', $x * $this->k, ($this->h - $y) * $this->k, $w * $this->k, -$h * $this->k, $op));
 }
 
-function AddFont($family, $style='', $file='', $uni=false)
+function AddFont($family, $style = '', $file = '', $uni = false)
 {
     // Add a TrueType, OpenType or Type1 font
     $family = strtolower($family);
     $style = strtoupper($style);
-    if($style=='IB')
-        $style='BI';
-    if($file=='') {
+    if ($style == 'IB')
+        $style = 'BI';
+    if ($file == '') {
        if ($uni) {
-        $file = str_replace(' ','',$family).strtolower($style).'.ttf';
+        $file = str_replace(' ', '', $family).strtolower($style).'.ttf';
        }
        else {
-        $file = str_replace(' ','',$family).strtolower($style).'.php';
+        $file = str_replace(' ', '', $family).strtolower($style).'.php';
        }
     }
     $fontkey = $family.$style;
-    if(isset($this->fonts[$fontkey]))
+    if (isset($this->fonts[$fontkey]))
         return;
 
     if ($uni) {
-        if (defined("_SYSTEM_TTFONTS") && file_exists(_SYSTEM_TTFONTS.$file )) { $ttffilename = _SYSTEM_TTFONTS.$file ; }
-        else { $ttffilename = $this->_getfontpath().'unifont/'.$file ; }
-        $unifilename = $this->_getfontpath().'unifont/'.strtolower(substr($file ,0,(strpos($file ,'.'))));
+        if (defined("_SYSTEM_TTFONTS") && file_exists(_SYSTEM_TTFONTS.$file)) { $ttffilename = _SYSTEM_TTFONTS.$file; }
+        else { $ttffilename = $this->_getfontpath().'unifont/'.$file; }
+        $unifilename = $this->_getfontpath().'unifont/'.strtolower(substr($file, 0, (strpos($file, '.'))));
         $name = '';
         $originalsize = 0;
         $ttfstat = stat($ttffilename);
         if (file_exists($unifilename.'.mtx.php')) {
             include($unifilename.'.mtx.php');
         }
-        if (!isset($type) ||  !isset($name) || $originalsize != $ttfstat['size']) {
+        if (!isset($type) || !isset($name) || $originalsize != $ttfstat['size']) {
             $ttffile = $ttffilename;
             require_once($this->_getfontpath().'unifont/ttfonts.php');
             $ttf = new TTFontFile();
             $ttf->getMetrics($ttffile);
             $cw = $ttf->charWidths;
-            $name = preg_replace('/[ ()]/','',$ttf->fullName);
+            $name = preg_replace('/[ ()]/', '', $ttf->fullName);
 
-            $desc= array('Ascent'=>round($ttf->ascent),
+            $desc = array('Ascent'=>round($ttf->ascent),
             'Descent'=>round($ttf->descent),
             'CapHeight'=>round($ttf->capHeight),
             'Flags'=>$ttf->flags,
@@ -520,25 +520,25 @@ 
             'MissingWidth'=>round($ttf->defaultWidth));
             $up = round($ttf->underlinePosition);
             $ut = round($ttf->underlineThickness);
-            $originalsize = $ttfstat['size']+0;
+            $originalsize = $ttfstat['size'] + 0;
             $type = 'TTF';
             // Generate metrics .php file
-            $s='<?php'."\n";
-            $s.='$name=\''.$name."';\n";
-            $s.='$type=\''.$type."';\n";
-            $s.='$desc='.var_export($desc,true).";\n";
-            $s.='$up='.$up.";\n";
-            $s.='$ut='.$ut.";\n";
-            $s.='$ttffile=\''.$ttffile."';\n";
-            $s.='$originalsize='.$originalsize.";\n";
-            $s.='$fontkey=\''.$fontkey."';\n";
-            $s.="?>";
+            $s = '<?php'."\n";
+            $s .= '$name=\''.$name."';\n";
+            $s .= '$type=\''.$type."';\n";
+            $s .= '$desc='.var_export($desc, true).";\n";
+            $s .= '$up='.$up.";\n";
+            $s .= '$ut='.$ut.";\n";
+            $s .= '$ttffile=\''.$ttffile."';\n";
+            $s .= '$originalsize='.$originalsize.";\n";
+            $s .= '$fontkey=\''.$fontkey."';\n";
+            $s .= "?>";
             if (is_writable(dirname($this->_getfontpath().'unifont/'.'x'))) {
-                $fh = fopen($unifilename.'.mtx.php',"w");
-                fwrite($fh,$s,strlen($s));
+                $fh = fopen($unifilename.'.mtx.php', "w");
+                fwrite($fh, $s, strlen($s));
                 fclose($fh);
-                $fh = fopen($unifilename.'.cw.dat',"wb");
-                fwrite($fh,$cw,strlen($cw));
+                $fh = fopen($unifilename.'.cw.dat', "wb");
+                fwrite($fh, $cw, strlen($cw));
                 fclose($fh);
                 @unlink($unifilename.'.cw127.php');
             }
@@ -547,35 +547,35 @@ 
         else {
             $cw = @file_get_contents($unifilename.'.cw.dat');
         }
-        $i = count($this->fonts)+1;
-        if(!empty($this->AliasNbPages))
-            $sbarr = range(0,57);
+        $i = count($this->fonts) + 1;
+        if (!empty($this->AliasNbPages))
+            $sbarr = range(0, 57);
         else
-            $sbarr = range(0,32);
+            $sbarr = range(0, 32);
         $this->fonts[$fontkey] = array('i'=>$i, 'type'=>$type, 'name'=>$name, 'desc'=>$desc, 'up'=>$up, 'ut'=>$ut, 'cw'=>$cw, 'ttffile'=>$ttffile, 'fontkey'=>$fontkey, 'subset'=>$sbarr, 'unifilename'=>$unifilename);
 
-        $this->FontFiles[$fontkey]=array('length1'=>$originalsize, 'type'=>"TTF", 'ttffile'=>$ttffile);
-        $this->FontFiles[$file]=array('type'=>"TTF");
+        $this->FontFiles[$fontkey] = array('length1'=>$originalsize, 'type'=>"TTF", 'ttffile'=>$ttffile);
+        $this->FontFiles[$file] = array('type'=>"TTF");
         unset($cw);
     }
     else {
         $info = $this->_loadfont($file);
-        $info['i'] = count($this->fonts)+1;
-        if(!empty($info['diff']))
+        $info['i'] = count($this->fonts) + 1;
+        if (!empty($info['diff']))
         {
             // Search existing encodings
-            $n = array_search($info['diff'],$this->diffs);
-            if(!$n)
+            $n = array_search($info['diff'], $this->diffs);
+            if (!$n)
             {
-                $n = count($this->diffs)+1;
+                $n = count($this->diffs) + 1;
                 $this->diffs[$n] = $info['diff'];
             }
             $info['diffn'] = $n;
         }
-        if(!empty($info['file']))
+        if (!empty($info['file']))
         {
             // Embedded font
-            if($info['type']=='TrueType')
+            if ($info['type'] == 'TrueType')
                 $this->FontFiles[$info['file']] = array('length1'=>$info['originalsize']);
             else
                 $this->FontFiles[$info['file']] = array('length1'=>$info['size1'], 'length2'=>$info['size2']);
@@ -584,42 +584,42 @@ 
     }
 }
 
-function SetFont($family, $style='', $size=0)
+function SetFont($family, $style = '', $size = 0)
 {
     // Select a font; size given in points
-    if($family=='')
+    if ($family == '')
         $family = $this->FontFamily;
     else
         $family = strtolower($family);
     $style = strtoupper($style);
-    if(strpos($style,'U')!==false)
+    if (strpos($style, 'U') !== false)
     {
         $this->underline = true;
-        $style = str_replace('U','',$style);
+        $style = str_replace('U', '', $style);
     }
     else
         $this->underline = false;
-    if($style=='IB')
+    if ($style == 'IB')
         $style = 'BI';
-    if($size==0)
+    if ($size == 0)
         $size = $this->FontSizePt;
     // Test if font is already selected
-    if($this->FontFamily==$family && $this->FontStyle==$style && $this->FontSizePt==$size)
+    if ($this->FontFamily == $family && $this->FontStyle == $style && $this->FontSizePt == $size)
         return;
     // Test if font is already loaded
     $fontkey = $family.$style;
-    if(!isset($this->fonts[$fontkey]))
+    if (!isset($this->fonts[$fontkey]))
     {
         // Test if one of the core fonts
-        if($family=='arial')
+        if ($family == 'arial')
             $family = 'helvetica';
-        if(in_array($family,$this->CoreFonts))
+        if (in_array($family, $this->CoreFonts))
         {
-            if($family=='symbol' || $family=='zapfdingbats')
+            if ($family == 'symbol' || $family == 'zapfdingbats')
                 $style = '';
             $fontkey = $family.$style;
-            if(!isset($this->fonts[$fontkey]))
-                $this->AddFont($family,$style);
+            if (!isset($this->fonts[$fontkey]))
+                $this->AddFont($family, $style);
         }
         else
             $this->Error('Undefined font: '.$family.' '.$style);
@@ -628,39 +628,39 @@ 
     $this->FontFamily = $family;
     $this->FontStyle = $style;
     $this->FontSizePt = $size;
-    $this->FontSize = $size/$this->k;
+    $this->FontSize = $size / $this->k;
     $this->CurrentFont = &$this->fonts[$fontkey];
-    if ($this->fonts[$fontkey]['type']=='TTF') { $this->unifontSubset = true; }
+    if ($this->fonts[$fontkey]['type'] == 'TTF') { $this->unifontSubset = true; }
     else { $this->unifontSubset = false; }
-    if($this->page>0)
-        $this->_out(sprintf('BT /F%d %.2F Tf ET',$this->CurrentFont['i'],$this->FontSizePt));
+    if ($this->page > 0)
+        $this->_out(sprintf('BT /F%d %.2F Tf ET', $this->CurrentFont['i'], $this->FontSizePt));
 }
 
 function SetFontSize($size)
 {
     // Set font size in points
-    if($this->FontSizePt==$size)
+    if ($this->FontSizePt == $size)
         return;
     $this->FontSizePt = $size;
-    $this->FontSize = $size/$this->k;
-    if($this->page>0)
-        $this->_out(sprintf('BT /F%d %.2F Tf ET',$this->CurrentFont['i'],$this->FontSizePt));
+    $this->FontSize = $size / $this->k;
+    if ($this->page > 0)
+        $this->_out(sprintf('BT /F%d %.2F Tf ET', $this->CurrentFont['i'], $this->FontSizePt));
 }
 
 function AddLink()
 {
     // Create a new internal link
-    $n = count($this->links)+1;
+    $n = count($this->links) + 1;
     $this->links[$n] = array(0, 0);
     return $n;
 }
 
-function SetLink($link, $y=0, $page=-1)
+function SetLink($link, $y = 0, $page = -1)
 {
     // Set destination of internal link
-    if($y==-1)
+    if ($y == -1)
         $y = $this->y;
-    if($page==-1)
+    if ($page == -1)
         $page = $this->page;
     $this->links[$link] = array($page, $y);
 }
@@ -668,7 +668,7 @@ 
 function Link($x, $y, $w, $h, $link)
 {
     // Put a link on the page
-    $this->PageLinks[$this->page][] = array($x*$this->k, $this->hPt-$y*$this->k, $w*$this->k, $h*$this->k, $link);
+    $this->PageLinks[$this->page][] = array($x * $this->k, $this->hPt - $y * $this->k, $w * $this->k, $h * $this->k, $link);
 }
 
 function Text($x, $y, $txt)
@@ -677,15 +677,15 @@ 
     if ($this->unifontSubset)
     {
         $txt2 = '('.$this->_escape($this->UTF8ToUTF16BE($txt, false)).')';
-        foreach($this->UTF8StringToArray($txt) as $uni)
+        foreach ($this->UTF8StringToArray($txt) as $uni)
             $this->CurrentFont['subset'][$uni] = $uni;
     }
     else
         $txt2 = '('.$this->_escape($txt).')';
-    $s = sprintf('BT %.2F %.2F Td %s Tj ET',$x*$this->k,($this->h-$y)*$this->k,$txt2);
-    if($this->underline && $txt!='')
-        $s .= ' '.$this->_dounderline($x,$y,$txt);
-    if($this->ColorFlag)
+    $s = sprintf('BT %.2F %.2F Td %s Tj ET', $x * $this->k, ($this->h - $y) * $this->k, $txt2);
+    if ($this->underline && $txt != '')
+        $s .= ' '.$this->_dounderline($x, $y, $txt);
+    if ($this->ColorFlag)
         $s = 'q '.$this->TextColor.' '.$s.' Q';
     $this->_out($s);
 }
@@ -696,78 +696,78 @@ 
     return $this->AutoPageBreak;
 }
 
-function Cell($w, $h=0, $txt='', $border=0, $ln=0, $align='', $fill=false, $link='')
+function Cell($w, $h = 0, $txt = '', $border = 0, $ln = 0, $align = '', $fill = false, $link = '')
 {
     // Output a cell
     $k = $this->k;
-    if($this->y+$h>$this->PageBreakTrigger && !$this->InHeader && !$this->InFooter && $this->AcceptPageBreak())
+    if ($this->y + $h > $this->PageBreakTrigger && !$this->InHeader && !$this->InFooter && $this->AcceptPageBreak())
     {
         // Automatic page break
         $x = $this->x;
         $ws = $this->ws;
-        if($ws>0)
+        if ($ws > 0)
         {
             $this->ws = 0;
             $this->_out('0 Tw');
         }
-        $this->AddPage($this->CurOrientation,$this->CurPageSize);
+        $this->AddPage($this->CurOrientation, $this->CurPageSize);
         $this->x = $x;
-        if($ws>0)
+        if ($ws > 0)
         {
             $this->ws = $ws;
-            $this->_out(sprintf('%.3F Tw',$ws*$k));
+            $this->_out(sprintf('%.3F Tw', $ws * $k));
         }
     }
-    if($w==0)
-        $w = $this->w-$this->rMargin-$this->x;
+    if ($w == 0)
+        $w = $this->w - $this->rMargin - $this->x;
     $s = '';
-    if($fill || $border==1)
+    if ($fill || $border == 1)
     {
-        if($fill)
-            $op = ($border==1) ? 'B' : 'f';
+        if ($fill)
+            $op = ($border == 1) ? 'B' : 'f';
         else
             $op = 'S';
-        $s = sprintf('%.2F %.2F %.2F %.2F re %s ',$this->x*$k,($this->h-$this->y)*$k,$w*$k,-$h*$k,$op);
+        $s = sprintf('%.2F %.2F %.2F %.2F re %s ', $this->x * $k, ($this->h - $this->y) * $k, $w * $k, -$h * $k, $op);
     }
-    if(is_string($border))
+    if (is_string($border))
     {
         $x = $this->x;
         $y = $this->y;
-        if(strpos($border,'L')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-$y)*$k,$x*$k,($this->h-($y+$h))*$k);
-        if(strpos($border,'T')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-$y)*$k);
-        if(strpos($border,'R')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',($x+$w)*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-($y+$h))*$k);
-        if(strpos($border,'B')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-($y+$h))*$k,($x+$w)*$k,($this->h-($y+$h))*$k);
-    }
-    if($txt!=='')
+        if (strpos($border, 'L') !== false)
+            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ', $x * $k, ($this->h - $y) * $k, $x * $k, ($this->h - ($y + $h)) * $k);
+        if (strpos($border, 'T') !== false)
+            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ', $x * $k, ($this->h - $y) * $k, ($x + $w) * $k, ($this->h - $y) * $k);
+        if (strpos($border, 'R') !== false)
+            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ', ($x + $w) * $k, ($this->h - $y) * $k, ($x + $w) * $k, ($this->h - ($y + $h)) * $k);
+        if (strpos($border, 'B') !== false)
+            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ', $x * $k, ($this->h - ($y + $h)) * $k, ($x + $w) * $k, ($this->h - ($y + $h)) * $k);
+    }
+    if ($txt !== '')
     {
-        if($align=='R')
-            $dx = $w-$this->cMargin-$this->GetStringWidth($txt);
-        elseif($align=='C')
-            $dx = ($w-$this->GetStringWidth($txt))/2;
+        if ($align == 'R')
+            $dx = $w - $this->cMargin - $this->GetStringWidth($txt);
+        elseif ($align == 'C')
+            $dx = ($w - $this->GetStringWidth($txt)) / 2;
         else
             $dx = $this->cMargin;
-        if($this->ColorFlag)
+        if ($this->ColorFlag)
             $s .= 'q '.$this->TextColor.' ';
 
         // If multibyte, Tw has no effect - do word spacing using an adjustment before each space
         if ($this->ws && $this->unifontSubset) {
-            foreach($this->UTF8StringToArray($txt) as $uni)
+            foreach ($this->UTF8StringToArray($txt) as $uni)
                 $this->CurrentFont['subset'][$uni] = $uni;
             $space = $this->_escape($this->UTF8ToUTF16BE(' ', false));
-            $s .= sprintf('BT 0 Tw %.2F %.2F Td [',($this->x+$dx)*$k,($this->h-($this->y+.5*$h+.3*$this->FontSize))*$k);
-            $t = explode(' ',$txt);
+            $s .= sprintf('BT 0 Tw %.2F %.2F Td [', ($this->x + $dx) * $k, ($this->h - ($this->y + .5 * $h + .3 * $this->FontSize)) * $k);
+            $t = explode(' ', $txt);
             $numt = count($t);
-            for($i=0;$i<$numt;$i++) {
+            for ($i = 0; $i < $numt; $i++) {
                 $tx = $t[$i];
                 $tx = '('.$this->_escape($this->UTF8ToUTF16BE($tx, false)).')';
-                $s .= sprintf('%s ',$tx);
-                if (($i+1)<$numt) {
-                    $adj = -($this->ws*$this->k)*1000/$this->FontSizePt;
-                    $s .= sprintf('%d(%s) ',$adj,$space);
+                $s .= sprintf('%s ', $tx);
+                if (($i + 1) < $numt) {
+                    $adj = -($this->ws * $this->k) * 1000 / $this->FontSizePt;
+                    $s .= sprintf('%d(%s) ', $adj, $space);
                 }
             }
             $s .= '] TJ';
@@ -777,55 +777,55 @@ 
             if ($this->unifontSubset)
             {
                 $txt2 = '('.$this->_escape($this->UTF8ToUTF16BE($txt, false)).')';
-                foreach($this->UTF8StringToArray($txt) as $uni)
+                foreach ($this->UTF8StringToArray($txt) as $uni)
                     $this->CurrentFont['subset'][$uni] = $uni;
             }
             else
-                $txt2='('.str_replace(')','\\)',str_replace('(','\\(',str_replace('\\','\\\\',$txt))).')';
-            $s .= sprintf('BT %.2F %.2F Td %s Tj ET',($this->x+$dx)*$k,($this->h-($this->y+.5*$h+.3*$this->FontSize))*$k,$txt2);
+                $txt2 = '('.str_replace(')', '\\)', str_replace('(', '\\(', str_replace('\\', '\\\\', $txt))).')';
+            $s .= sprintf('BT %.2F %.2F Td %s Tj ET', ($this->x + $dx) * $k, ($this->h - ($this->y + .5 * $h + .3 * $this->FontSize)) * $k, $txt2);
         }
-        if($this->underline)
-            $s .= ' '.$this->_dounderline($this->x+$dx,$this->y+.5*$h+.3*$this->FontSize,$txt);
-        if($this->ColorFlag)
+        if ($this->underline)
+            $s .= ' '.$this->_dounderline($this->x + $dx, $this->y + .5 * $h + .3 * $this->FontSize, $txt);
+        if ($this->ColorFlag)
             $s .= ' Q';
-        if($link)
-            $this->Link($this->x+$dx,$this->y+.5*$h-.5*$this->FontSize,$this->GetStringWidth($txt),$this->FontSize,$link);
+        if ($link)
+            $this->Link($this->x + $dx, $this->y + .5 * $h - .5 * $this->FontSize, $this->GetStringWidth($txt), $this->FontSize, $link);
     }
-    if($s)
+    if ($s)
         $this->_out($s);
     $this->lasth = $h;
-    if($ln>0)
+    if ($ln > 0)
     {
         // Go to next line
         $this->y += $h;
-        if($ln==1)
+        if ($ln == 1)
             $this->x = $this->lMargin;
     }
     else
         $this->x += $w;
 }
 
-function MultiCell($w, $h, $txt, $border=0, $align='J', $fill=false)
+function MultiCell($w, $h, $txt, $border = 0, $align = 'J', $fill = false)
 {
     // Output text with automatic or explicit line breaks
     $cw = &$this->CurrentFont['cw'];
-    if($w==0)
-        $w = $this->w-$this->rMargin-$this->x;
-    $wmax = ($w-2*$this->cMargin);
-    $s = str_replace("\r",'',$txt);
+    if ($w == 0)
+        $w = $this->w - $this->rMargin - $this->x;
+    $wmax = ($w - 2 * $this->cMargin);
+    $s = str_replace("\r", '', $txt);
     if ($this->unifontSubset) {
-        $nb=mb_strlen($s, 'utf-8');
-        while($nb>0 && mb_substr($s,$nb-1,1,'utf-8')=="\n") $nb--;
+        $nb = mb_strlen($s, 'utf-8');
+        while ($nb > 0 && mb_substr($s, $nb - 1, 1, 'utf-8') == "\n") $nb--;
     }
     else {
         $nb = strlen($s);
-        if($nb>0 && $s[$nb-1]=="\n")
+        if ($nb > 0 && $s[$nb - 1] == "\n")
             $nb--;
     }
     $b = 0;
-    if($border)
+    if ($border)
     {
-        if($border==1)
+        if ($border == 1)
         {
             $border = 'LTRB';
             $b = 'LRT';
@@ -834,11 +834,11 @@ 
         else
         {
             $b2 = '';
-            if(strpos($border,'L')!==false)
+            if (strpos($border, 'L') !== false)
                 $b2 .= 'L';
-            if(strpos($border,'R')!==false)
+            if (strpos($border, 'R') !== false)
                 $b2 .= 'R';
-            $b = (strpos($border,'T')!==false) ? $b2.'T' : $b2;
+            $b = (strpos($border, 'T') !== false) ? $b2.'T' : $b2;
         }
     }
     $sep = -1;
@@ -847,28 +847,28 @@ 
     $l = 0;
     $ns = 0;
     $nl = 1;
-    while($i<$nb)
+    while ($i < $nb)
     {
         // Get next character
         if ($this->unifontSubset) {
-            $c = mb_substr($s,$i,1,'UTF-8');
+            $c = mb_substr($s, $i, 1, 'UTF-8');
         }
         else {
-            $c=$s[$i];
+            $c = $s[$i];
         }
-        if($c=="\n")
+        if ($c == "\n")
         {
             // Explicit line break
-            if($this->ws>0)
+            if ($this->ws > 0)
             {
                 $this->ws = 0;
                 $this->_out('0 Tw');
             }
             if ($this->unifontSubset) {
-                $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),$b,2,$align,$fill);
+                $this->Cell($w, $h, mb_substr($s, $j, $i - $j, 'UTF-8'), $b, 2, $align, $fill);
             }
             else {
-                $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill);
+                $this->Cell($w, $h, substr($s, $j, $i - $j), $b, 2, $align, $fill);
             }
             $i++;
             $sep = -1;
@@ -876,11 +876,11 @@ 
             $l = 0;
             $ns = 0;
             $nl++;
-            if($border && $nl==2)
+            if ($border && $nl == 2)
                 $b = $b2;
             continue;
         }
-        if($c==' ')
+        if ($c == ' ')
         {
             $sep = $i;
             $ls = $l;
@@ -888,81 +888,81 @@ 
         }
 
         if ($this->unifontSubset) { $l += $this->GetStringWidth($c); }
-        else { $l += $cw[$c]*$this->FontSize/1000; }
+        else { $l += $cw[$c] * $this->FontSize / 1000; }
 
-        if($l>$wmax)
+        if ($l > $wmax)
         {
             // Automatic line break
-            if($sep==-1)
+            if ($sep == -1)
             {
-                if($i==$j)
+                if ($i == $j)
                     $i++;
-                if($this->ws>0)
+                if ($this->ws > 0)
                 {
                     $this->ws = 0;
                     $this->_out('0 Tw');
                 }
                 if ($this->unifontSubset) {
-                    $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),$b,2,$align,$fill);
+                    $this->Cell($w, $h, mb_substr($s, $j, $i - $j, 'UTF-8'), $b, 2, $align, $fill);
                 }
                 else {
-                    $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill);
+                    $this->Cell($w, $h, substr($s, $j, $i - $j), $b, 2, $align, $fill);
                 }
             }
             else
             {
-                if($align=='J')
+                if ($align == 'J')
                 {
-                    $this->ws = ($ns>1) ? ($wmax-$ls)/($ns-1) : 0;
-                    $this->_out(sprintf('%.3F Tw',$this->ws*$this->k));
+                    $this->ws = ($ns > 1) ? ($wmax - $ls) / ($ns - 1) : 0;
+                    $this->_out(sprintf('%.3F Tw', $this->ws * $this->k));
                 }
                 if ($this->unifontSubset) {
-                    $this->Cell($w,$h,mb_substr($s,$j,$sep-$j,'UTF-8'),$b,2,$align,$fill);
+                    $this->Cell($w, $h, mb_substr($s, $j, $sep - $j, 'UTF-8'), $b, 2, $align, $fill);
                 }
                 else {
-                    $this->Cell($w,$h,substr($s,$j,$sep-$j),$b,2,$align,$fill);
+                    $this->Cell($w, $h, substr($s, $j, $sep - $j), $b, 2, $align, $fill);
                 }
-                $i = $sep+1;
+                $i = $sep + 1;
             }
             $sep = -1;
             $j = $i;
             $l = 0;
             $ns = 0;
             $nl++;
-            if($border && $nl==2)
+            if ($border && $nl == 2)
                 $b = $b2;
         }
         else
             $i++;
     }
     // Last chunk
-    if($this->ws>0)
+    if ($this->ws > 0)
     {
         $this->ws = 0;
         $this->_out('0 Tw');
     }
-    if($border && strpos($border,'B')!==false)
+    if ($border && strpos($border, 'B') !== false)
         $b .= 'B';
     if ($this->unifontSubset) {
-        $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),$b,2,$align,$fill);
+        $this->Cell($w, $h, mb_substr($s, $j, $i - $j, 'UTF-8'), $b, 2, $align, $fill);
     }
     else {
-        $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill);
+        $this->Cell($w, $h, substr($s, $j, $i - $j), $b, 2, $align, $fill);
     }
     $this->x = $this->lMargin;
 }
 
-function Write($h, $txt, $link='')
+function Write($h, $txt, $link = '')
 {
     // Output text in flowing mode
     $cw = &$this->CurrentFont['cw'];
-    $w = $this->w-$this->rMargin-$this->x;
+    $w = $this->w - $this->rMargin - $this->x;
 
-    $wmax = ($w-2*$this->cMargin);
-    $s = str_replace("\r",'',$txt);
+    $wmax = ($w - 2 * $this->cMargin);
+    $s = str_replace("\r", '', $txt);
     if ($this->unifontSubset) {
         $nb = mb_strlen($s, 'UTF-8');
-        if($nb==1 && $s==" ") {
+        if ($nb == 1 && $s == " ") {
             $this->x += $this->GetStringWidth($s);
             return;
         }
@@ -975,86 +975,86 @@ 
     $j = 0;
     $l = 0;
     $nl = 1;
-    while($i<$nb)
+    while ($i < $nb)
     {
         // Get next character
         if ($this->unifontSubset) {
-            $c = mb_substr($s,$i,1,'UTF-8');
+            $c = mb_substr($s, $i, 1, 'UTF-8');
         }
         else {
             $c = $s[$i];
         }
-        if($c=="\n")
+        if ($c == "\n")
         {
             // Explicit line break
             if ($this->unifontSubset) {
-                $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),0,2,'',0,$link);
+                $this->Cell($w, $h, mb_substr($s, $j, $i - $j, 'UTF-8'), 0, 2, '', 0, $link);
             }
             else {
-                $this->Cell($w,$h,substr($s,$j,$i-$j),0,2,'',0,$link);
+                $this->Cell($w, $h, substr($s, $j, $i - $j), 0, 2, '', 0, $link);
             }
             $i++;
             $sep = -1;
             $j = $i;
             $l = 0;
-            if($nl==1)
+            if ($nl == 1)
             {
                 $this->x = $this->lMargin;
-                $w = $this->w-$this->rMargin-$this->x;
-                $wmax = ($w-2*$this->cMargin);
+                $w = $this->w - $this->rMargin - $this->x;
+                $wmax = ($w - 2 * $this->cMargin);
             }
             $nl++;
             continue;
         }
-        if($c==' ')
+        if ($c == ' ')
             $sep = $i;
 
         if ($this->unifontSubset) { $l += $this->GetStringWidth($c); }
-        else { $l += $cw[$c]*$this->FontSize/1000; }
+        else { $l += $cw[$c] * $this->FontSize / 1000; }
 
-        if($l>$wmax)
+        if ($l > $wmax)
         {
             // Automatic line break
-            if($sep==-1)
+            if ($sep == -1)
             {
-                if($this->x>$this->lMargin)
+                if ($this->x > $this->lMargin)
                 {
                     // Move to next line
                     $this->x = $this->lMargin;
                     $this->y += $h;
-                    $w = $this->w-$this->rMargin-$this->x;
-                    $wmax = ($w-2*$this->cMargin);
+                    $w = $this->w - $this->rMargin - $this->x;
+                    $wmax = ($w - 2 * $this->cMargin);
                     $i++;
                     $nl++;
                     continue;
                 }
-                if($i==$j)
+                if ($i == $j)
                     $i++;
                 if ($this->unifontSubset) {
-                    $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),0,2,'',0,$link);
+                    $this->Cell($w, $h, mb_substr($s, $j, $i - $j, 'UTF-8'), 0, 2, '', 0, $link);
                 }
                 else {
-                    $this->Cell($w,$h,substr($s,$j,$i-$j),0,2,'',0,$link);
+                    $this->Cell($w, $h, substr($s, $j, $i - $j), 0, 2, '', 0, $link);
                 }
             }
             else
             {
                 if ($this->unifontSubset) {
-                    $this->Cell($w,$h,mb_substr($s,$j,$sep-$j,'UTF-8'),0,2,'',0,$link);
+                    $this->Cell($w, $h, mb_substr($s, $j, $sep - $j, 'UTF-8'), 0, 2, '', 0, $link);
                 }
                 else {
-                    $this->Cell($w,$h,substr($s,$j,$sep-$j),0,2,'',0,$link);
+                    $this->Cell($w, $h, substr($s, $j, $sep - $j), 0, 2, '', 0, $link);
                 }
-                $i = $sep+1;
+                $i = $sep + 1;
             }
             $sep = -1;
             $j = $i;
             $l = 0;
-            if($nl==1)
+            if ($nl == 1)
             {
                 $this->x = $this->lMargin;
-                $w = $this->w-$this->rMargin-$this->x;
-                $wmax = ($w-2*$this->cMargin);
+                $w = $this->w - $this->rMargin - $this->x;
+                $wmax = ($w - 2 * $this->cMargin);
             }
             $nl++;
         }
@@ -1062,87 +1062,87 @@ 
             $i++;
     }
     // Last chunk
-    if($i!=$j) {
+    if ($i != $j) {
         if ($this->unifontSubset) {
-            $this->Cell($l,$h,mb_substr($s,$j,$i-$j,'UTF-8'),0,0,'',0,$link);
+            $this->Cell($l, $h, mb_substr($s, $j, $i - $j, 'UTF-8'), 0, 0, '', 0, $link);
         }
         else {
-            $this->Cell($l,$h,substr($s,$j),0,0,'',0,$link);
+            $this->Cell($l, $h, substr($s, $j), 0, 0, '', 0, $link);
         }
     }
 }
 
-function Ln($h=null)
+function Ln($h = null)
 {
     // Line feed; default value is last cell height
     $this->x = $this->lMargin;
-    if($h===null)
+    if ($h === null)
         $this->y += $this->lasth;
     else
         $this->y += $h;
 }
 
-function Image($file, $x=null, $y=null, $w=0, $h=0, $type='', $link='')
+function Image($file, $x = null, $y = null, $w = 0, $h = 0, $type = '', $link = '')
 {
     // Put an image on the page
-    if(!isset($this->images[$file]))
+    if (!isset($this->images[$file]))
     {
         // First use of this image, get info
-        if($type=='')
+        if ($type == '')
         {
-            $pos = strrpos($file,'.');
-            if(!$pos)
+            $pos = strrpos($file, '.');
+            if (!$pos)
                 $this->Error('Image file has no extension and no type was specified: '.$file);
-            $type = substr($file,$pos+1);
+            $type = substr($file, $pos + 1);
         }
         $type = strtolower($type);
-        if($type=='jpeg')
+        if ($type == 'jpeg')
             $type = 'jpg';
         $mtd = '_parse'.$type;
-        if(!method_exists($this,$mtd))
+        if (!method_exists($this, $mtd))
             $this->Error('Unsupported image type: '.$type);
         $info = $this->$mtd($file);
-        $info['i'] = count($this->images)+1;
+        $info['i'] = count($this->images) + 1;
         $this->images[$file] = $info;
     }
     else
         $info = $this->images[$file];
 
     // Automatic width and height calculation if needed
-    if($w==0 && $h==0)
+    if ($w == 0 && $h == 0)
     {
         // Put image at 96 dpi
         $w = -96;
         $h = -96;
     }
-    if($w<0)
-        $w = -$info['w']*72/$w/$this->k;
-    if($h<0)
-        $h = -$info['h']*72/$h/$this->k;
-    if($w==0)
-        $w = $h*$info['w']/$info['h'];
-    if($h==0)
-        $h = $w*$info['h']/$info['w'];
+    if ($w < 0)
+        $w = -$info['w'] * 72 / $w / $this->k;
+    if ($h < 0)
+        $h = -$info['h'] * 72 / $h / $this->k;
+    if ($w == 0)
+        $w = $h * $info['w'] / $info['h'];
+    if ($h == 0)
+        $h = $w * $info['h'] / $info['w'];
 
     // Flowing mode
-    if($y===null)
+    if ($y === null)
     {
-        if($this->y+$h>$this->PageBreakTrigger && !$this->InHeader && !$this->InFooter && $this->AcceptPageBreak())
+        if ($this->y + $h > $this->PageBreakTrigger && !$this->InHeader && !$this->InFooter && $this->AcceptPageBreak())
         {
             // Automatic page break
             $x2 = $this->x;
-            $this->AddPage($this->CurOrientation,$this->CurPageSize);
+            $this->AddPage($this->CurOrientation, $this->CurPageSize);
             $this->x = $x2;
         }
         $y = $this->y;
         $this->y += $h;
     }
 
-    if($x===null)
+    if ($x === null)
         $x = $this->x;
-    $this->_out(sprintf('q %.2F 0 0 %.2F %.2F %.2F cm /I%d Do Q',$w*$this->k,$h*$this->k,$x*$this->k,($this->h-($y+$h))*$this->k,$info['i']));
-    if($link)
-        $this->Link($x,$y,$w,$h,$link);
+    $this->_out(sprintf('q %.2F 0 0 %.2F %.2F %.2F cm /I%d Do Q', $w * $this->k, $h * $this->k, $x * $this->k, ($this->h - ($y + $h)) * $this->k, $info['i']));
+    if ($link)
+        $this->Link($x, $y, $w, $h, $link);
 }
 
 function GetX()
@@ -1154,10 +1154,10 @@ 
 function SetX($x)
 {
     // Set x position
-    if($x>=0)
+    if ($x >= 0)
         $this->x = $x;
     else
-        $this->x = $this->w+$x;
+        $this->x = $this->w + $x;
 }
 
 function GetY()
@@ -1170,10 +1170,10 @@ 
 {
     // Set y position and reset x
     $this->x = $this->lMargin;
-    if($y>=0)
+    if ($y >= 0)
         $this->y = $y;
     else
-        $this->y = $this->h+$y;
+        $this->y = $this->h + $y;
 }
 
 function SetXY($x, $y)
@@ -1183,15 +1183,15 @@ 
     $this->SetX($x);
 }
 
-function Output($name='', $dest='')
+function Output($name = '', $dest = '')
 {
     // Output PDF to some destination
-    if($this->state<3)
+    if ($this->state < 3)
         $this->Close();
     $dest = strtoupper($dest);
-    if($dest=='')
+    if ($dest == '')
     {
-        if($name=='')
+        if ($name == '')
         {
             $name = 'doc.pdf';
             $dest = 'I';
@@ -1199,12 +1199,12 @@ 
         else
             $dest = 'F';
     }
-    switch($dest)
+    switch ($dest)
     {
         case 'I':
             // Send to standard output
             $this->_checkoutput();
-            if(PHP_SAPI!='cli')
+            if (PHP_SAPI != 'cli')
             {
                 // We send to a browser
                 header('Content-Type: application/pdf');
@@ -1225,10 +1225,10 @@ 
             break;
         case 'F':
             // Save to local file
-            $f = fopen($name,'wb');
-            if(!$f)
+            $f = fopen($name, 'wb');
+            if (!$f)
                 $this->Error('Unable to create output file: '.$name);
-            fwrite($f,$this->buffer,strlen($this->buffer));
+            fwrite($f, $this->buffer, strlen($this->buffer));
             fclose($f);
             break;
         case 'S':
@@ -1248,16 +1248,16 @@ 
 function _dochecks()
 {
     // Check availability of %F
-    if(sprintf('%.1F',1.0)!='1.0')
+    if (sprintf('%.1F', 1.0) != '1.0')
         $this->Error('This version of PHP is not supported');
     // Check availability of mbstring
-    if(!function_exists('mb_strlen'))
+    if (!function_exists('mb_strlen'))
         $this->Error('mbstring extension is not available');
     // Check mbstring overloading
-    if(ini_get('mbstring.func_overload') & 2)
+    if (ini_get('mbstring.func_overload') & 2)
         $this->Error('mbstring overloading must be disabled');
     // Ensure runtime magic quotes are disabled
-    if(get_magic_quotes_runtime())
+    if (get_magic_quotes_runtime())
         @set_magic_quotes_runtime(0);
 }
 
@@ -1268,15 +1268,15 @@ 
 
 function _checkoutput()
 {
-    if(PHP_SAPI!='cli')
+    if (PHP_SAPI != 'cli')
     {
-        if(headers_sent($file,$line))
+        if (headers_sent($file, $line))
             $this->Error("Some data has already been output, can't send PDF file (output started at $file:$line)");
     }
-    if(ob_get_length())
+    if (ob_get_length())
     {
         // The output buffer is not empty
-        if(preg_match('/^(\xEF\xBB\xBF)?\s*$/',ob_get_contents()))
+        if (preg_match('/^(\xEF\xBB\xBF)?\s*$/', ob_get_contents()))
         {
             // It contains only a UTF-8 BOM and/or whitespace, let's clean it
             ob_clean();
@@ -1288,17 +1288,17 @@ 
 
 function _getpagesize($size)
 {
-    if(is_string($size))
+    if (is_string($size))
     {
         $size = strtolower($size);
-        if(!isset($this->StdPageSizes[$size]))
+        if (!isset($this->StdPageSizes[$size]))
             $this->Error('Unknown page size: '.$size);
         $a = $this->StdPageSizes[$size];
-        return array($a[0]/$this->k, $a[1]/$this->k);
+        return array($a[0] / $this->k, $a[1] / $this->k);
     }
     else
     {
-        if($size[0]>$size[1])
+        if ($size[0] > $size[1])
             return array($size[1], $size[0]);
         else
             return $size;
@@ -1314,18 +1314,18 @@ 
     $this->y = $this->tMargin;
     $this->FontFamily = '';
     // Check page size and orientation
-    if($orientation=='')
+    if ($orientation == '')
         $orientation = $this->DefOrientation;
     else
         $orientation = strtoupper($orientation[0]);
-    if($size=='')
+    if ($size == '')
         $size = $this->DefPageSize;
     else
         $size = $this->_getpagesize($size);
-    if($orientation!=$this->CurOrientation || $size[0]!=$this->CurPageSize[0] || $size[1]!=$this->CurPageSize[1])
+    if ($orientation != $this->CurOrientation || $size[0] != $this->CurPageSize[0] || $size[1] != $this->CurPageSize[1])
     {
         // New size or orientation
-        if($orientation=='P')
+        if ($orientation == 'P')
         {
             $this->w = $size[0];
             $this->h = $size[1];
@@ -1335,13 +1335,13 @@ 
             $this->w = $size[1];
             $this->h = $size[0];
         }
-        $this->wPt = $this->w*$this->k;
-        $this->hPt = $this->h*$this->k;
-        $this->PageBreakTrigger = $this->h-$this->bMargin;
+        $this->wPt = $this->w * $this->k;
+        $this->hPt = $this->h * $this->k;
+        $this->PageBreakTrigger = $this->h - $this->bMargin;
         $this->CurOrientation = $orientation;
         $this->CurPageSize = $size;
     }
-    if($orientation!=$this->DefOrientation || $size[0]!=$this->DefPageSize[0] || $size[1]!=$this->DefPageSize[1])
+    if ($orientation != $this->DefOrientation || $size[0] != $this->DefPageSize[0] || $size[1] != $this->DefPageSize[1])
         $this->PageSizes[$this->page] = array($this->wPt, $this->hPt);
 }
 
@@ -1355,7 +1355,7 @@ 
     // Load a font definition file from the font directory
     include($this->fontpath.$font);
     $a = get_defined_vars();
-    if(!isset($a['name']))
+    if (!isset($a['name']))
         $this->Error('Could not include font definition file');
     return $a;
 }
@@ -1363,10 +1363,10 @@ 
 function _escape($s)
 {
     // Escape special characters in strings
-    $s = str_replace('\\','\\\\',$s);
-    $s = str_replace('(','\\(',$s);
-    $s = str_replace(')','\\)',$s);
-    $s = str_replace("\r",'\\r',$s);
+    $s = str_replace('\\', '\\\\', $s);
+    $s = str_replace('(', '\\(', $s);
+    $s = str_replace(')', '\\)', $s);
+    $s = str_replace("\r", '\\r', $s);
     return $s;
 }
 
@@ -1382,23 +1382,23 @@ 
     $res = "\xFE\xFF";
     $nb = strlen($s);
     $i = 0;
-    while($i<$nb)
+    while ($i < $nb)
     {
         $c1 = ord($s[$i++]);
-        if($c1>=224)
+        if ($c1 >= 224)
         {
             // 3-byte character
             $c2 = ord($s[$i++]);
             $c3 = ord($s[$i++]);
-            $res .= chr((($c1 & 0x0F)<<4) + (($c2 & 0x3C)>>2));
-            $res .= chr((($c2 & 0x03)<<6) + ($c3 & 0x3F));
+            $res .= chr((($c1 & 0x0F) << 4) + (($c2 & 0x3C) >> 2));
+            $res .= chr((($c2 & 0x03) << 6) + ($c3 & 0x3F));
         }
-        elseif($c1>=192)
+        elseif ($c1 >= 192)
         {
             // 2-byte character
             $c2 = ord($s[$i++]);
-            $res .= chr(($c1 & 0x1C)>>2);
-            $res .= chr((($c1 & 0x03)<<6) + ($c2 & 0x3F));
+            $res .= chr(($c1 & 0x1C) >> 2);
+            $res .= chr((($c1 & 0x03) << 6) + ($c2 & 0x3F));
         }
         else
         {
@@ -1414,21 +1414,21 @@ 
     // Underline text
     $up = $this->CurrentFont['up'];
     $ut = $this->CurrentFont['ut'];
-    $w = $this->GetStringWidth($txt)+$this->ws*substr_count($txt,' ');
-    return sprintf('%.2F %.2F %.2F %.2F re f',$x*$this->k,($this->h-($y-$up/1000*$this->FontSize))*$this->k,$w*$this->k,-$ut/1000*$this->FontSizePt);
+    $w = $this->GetStringWidth($txt) + $this->ws * substr_count($txt, ' ');
+    return sprintf('%.2F %.2F %.2F %.2F re f', $x * $this->k, ($this->h - ($y - $up / 1000 * $this->FontSize)) * $this->k, $w * $this->k, -$ut / 1000 * $this->FontSizePt);
 }
 
 function _parsejpg($file)
 {
     // Extract info from a JPEG file
     $a = getimagesize($file);
-    if(!$a)
+    if (!$a)
         $this->Error('Missing or incorrect image file: '.$file);
-    if($a[2]!=2)
+    if ($a[2] != 2)
         $this->Error('Not a JPEG file: '.$file);
-    if(!isset($a['channels']) || $a['channels']==3)
+    if (!isset($a['channels']) || $a['channels'] == 3)
         $colspace = 'DeviceRGB';
-    elseif($a['channels']==4)
+    elseif ($a['channels'] == 4)
         $colspace = 'DeviceCMYK';
     else
         $colspace = 'DeviceGray';
@@ -1440,10 +1440,10 @@ 
 function _parsepng($file)
 {
     // Extract info from a PNG file
-    $f = fopen($file,'rb');
-    if(!$f)
+    $f = fopen($file, 'rb');
+    if (!$f)
         $this->Error('Can\'t open image file: '.$file);
-    $info = $this->_parsepngstream($f,$file);
+    $info = $this->_parsepngstream($f, $file);
     fclose($f);
     return $info;
 }
@@ -1451,35 +1451,35 @@ 
 function _parsepngstream($f, $file)
 {
     // Check signature
-    if($this->_readstream($f,8)!=chr(137).'PNG'.chr(13).chr(10).chr(26).chr(10))
+    if ($this->_readstream($f, 8) != chr(137).'PNG'.chr(13).chr(10).chr(26).chr(10))
         $this->Error('Not a PNG file: '.$file);
 
     // Read header chunk
-    $this->_readstream($f,4);
-    if($this->_readstream($f,4)!='IHDR')
+    $this->_readstream($f, 4);
+    if ($this->_readstream($f, 4) != 'IHDR')
         $this->Error('Incorrect PNG file: '.$file);
     $w = $this->_readint($f);
     $h = $this->_readint($f);
-    $bpc = ord($this->_readstream($f,1));
-    if($bpc>8)
+    $bpc = ord($this->_readstream($f, 1));
+    if ($bpc > 8)
         $this->Error('16-bit depth not supported: '.$file);
-    $ct = ord($this->_readstream($f,1));
-    if($ct==0 || $ct==4)
+    $ct = ord($this->_readstream($f, 1));
+    if ($ct == 0 || $ct == 4)
         $colspace = 'DeviceGray';
-    elseif($ct==2 || $ct==6)
+    elseif ($ct == 2 || $ct == 6)
         $colspace = 'DeviceRGB';
-    elseif($ct==3)
+    elseif ($ct == 3)
         $colspace = 'Indexed';
     else
         $this->Error('Unknown color type: '.$file);
-    if(ord($this->_readstream($f,1))!=0)
+    if (ord($this->_readstream($f, 1)) != 0)
         $this->Error('Unknown compression method: '.$file);
-    if(ord($this->_readstream($f,1))!=0)
+    if (ord($this->_readstream($f, 1)) != 0)
         $this->Error('Unknown filter method: '.$file);
-    if(ord($this->_readstream($f,1))!=0)
+    if (ord($this->_readstream($f, 1)) != 0)
         $this->Error('Interlacing not supported: '.$file);
-    $this->_readstream($f,4);
-    $dp = '/Predictor 15 /Colors '.($colspace=='DeviceRGB' ? 3 : 1).' /BitsPerComponent '.$bpc.' /Columns '.$w;
+    $this->_readstream($f, 4);
+    $dp = '/Predictor 15 /Colors '.($colspace == 'DeviceRGB' ? 3 : 1).' /BitsPerComponent '.$bpc.' /Columns '.$w;
 
     // Scan chunks looking for palette, transparency and image data
     $pal = '';
@@ -1488,85 +1488,85 @@ 
     do
     {
         $n = $this->_readint($f);
-        $type = $this->_readstream($f,4);
-        if($type=='PLTE')
+        $type = $this->_readstream($f, 4);
+        if ($type == 'PLTE')
         {
             // Read palette
-            $pal = $this->_readstream($f,$n);
-            $this->_readstream($f,4);
+            $pal = $this->_readstream($f, $n);
+            $this->_readstream($f, 4);
         }
-        elseif($type=='tRNS')
+        elseif ($type == 'tRNS')
         {
             // Read transparency info
-            $t = $this->_readstream($f,$n);
-            if($ct==0)
-                $trns = array(ord(substr($t,1,1)));
-            elseif($ct==2)
-                $trns = array(ord(substr($t,1,1)), ord(substr($t,3,1)), ord(substr($t,5,1)));
+            $t = $this->_readstream($f, $n);
+            if ($ct == 0)
+                $trns = array(ord(substr($t, 1, 1)));
+            elseif ($ct == 2)
+                $trns = array(ord(substr($t, 1, 1)), ord(substr($t, 3, 1)), ord(substr($t, 5, 1)));
             else
             {
-                $pos = strpos($t,chr(0));
-                if($pos!==false)
+                $pos = strpos($t, chr(0));
+                if ($pos !== false)
                     $trns = array($pos);
             }
-            $this->_readstream($f,4);
+            $this->_readstream($f, 4);
         }
-        elseif($type=='IDAT')
+        elseif ($type == 'IDAT')
         {
             // Read image data block
-            $data .= $this->_readstream($f,$n);
-            $this->_readstream($f,4);
+            $data .= $this->_readstream($f, $n);
+            $this->_readstream($f, 4);
         }
-        elseif($type=='IEND')
+        elseif ($type == 'IEND')
             break;
         else
-            $this->_readstream($f,$n+4);
+            $this->_readstream($f, $n + 4);
     }
-    while($n);
+    while ($n);
 
-    if($colspace=='Indexed' && empty($pal))
+    if ($colspace == 'Indexed' && empty($pal))
         $this->Error('Missing palette in '.$file);
     $info = array('w'=>$w, 'h'=>$h, 'cs'=>$colspace, 'bpc'=>$bpc, 'f'=>'FlateDecode', 'dp'=>$dp, 'pal'=>$pal, 'trns'=>$trns);
-    if($ct>=4)
+    if ($ct >= 4)
     {
         // Extract alpha channel
-        if(!function_exists('gzuncompress'))
+        if (!function_exists('gzuncompress'))
             $this->Error('Zlib not available, can\'t handle alpha channel: '.$file);
         $data = gzuncompress($data);
         $color = '';
         $alpha = '';
-        if($ct==4)
+        if ($ct == 4)
         {
             // Gray image
-            $len = 2*$w;
-            for($i=0;$i<$h;$i++)
+            $len = 2 * $w;
+            for ($i = 0; $i < $h; $i++)
             {
-                $pos = (1+$len)*$i;
+                $pos = (1 + $len) * $i;
                 $color .= $data[$pos];
                 $alpha .= $data[$pos];
-                $line = substr($data,$pos+1,$len);
-                $color .= preg_replace('/(.)./s','$1',$line);
-                $alpha .= preg_replace('/.(.)/s','$1',$line);
+                $line = substr($data, $pos + 1, $len);
+                $color .= preg_replace('/(.)./s', '$1', $line);
+                $alpha .= preg_replace('/.(.)/s', '$1', $line);
             }
         }
         else
         {
             // RGB image
-            $len = 4*$w;
-            for($i=0;$i<$h;$i++)
+            $len = 4 * $w;
+            for ($i = 0; $i < $h; $i++)
             {
-                $pos = (1+$len)*$i;
+                $pos = (1 + $len) * $i;
                 $color .= $data[$pos];
                 $alpha .= $data[$pos];
-                $line = substr($data,$pos+1,$len);
-                $color .= preg_replace('/(.{3})./s','$1',$line);
-                $alpha .= preg_replace('/.{3}(.)/s','$1',$line);
+                $line = substr($data, $pos + 1, $len);
+                $color .= preg_replace('/(.{3})./s', '$1', $line);
+                $alpha .= preg_replace('/.{3}(.)/s', '$1', $line);
             }
         }
         unset($data);
         $data = gzcompress($color);
         $info['smask'] = gzcompress($alpha);
-        if($this->PDFVersion<'1.4')
+        if ($this->PDFVersion < '1.4')
             $this->PDFVersion = '1.4';
     }
     $info['data'] = $data;
@@ -1577,15 +1577,15 @@ 
 {
     // Read n bytes from stream
     $res = '';
-    while($n>0 && !feof($f))
+    while ($n > 0 && !feof($f))
     {
-        $s = fread($f,$n);
-        if($s===false)
+        $s = fread($f, $n);
+        if ($s === false)
             $this->Error('Error while reading stream');
         $n -= strlen($s);
         $res .= $s;
     }
-    if($n>0)
+    if ($n > 0)
         $this->Error('Unexpected end of stream');
     return $res;
 }
@@ -1593,41 +1593,41 @@ 
 function _readint($f)
 {
     // Read a 4-byte integer from stream
-    $a = unpack('Ni',$this->_readstream($f,4));
+    $a = unpack('Ni', $this->_readstream($f, 4));
     return $a['i'];
 }
 
 function _parsegif($file)
 {
     // Extract info from a GIF file (via PNG conversion)
-    if(!function_exists('imagepng'))
+    if (!function_exists('imagepng'))
         $this->Error('GD extension is required for GIF support');
-    if(!function_exists('imagecreatefromgif'))
+    if (!function_exists('imagecreatefromgif'))
         $this->Error('GD has no GIF read support');
     $im = imagecreatefromgif($file);
-    if(!$im)
+    if (!$im)
         $this->Error('Missing or incorrect image file: '.$file);
-    imageinterlace($im,0);
-    $f = @fopen('php://temp','rb+');
-    if($f)
+    imageinterlace($im, 0);
+    $f = @fopen('php://temp', 'rb+');
+    if ($f)
     {
         // Perform conversion in memory
         ob_start();
         imagepng($im);
         $data = ob_get_clean();
         imagedestroy($im);
-        fwrite($f,$data);
+        fwrite($f, $data);
         rewind($f);
-        $info = $this->_parsepngstream($f,$file);
+        $info = $this->_parsepngstream($f, $file);
         fclose($f);
     }
     else
     {
         // Use temporary file
-        $tmp = tempnam('.','gif');
-        if(!$tmp)
+        $tmp = tempnam('.', 'gif');
+        if (!$tmp)
             $this->Error('Unable to create a temporary file');
-        if(!imagepng($im,$tmp))
+        if (!imagepng($im, $tmp))
             $this->Error('Error while saving to temporary file');
         imagedestroy($im);
         $info = $this->_parsepng($tmp);
@@ -1654,7 +1654,7 @@ 
 function _out($s)
 {
     // Add a line to the document
-    if($this->state==2)
+    if ($this->state == 2)
         $this->pages[$this->page] .= $s."\n";
     else
         $this->buffer .= $s."\n";
@@ -1663,59 +1663,59 @@ 
 function _putpages()
 {
     $nb = $this->page;
-    if(!empty($this->AliasNbPages))
+    if (!empty($this->AliasNbPages))
     {
         // Replace number of pages in fonts using subsets
         $alias = $this->UTF8ToUTF16BE($this->AliasNbPages, false);
         $r = $this->UTF8ToUTF16BE("$nb", false);
-        for($n=1;$n<=$nb;$n++)
-            $this->pages[$n] = str_replace($alias,$r,$this->pages[$n]);
+        for ($n = 1; $n <= $nb; $n++)
+            $this->pages[$n] = str_replace($alias, $r, $this->pages[$n]);
         // Now repeat for no pages in non-subset fonts
-        for($n=1;$n<=$nb;$n++)
-            $this->pages[$n] = str_replace($this->AliasNbPages,$nb,$this->pages[$n]);
+        for ($n = 1; $n <= $nb; $n++)
+            $this->pages[$n] = str_replace($this->AliasNbPages, $nb, $this->pages[$n]);
     }
-    if($this->DefOrientation=='P')
+    if ($this->DefOrientation == 'P')
     {
-        $wPt = $this->DefPageSize[0]*$this->k;
-        $hPt = $this->DefPageSize[1]*$this->k;
+        $wPt = $this->DefPageSize[0] * $this->k;
+        $hPt = $this->DefPageSize[1] * $this->k;
     }
     else
     {
-        $wPt = $this->DefPageSize[1]*$this->k;
-        $hPt = $this->DefPageSize[0]*$this->k;
+        $wPt = $this->DefPageSize[1] * $this->k;
+        $hPt = $this->DefPageSize[0] * $this->k;
     }
     $filter = ($this->compress) ? '/Filter /FlateDecode ' : '';
-    for($n=1;$n<=$nb;$n++)
+    for ($n = 1; $n <= $nb; $n++)
     {
         // Page
         $this->_newobj();
         $this->_out('<</Type /Page');
         $this->_out('/Parent 1 0 R');
-        if(isset($this->PageSizes[$n]))
-            $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]',$this->PageSizes[$n][0],$this->PageSizes[$n][1]));
+        if (isset($this->PageSizes[$n]))
+            $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]', $this->PageSizes[$n][0], $this->PageSizes[$n][1]));
         $this->_out('/Resources 2 0 R');
-        if(isset($this->PageLinks[$n]))
+        if (isset($this->PageLinks[$n]))
         {
             // Links
             $annots = '/Annots [';
-            foreach($this->PageLinks[$n] as $pl)
+            foreach ($this->PageLinks[$n] as $pl)
             {
-                $rect = sprintf('%.2F %.2F %.2F %.2F',$pl[0],$pl[1],$pl[0]+$pl[2],$pl[1]-$pl[3]);
+                $rect = sprintf('%.2F %.2F %.2F %.2F', $pl[0], $pl[1], $pl[0] + $pl[2], $pl[1] - $pl[3]);
                 $annots .= '<</Type /Annot /Subtype /Link /Rect ['.$rect.'] /Border [0 0 0] ';
-                if(is_string($pl[4]))
+                if (is_string($pl[4]))
                     $annots .= '/A <</S /URI /URI '.$this->_textstring($pl[4]).'>>>>';
                 else
                 {
                     $l = $this->links[$pl[4]];
                     $h = isset($this->PageSizes[$l[0]]) ? $this->PageSizes[$l[0]][1] : $hPt;
-                    $annots .= sprintf('/Dest [%d 0 R /XYZ 0 %.2F null]>>',1+2*$l[0],$h-$l[1]*$this->k);
+                    $annots .= sprintf('/Dest [%d 0 R /XYZ 0 %.2F null]>>', 1 + 2 * $l[0], $h - $l[1] * $this->k);
                 }
             }
             $this->_out($annots.']');
         }
-        if($this->PDFVersion>'1.3')
+        if ($this->PDFVersion > '1.3')
             $this->_out('/Group <</Type /Group /S /Transparency /CS /DeviceRGB>>');
-        $this->_out('/Contents '.($this->n+1).' 0 R>>');
+        $this->_out('/Contents '.($this->n + 1).' 0 R>>');
         $this->_out('endobj');
         // Page content
         $p = ($this->compress) ? gzcompress($this->pages[$n]) : $this->pages[$n];
@@ -1729,98 +1729,98 @@ 
     $this->_out('1 0 obj');
     $this->_out('<</Type /Pages');
     $kids = '/Kids [';
-    for($i=0;$i<$nb;$i++)
-        $kids .= (3+2*$i).' 0 R ';
+    for ($i = 0; $i < $nb; $i++)
+        $kids .= (3 + 2 * $i).' 0 R ';
     $this->_out($kids.']');
     $this->_out('/Count '.$nb);
-    $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]',$wPt,$hPt));
+    $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]', $wPt, $hPt));
     $this->_out('>>');
     $this->_out('endobj');
 }
 
 function _putfonts()
 {
-    $nf=$this->n;
-    foreach($this->diffs as $diff)
+    $nf = $this->n;
+    foreach ($this->diffs as $diff)
     {
         // Encodings
         $this->_newobj();
         $this->_out('<</Type /Encoding /BaseEncoding /WinAnsiEncoding /Differences ['.$diff.']>>');
         $this->_out('endobj');
     }
-    foreach($this->FontFiles as $file=>$info)
+    foreach ($this->FontFiles as $file=>$info)
     {
-       if (!isset($info['type']) || $info['type']!='TTF') {
+       if (!isset($info['type']) || $info['type'] != 'TTF') {
         // Font file embedding
         $this->_newobj();
-        $this->FontFiles[$file]['n']=$this->n;
-        $font='';
-        $f=fopen($this->_getfontpath().$file,'rb',1);
-        if(!$f)
+        $this->FontFiles[$file]['n'] = $this->n;
+        $font = '';
+        $f = fopen($this->_getfontpath().$file, 'rb', 1);
+        if (!$f)
             $this->Error('Font file not found');
-        while(!feof($f))
-            $font.=fread($f,8192);
+        while (!feof($f))
+            $font .= fread($f, 8192);
         fclose($f);
-        $compressed=(substr($file,-2)=='.z');
-        if(!$compressed && isset($info['length2']))
+        $compressed = (substr($file, -2) == '.z');
+        if (!$compressed && isset($info['length2']))
         {
-            $header=(ord($font[0])==128);
-            if($header)
+            $header = (ord($font[0]) == 128);
+            if ($header)
             {
                 // Strip first binary header
-                $font=substr($font,6);
+                $font = substr($font, 6);
             }
-            if($header && ord($font[$info['length1']])==128)
+            if ($header && ord($font[$info['length1']]) == 128)
             {
                 // Strip second binary header
-                $font=substr($font,0,$info['length1']).substr($font,$info['length1']+6);
+                $font = substr($font, 0, $info['length1']).substr($font, $info['length1'] + 6);
             }
         }
         $this->_out('<</Length '.strlen($font));
-        if($compressed)
+        if ($compressed)
             $this->_out('/Filter /FlateDecode');
         $this->_out('/Length1 '.$info['length1']);
-        if(isset($info['length2']))
+        if (isset($info['length2']))
             $this->_out('/Length2 '.$info['length2'].' /Length3 0');
         $this->_out('>>');
         $this->_putstream($font);
         $this->_out('endobj');
        }
     }
-    foreach($this->fonts as $k=>$font)
+    foreach ($this->fonts as $k=>$font)
     {
         // Font objects
         //$this->fonts[$k]['n']=$this->n+1;
         $type = $font['type'];
         $name = $font['name'];
-        if($type=='Core')
+        if ($type == 'Core')
         {
             // Standard font
-            $this->fonts[$k]['n']=$this->n+1;
+            $this->fonts[$k]['n'] = $this->n + 1;
             $this->_newobj();
             $this->_out('<</Type /Font');
             $this->_out('/BaseFont /'.$name);
             $this->_out('/Subtype /Type1');
-            if($name!='Symbol' && $name!='ZapfDingbats')
+            if ($name != 'Symbol' && $name != 'ZapfDingbats')
                 $this->_out('/Encoding /WinAnsiEncoding');
             $this->_out('>>');
             $this->_out('endobj');
         }
-        elseif($type=='Type1' || $type=='TrueType')
+        elseif ($type == 'Type1' || $type == 'TrueType')
         {
             // Additional Type1 or TrueType font
-            $this->fonts[$k]['n']=$this->n+1;
+            $this->fonts[$k]['n'] = $this->n + 1;
             $this->_newobj();
             $this->_out('<</Type /Font');
             $this->_out('/BaseFont /'.$name);
             $this->_out('/Subtype /'.$type);
             $this->_out('/FirstChar 32 /LastChar 255');
-            $this->_out('/Widths '.($this->n+1).' 0 R');
-            $this->_out('/FontDescriptor '.($this->n+2).' 0 R');
-            if($font['enc'])
+            $this->_out('/Widths '.($this->n + 1).' 0 R');
+            $this->_out('/FontDescriptor '.($this->n + 2).' 0 R');
+            if ($font['enc'])
             {
-                if(isset($font['diff']))
-                    $this->_out('/Encoding '.($nf+$font['diff']).' 0 R');
+                if (isset($font['diff']))
+                    $this->_out('/Encoding '.($nf + $font['diff']).' 0 R');
                 else
                     $this->_out('/Encoding /WinAnsiEncoding');
             }
@@ -1828,26 +1828,26 @@ 
             $this->_out('endobj');
             // Widths
             $this->_newobj();
-            $cw=&$font['cw'];
-            $s='[';
-            for($i=32;$i<=255;$i++)
-                $s.=$cw[chr($i)].' ';
+            $cw = &$font['cw'];
+            $s = '[';
+            for ($i = 32; $i <= 255; $i++)
+                $s .= $cw[chr($i)].' ';
             $this->_out($s.']');
             $this->_out('endobj');
             // Descriptor
             $this->_newobj();
-            $s='<</Type /FontDescriptor /FontName /'.$name;
-            foreach($font['desc'] as $k=>$v)
-                $s.=' /'.$k.' '.$v;
-            $file=$font['file'];
-            if($file)
-                $s.=' /FontFile'.($type=='Type1' ? '' : '2').' '.$this->FontFiles[$file]['n'].' 0 R';
+            $s = '<</Type /FontDescriptor /FontName /'.$name;
+            foreach ($font['desc'] as $k=>$v)
+                $s .= ' /'.$k.' '.$v;
+            $file = $font['file'];
+            if ($file)
+                $s .= ' /FontFile'.($type == 'Type1' ? '' : '2').' '.$this->FontFiles[$file]['n'].' 0 R';
             $this->_out($s.'>>');
             $this->_out('endobj');
         }
         // TrueType embedded SUBSETS or FULL
-        else if ($type=='TTF') {
-            $this->fonts[$k]['n']=$this->n+1;
+        else if ($type == 'TTF') {
+            $this->fonts[$k]['n'] = $this->n + 1;
             require_once($this->_getfontpath().'unifont/ttfonts.php');
             $ttf = new TTFontFile();
             $fontname = 'MPDFAA'.'+'.$font['name'];
@@ -1879,7 +1879,7 @@ 
             $this->_out('/BaseFont /'.$fontname.'');
             $this->_out('/CIDSystemInfo '.($this->n + 2).' 0 R');
             $this->_out('/FontDescriptor '.($this->n + 3).' 0 R');
-            if (isset($font['desc']['MissingWidth'])){
+            if (isset($font['desc']['MissingWidth'])) {
                 $this->_out('/DW '.$font['desc']['MissingWidth'].'');
             }
 
@@ -1927,7 +1927,7 @@ 
             $this->_newobj();
             $this->_out('<</Type /FontDescriptor');
             $this->_out('/FontName /'.$fontname);
-            foreach($font['desc'] as $kd=>$v) {
+            foreach ($font['desc'] as $kd=>$v) {
                 if ($kd == 'Flags') { $v = $v | 4; $v = $v & ~32; } // SYMBOLIC font flag
                 $this->_out(' /'.$kd.' '.$v);
             }
@@ -1938,10 +1938,10 @@ 
             // Embed CIDToGIDMap
             // A specification of the mapping from CIDs to glyph indices
             $cidtogidmap = '';
-            $cidtogidmap = str_pad('', 256*256*2, "\x00");
-            foreach($codeToGlyph as $cc=>$glyph) {
-                $cidtogidmap[$cc*2] = chr($glyph >> 8);
-                $cidtogidmap[$cc*2 + 1] = chr($glyph & 0xFF);
+            $cidtogidmap = str_pad('', 256 * 256 * 2, "\x00");
+            foreach ($codeToGlyph as $cc=>$glyph) {
+                $cidtogidmap[$cc * 2] = chr($glyph >> 8);
+                $cidtogidmap[$cc * 2 + 1] = chr($glyph & 0xFF);
             }
             $cidtogidmap = gzcompress($cidtogidmap);
             $this->_newobj();
@@ -1964,9 +1964,9 @@ 
         else
         {
             // Allow for additional types
-            $this->fonts[$k]['n'] = $this->n+1;
-            $mtd='_put'.strtolower($type);
-            if(!method_exists($this,$mtd))
+            $this->fonts[$k]['n'] = $this->n + 1;
+            $mtd = '_put'.strtolower($type);
+            if (!method_exists($this, $mtd))
                 $this->Error('Unsupported font type: '.$type);
             $this->$mtd($font);
         }
@@ -1975,7 +1975,7 @@ 
 
 function _putTTfontwidths(&$font, $maxUni) {
     if (file_exists($font['unifilename'].'.cw127.php')) {
-        include($font['unifilename'].'.cw127.php') ;
+        include($font['unifilename'].'.cw127.php');
         $startcid = 128;
     }
     else {
@@ -1989,24 +1989,24 @@ 
     $cwlen = $maxUni + 1;
 
     // for each character
-    for ($cid=$startcid; $cid<$cwlen; $cid++) {
-        if ($cid==128 && (!file_exists($font['unifilename'].'.cw127.php'))) {
+    for ($cid = $startcid; $cid < $cwlen; $cid++) {
+        if ($cid == 128 && (!file_exists($font['unifilename'].'.cw127.php'))) {
             if (is_writable(dirname($this->_getfontpath().'unifont/x'))) {
-                $fh = fopen($font['unifilename'].'.cw127.php',"wb");
-                $cw127='<?php'."\n";
-                $cw127.='$rangeid='.$rangeid.";\n";
-                $cw127.='$prevcid='.$prevcid.";\n";
-                $cw127.='$prevwidth='.$prevwidth.";\n";
-                if ($interval) { $cw127.='$interval=true'.";\n"; }
-                else { $cw127.='$interval=false'.";\n"; }
-                $cw127.='$range='.var_export($range,true).";\n";
-                $cw127.="?>";
-                fwrite($fh,$cw127,strlen($cw127));
+                $fh = fopen($font['unifilename'].'.cw127.php', "wb");
+                $cw127 = '<?php'."\n";
+                $cw127 .= '$rangeid='.$rangeid.";\n";
+                $cw127 .= '$prevcid='.$prevcid.";\n";
+                $cw127 .= '$prevwidth='.$prevwidth.";\n";
+                if ($interval) { $cw127 .= '$interval=true'.";\n"; }
+                else { $cw127 .= '$interval=false'.";\n"; }
+                $cw127 .= '$range='.var_export($range, true).";\n";
+                $cw127 .= "?>";
+                fwrite($fh, $cw127, strlen($cw127));
                 fclose($fh);
             }
         }
-        if ($font['cw'][$cid*2] == "\00" && $font['cw'][$cid*2+1] == "\00") { continue; }
-        $width = (ord($font['cw'][$cid*2]) << 8) + ord($font['cw'][$cid*2+1]);
+        if ($font['cw'][$cid * 2] == "\00" && $font['cw'][$cid * 2 + 1] == "\00") { continue; }
+        $width = (ord($font['cw'][$cid * 2]) << 8) + ord($font['cw'][$cid * 2 + 1]);
         if ($width == 65535) { $width = 0; }
         if ($cid > 255 && (!isset($font['subset'][$cid]) || !$font['subset'][$cid])) { continue; }
         if (!isset($font['dw']) || (isset($font['dw']) && $width != $font['dw'])) {
@@ -2068,14 +2068,14 @@ 
     $w = '';
     foreach ($range as $k => $ws) {
         if (count(array_count_values($ws)) == 1) { $w .= ' '.$k.' '.($k + count($ws) - 1).' '.$ws[0]; }
-        else { $w .= ' '.$k.' [ '.implode(' ', $ws).' ]' . "\n"; }
+        else { $w .= ' '.$k.' [ '.implode(' ', $ws).' ]'."\n"; }
     }
     $this->_out('/W ['.$w.' ]');
 }
 
 function _putimages()
 {
-    foreach(array_keys($this->images) as $file)
+    foreach (array_keys($this->images) as $file)
     {
         $this->_putimage($this->images[$file]);
         unset($this->images[$file]['data']);
@@ -2091,40 +2091,40 @@ 
     $this->_out('/Subtype /Image');
     $this->_out('/Width '.$info['w']);
     $this->_out('/Height '.$info['h']);
-    if($info['cs']=='Indexed')
-        $this->_out('/ColorSpace [/Indexed /DeviceRGB '.(strlen($info['pal'])/3-1).' '.($this->n+1).' 0 R]');
+    if ($info['cs'] == 'Indexed')
+        $this->_out('/ColorSpace [/Indexed /DeviceRGB '.(strlen($info['pal']) / 3 - 1).' '.($this->n + 1).' 0 R]');
     else
     {
         $this->_out('/ColorSpace /'.$info['cs']);
-        if($info['cs']=='DeviceCMYK')
+        if ($info['cs'] == 'DeviceCMYK')
             $this->_out('/Decode [1 0 1 0 1 0 1 0]');
     }
     $this->_out('/BitsPerComponent '.$info['bpc']);
-    if(isset($info['f']))
+    if (isset($info['f']))
         $this->_out('/Filter /'.$info['f']);
-    if(isset($info['dp']))
+    if (isset($info['dp']))
         $this->_out('/DecodeParms <<'.$info['dp'].'>>');
-    if(isset($info['trns']) && is_array($info['trns']))
+    if (isset($info['trns']) && is_array($info['trns']))
     {
         $trns = '';
-        for($i=0;$i<count($info['trns']);$i++)
+        for ($i = 0; $i < count($info['trns']); $i++)
             $trns .= $info['trns'][$i].' '.$info['trns'][$i].' ';
         $this->_out('/Mask ['.$trns.']');
     }
-    if(isset($info['smask']))
-        $this->_out('/SMask '.($this->n+1).' 0 R');
+    if (isset($info['smask']))
+        $this->_out('/SMask '.($this->n + 1).' 0 R');
     $this->_out('/Length '.strlen($info['data']).'>>');
     $this->_putstream($info['data']);
     $this->_out('endobj');
     // Soft mask
-    if(isset($info['smask']))
+    if (isset($info['smask']))
     {
         $dp = '/Predictor 15 /Colors 1 /BitsPerComponent 8 /Columns '.$info['w'];
         $smask = array('w'=>$info['w'], 'h'=>$info['h'], 'cs'=>'DeviceGray', 'bpc'=>8, 'f'=>$info['f'], 'dp'=>$dp, 'data'=>$info['smask']);
         $this->_putimage($smask);
     }
     // Palette
-    if($info['cs']=='Indexed')
+    if ($info['cs'] == 'Indexed')
     {
         $filter = ($this->compress) ? '/Filter /FlateDecode ' : '';
         $pal = ($this->compress) ? gzcompress($info['pal']) : $info['pal'];
@@ -2137,7 +2137,7 @@ 
 
 function _putxobjectdict()
 {
-    foreach($this->images as $image)
+    foreach ($this->images as $image)
         $this->_out('/I'.$image['i'].' '.$image['n'].' 0 R');
 }
 
@@ -2145,7 +2145,7 @@ 
 {
     $this->_out('/ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');
     $this->_out('/Font <<');
-    foreach($this->fonts as $font) {
+    foreach ($this->fonts as $font) {
         $this->_out('/F'.$font['i'].' '.$font['n'].' 0 R');
     }
     $this->_out('>>');
@@ -2170,15 +2170,15 @@ 
 function _putinfo()
 {
     $this->_out('/Producer '.$this->_textstring('tFPDF '.tFPDF_VERSION));
-    if(!empty($this->title))
+    if (!empty($this->title))
         $this->_out('/Title '.$this->_textstring($this->title));
-    if(!empty($this->subject))
+    if (!empty($this->subject))
         $this->_out('/Subject '.$this->_textstring($this->subject));
-    if(!empty($this->author))
+    if (!empty($this->author))
         $this->_out('/Author '.$this->_textstring($this->author));
-    if(!empty($this->keywords))
+    if (!empty($this->keywords))
         $this->_out('/Keywords '.$this->_textstring($this->keywords));
-    if(!empty($this->creator))
+    if (!empty($this->creator))
         $this->_out('/Creator '.$this->_textstring($this->creator));
     $this->_out('/CreationDate '.$this->_textstring('D:'.@date('YmdHis')));
 }
@@ -2187,19 +2187,19 @@ 
 {
     $this->_out('/Type /Catalog');
     $this->_out('/Pages 1 0 R');
-    if($this->ZoomMode=='fullpage')
+    if ($this->ZoomMode == 'fullpage')
         $this->_out('/OpenAction [3 0 R /Fit]');
-    elseif($this->ZoomMode=='fullwidth')
+    elseif ($this->ZoomMode == 'fullwidth')
         $this->_out('/OpenAction [3 0 R /FitH null]');
-    elseif($this->ZoomMode=='real')
+    elseif ($this->ZoomMode == 'real')
         $this->_out('/OpenAction [3 0 R /XYZ null null 1]');
-    elseif(!is_string($this->ZoomMode))
-        $this->_out('/OpenAction [3 0 R /XYZ null null '.sprintf('%.2F',$this->ZoomMode/100).']');
-    if($this->LayoutMode=='single')
+    elseif (!is_string($this->ZoomMode))
+        $this->_out('/OpenAction [3 0 R /XYZ null null '.sprintf('%.2F', $this->ZoomMode / 100).']');
+    if ($this->LayoutMode == 'single')
         $this->_out('/PageLayout /SinglePage');
-    elseif($this->LayoutMode=='continuous')
+    elseif ($this->LayoutMode == 'continuous')
         $this->_out('/PageLayout /OneColumn');
-    elseif($this->LayoutMode=='two')
+    elseif ($this->LayoutMode == 'two')
         $this->_out('/PageLayout /TwoColumnLeft');
 }
 
@@ -2210,9 +2210,9 @@ 
 
 function _puttrailer()
 {
-    $this->_out('/Size '.($this->n+1));
+    $this->_out('/Size '.($this->n + 1));
     $this->_out('/Root '.$this->n.' 0 R');
-    $this->_out('/Info '.($this->n-1).' 0 R');
+    $this->_out('/Info '.($this->n - 1).' 0 R');
 }
 
 function _enddoc()
@@ -2235,10 +2235,10 @@ 
     // Cross-ref
     $o = strlen($this->buffer);
     $this->_out('xref');
-    $this->_out('0 '.($this->n+1));
+    $this->_out('0 '.($this->n + 1));
     $this->_out('0000000000 65535 f ');
-    for($i=1;$i<=$this->n;$i++)
-        $this->_out(sprintf('%010d 00000 n ',$this->offsets[$i]));
+    for ($i = 1; $i <= $this->n; $i++)
+        $this->_out(sprintf('%010d 00000 n ', $this->offsets[$i]));
     // Trailer
     $this->_out('trailer');
     $this->_out('<<');
@@ -2252,7 +2252,7 @@ 
 
 // ********* NEW FUNCTIONS *********
 // Converts UTF-8 strings to UTF16-BE.
-function UTF8ToUTF16BE($str, $setbom=true) {
+function UTF8ToUTF16BE($str, $setbom = true) {
     $outstr = "";
     if ($setbom) {
         $outstr .= "\xFE\xFF"; // Byte Order Mark (BOM)
@@ -2268,15 +2268,15 @@ 
    for ($i = 0; $i < $len; $i++) {
     $uni = -1;
       $h = ord($str[$i]);
-      if ( $h <= 0x7F )
+      if ($h <= 0x7F)
          $uni = $h;
-      elseif ( $h >= 0xC2 ) {
-         if ( ($h <= 0xDF) && ($i < $len -1) )
+      elseif ($h >= 0xC2) {
+         if (($h <= 0xDF) && ($i < $len - 1))
             $uni = ($h & 0x1F) << 6 | (ord($str[++$i]) & 0x3F);
-         elseif ( ($h <= 0xEF) && ($i < $len -2) )
+         elseif (($h <= 0xEF) && ($i < $len - 2))
             $uni = ($h & 0x0F) << 12 | (ord($str[++$i]) & 0x3F) << 6
                                        | (ord($str[++$i]) & 0x3F);
-         elseif ( ($h <= 0xF4) && ($i < $len -3) )
+         elseif (($h <= 0xF4) && ($i < $len - 3))
             $uni = ($h & 0x0F) << 18 | (ord($str[++$i]) & 0x3F) << 12
                                        | (ord($str[++$i]) & 0x3F) << 6
                                        | (ord($str[++$i]) & 0x3F);
@@ -2293,7 +2293,7 @@ 
 }
 
 // Handle special IE contype request
-if(isset($_SERVER['HTTP_USER_AGENT']) && $_SERVER['HTTP_USER_AGENT']=='contype')
+if (isset($_SERVER['HTTP_USER_AGENT']) && $_SERVER['HTTP_USER_AGENT'] == 'contype')
 {
     header('Content-Type: application/pdf');
     exit;

Braces +633 added lines, -530 removed lines

@@ -108,26 +108,28 @@ 
     if(defined('FPDF_FONTPATH'))
     {
         $this->fontpath = FPDF_FONTPATH;
-        if(substr($this->fontpath,-1)!='/' && substr($this->fontpath,-1)!='\\')
-            $this->fontpath .= '/';
+        if(substr($this->fontpath,-1)!='/' && substr($this->fontpath,-1)!='\\') {
+                    $this->fontpath .= '/';
+        }
+    } elseif(is_dir(dirname(__FILE__).'/font')) {
+            $this->fontpath = dirname(__FILE__).'/font/';
+    } else {
+            $this->fontpath = '';
     }
-    elseif(is_dir(dirname(__FILE__).'/font'))
-        $this->fontpath = dirname(__FILE__).'/font/';
-    else
-        $this->fontpath = '';
     // Core fonts
     $this->CoreFonts = array('courier', 'helvetica', 'times', 'symbol', 'zapfdingbats');
     // Scale factor
-    if($unit=='pt')
-        $this->k = 1;
-    elseif($unit=='mm')
-        $this->k = 72/25.4;
-    elseif($unit=='cm')
-        $this->k = 72/2.54;
-    elseif($unit=='in')
-        $this->k = 72;
-    else
-        $this->Error('Incorrect unit: '.$unit);
+    if($unit=='pt') {
+            $this->k = 1;
+    } elseif($unit=='mm') {
+            $this->k = 72/25.4;
+    } elseif($unit=='cm') {
+            $this->k = 72/2.54;
+    } elseif($unit=='in') {
+            $this->k = 72;
+    } else {
+            $this->Error('Incorrect unit: '.$unit);
+    }
     // Page sizes
     $this->StdPageSizes = array('a3'=>array(841.89,1190.55), 'a4'=>array(595.28,841.89), 'a5'=>array(420.94,595.28),
         'letter'=>array(612,792), 'legal'=>array(612,1008));
@@ -141,15 +143,14 @@ 
         $this->DefOrientation = 'P';
         $this->w = $size[0];
         $this->h = $size[1];
-    }
-    elseif($orientation=='l' || $orientation=='landscape')
+    } elseif($orientation=='l' || $orientation=='landscape')
     {
         $this->DefOrientation = 'L';
         $this->w = $size[1];
         $this->h = $size[0];
+    } else {
+            $this->Error('Incorrect orientation: '.$orientation);
     }
-    else
-        $this->Error('Incorrect orientation: '.$orientation);
     $this->CurOrientation = $this->DefOrientation;
     $this->wPt = $this->w*$this->k;
     $this->hPt = $this->h*$this->k;
@@ -175,8 +176,9 @@ 
     // Set left, top and right margins
     $this->lMargin = $left;
     $this->tMargin = $top;
-    if($right===null)
-        $right = $left;
+    if($right===null) {
+            $right = $left;
+    }
     $this->rMargin = $right;
 }
 
@@ -184,9 +186,10 @@ 
 {
     // Set left margin
     $this->lMargin = $margin;
-    if($this->page>0 && $this->x<$margin)
-        $this->x = $margin;
-}
+    if($this->page>0 && $this->x<$margin) {
+            $this->x = $margin;
+    }
+    }
 
 function SetTopMargin($margin)
 {
@@ -211,62 +214,70 @@ 
 function SetDisplayMode($zoom, $layout='default')
 {
     // Set display mode in viewer
-    if($zoom=='fullpage' || $zoom=='fullwidth' || $zoom=='real' || $zoom=='default' || !is_string($zoom))
-        $this->ZoomMode = $zoom;
-    else
-        $this->Error('Incorrect zoom display mode: '.$zoom);
-    if($layout=='single' || $layout=='continuous' || $layout=='two' || $layout=='default')
-        $this->LayoutMode = $layout;
-    else
-        $this->Error('Incorrect layout display mode: '.$layout);
-}
+    if($zoom=='fullpage' || $zoom=='fullwidth' || $zoom=='real' || $zoom=='default' || !is_string($zoom)) {
+            $this->ZoomMode = $zoom;
+    } else {
+            $this->Error('Incorrect zoom display mode: '.$zoom);
+    }
+    if($layout=='single' || $layout=='continuous' || $layout=='two' || $layout=='default') {
+            $this->LayoutMode = $layout;
+    } else {
+            $this->Error('Incorrect layout display mode: '.$layout);
+    }
+    }
 
 function SetCompression($compress)
 {
     // Set page compression
-    if(function_exists('gzcompress'))
-        $this->compress = $compress;
-    else
-        $this->compress = false;
-}
+    if(function_exists('gzcompress')) {
+            $this->compress = $compress;
+    } else {
+            $this->compress = false;
+    }
+    }
 
 function SetTitle($title, $isUTF8=false)
 {
     // Title of document
-    if($isUTF8)
-        $title = $this->_UTF8toUTF16($title);
+    if($isUTF8) {
+            $title = $this->_UTF8toUTF16($title);
+    }
     $this->title = $title;
 }
 
 function SetSubject($subject, $isUTF8=false)
 {
     // Subject of document
-    if($isUTF8)
-        $subject = $this->_UTF8toUTF16($subject);
+    if($isUTF8) {
+            $subject = $this->_UTF8toUTF16($subject);
+    }
     $this->subject = $subject;
 }
 
 function SetAuthor($author, $isUTF8=false)
 {
     // Author of document
-    if($isUTF8)
-        $author = $this->_UTF8toUTF16($author);
+    if($isUTF8) {
+            $author = $this->_UTF8toUTF16($author);
+    }
     $this->author = $author;
 }
 
 function SetKeywords($keywords, $isUTF8=false)
 {
     // Keywords of document
-    if($isUTF8)
-        $keywords = $this->_UTF8toUTF16($keywords);
+    if($isUTF8) {
+            $keywords = $this->_UTF8toUTF16($keywords);
+    }
     $this->keywords = $keywords;
 }
 
 function SetCreator($creator, $isUTF8=false)
 {
     // Creator of document
-    if($isUTF8)
-        $creator = $this->_UTF8toUTF16($creator);
+    if($isUTF8) {
+            $creator = $this->_UTF8toUTF16($creator);
+    }
     $this->creator = $creator;
 }
 
@@ -291,10 +302,12 @@ 
 function Close()
 {
     // Terminate document
-    if($this->state==3)
-        return;
-    if($this->page==0)
-        $this->AddPage();
+    if($this->state==3) {
+            return;
+    }
+    if($this->page==0) {
+            $this->AddPage();
+    }
     // Page footer
     $this->InFooter = true;
     $this->Footer();
@@ -308,8 +321,9 @@ 
 function AddPage($orientation='', $size='')
 {
     // Start a new page
-    if($this->state==0)
-        $this->Open();
+    if($this->state==0) {
+            $this->Open();
+    }
     $family = $this->FontFamily;
     $style = $this->FontStyle.($this->underline ? 'U' : '');
     $fontsize = $this->FontSizePt;
@@ -335,15 +349,18 @@ 
     $this->LineWidth = $lw;
     $this->_out(sprintf('%.2F w',$lw*$this->k));
     // Set font
-    if($family)
-        $this->SetFont($family,$style,$fontsize);
+    if($family) {
+            $this->SetFont($family,$style,$fontsize);
+    }
     // Set colors
     $this->DrawColor = $dc;
-    if($dc!='0 G')
-        $this->_out($dc);
+    if($dc!='0 G') {
+            $this->_out($dc);
+    }
     $this->FillColor = $fc;
-    if($fc!='0 g')
-        $this->_out($fc);
+    if($fc!='0 g') {
+            $this->_out($fc);
+    }
     $this->TextColor = $tc;
     $this->ColorFlag = $cf;
     // Page header
@@ -357,8 +374,9 @@ 
         $this->_out(sprintf('%.2F w',$lw*$this->k));
     }
     // Restore font
-    if($family)
-        $this->SetFont($family,$style,$fontsize);
+    if($family) {
+            $this->SetFont($family,$style,$fontsize);
+    }
     // Restore colors
     if($this->DrawColor!=$dc)
     {
@@ -393,33 +411,38 @@ 
 function SetDrawColor($r, $g=null, $b=null)
 {
     // Set color for all stroking operations
-    if(($r==0 && $g==0 && $b==0) || $g===null)
-        $this->DrawColor = sprintf('%.3F G',$r/255);
-    else
-        $this->DrawColor = sprintf('%.3F %.3F %.3F RG',$r/255,$g/255,$b/255);
-    if($this->page>0)
-        $this->_out($this->DrawColor);
-}
+    if(($r==0 && $g==0 && $b==0) || $g===null) {
+            $this->DrawColor = sprintf('%.3F G',$r/255);
+    } else {
+            $this->DrawColor = sprintf('%.3F %.3F %.3F RG',$r/255,$g/255,$b/255);
+    }
+    if($this->page>0) {
+            $this->_out($this->DrawColor);
+    }
+    }
 
 function SetFillColor($r, $g=null, $b=null)
 {
     // Set color for all filling operations
-    if(($r==0 && $g==0 && $b==0) || $g===null)
-        $this->FillColor = sprintf('%.3F g',$r/255);
-    else
-        $this->FillColor = sprintf('%.3F %.3F %.3F rg',$r/255,$g/255,$b/255);
+    if(($r==0 && $g==0 && $b==0) || $g===null) {
+            $this->FillColor = sprintf('%.3F g',$r/255);
+    } else {
+            $this->FillColor = sprintf('%.3F %.3F %.3F rg',$r/255,$g/255,$b/255);
+    }
     $this->ColorFlag = ($this->FillColor!=$this->TextColor);
-    if($this->page>0)
-        $this->_out($this->FillColor);
-}
+    if($this->page>0) {
+            $this->_out($this->FillColor);
+    }
+    }
 
 function SetTextColor($r, $g=null, $b=null)
 {
     // Set color for text
-    if(($r==0 && $g==0 && $b==0) || $g===null)
-        $this->TextColor = sprintf('%.3F g',$r/255);
-    else
-        $this->TextColor = sprintf('%.3F %.3F %.3F rg',$r/255,$g/255,$b/255);
+    if(($r==0 && $g==0 && $b==0) || $g===null) {
+            $this->TextColor = sprintf('%.3F g',$r/255);
+    } else {
+            $this->TextColor = sprintf('%.3F %.3F %.3F rg',$r/255,$g/255,$b/255);
+    }
     $this->ColorFlag = ($this->FillColor!=$this->TextColor);
 }
 
@@ -432,17 +455,13 @@ 
     if ($this->unifontSubset) {
         $unicode = $this->UTF8StringToArray($s);
         foreach($unicode as $char) {
-            if (isset($cw[$char])) { $w += (ord($cw[2*$char])<<8) + ord($cw[2*$char+1]); }
-            else if($char>0 && $char<128 && isset($cw[chr($char)])) { $w += $cw[chr($char)]; }
-            else if(isset($this->CurrentFont['desc']['MissingWidth'])) { $w += $this->CurrentFont['desc']['MissingWidth']; }
-            else if(isset($this->CurrentFont['MissingWidth'])) { $w += $this->CurrentFont['MissingWidth']; }
-            else { $w += 500; }
+            if (isset($cw[$char])) { $w += (ord($cw[2*$char])<<8) + ord($cw[2*$char+1]); } else if($char>0 && $char<128 && isset($cw[chr($char)])) { $w += $cw[chr($char)]; } else if(isset($this->CurrentFont['desc']['MissingWidth'])) { $w += $this->CurrentFont['desc']['MissingWidth']; } else if(isset($this->CurrentFont['MissingWidth'])) { $w += $this->CurrentFont['MissingWidth']; } else { $w += 500; }
         }
-    }
-    else {
+    } else {
         $l = strlen($s);
-        for($i=0;$i<$l;$i++)
-            $w += $cw[$s[$i]];
+        for($i=0;$i<$l;$i++) {
+                    $w += $cw[$s[$i]];
+        }
     }
     return $w*$this->FontSize/1000;
 }
@@ -451,9 +470,10 @@ 
 {
     // Set line width
     $this->LineWidth = $width;
-    if($this->page>0)
-        $this->_out(sprintf('%.2F w',$width*$this->k));
-}
+    if($this->page>0) {
+            $this->_out(sprintf('%.2F w',$width*$this->k));
+    }
+    }
 
 function Line($x1, $y1, $x2, $y2)
 {
@@ -464,12 +484,13 @@ 
 function Rect($x, $y, $w, $h, $style='')
 {
     // Draw a rectangle
-    if($style=='F')
-        $op = 'f';
-    elseif($style=='FD' || $style=='DF')
-        $op = 'B';
-    else
-        $op = 'S';
+    if($style=='F') {
+            $op = 'f';
+    } elseif($style=='FD' || $style=='DF') {
+            $op = 'B';
+    } else {
+            $op = 'S';
+    }
     $this->_out(sprintf('%.2F %.2F %.2F %.2F re %s',$x*$this->k,($this->h-$y)*$this->k,$w*$this->k,-$h*$this->k,$op));
 }
 
@@ -478,23 +499,23 @@ 
     // Add a TrueType, OpenType or Type1 font
     $family = strtolower($family);
     $style = strtoupper($style);
-    if($style=='IB')
-        $style='BI';
+    if($style=='IB') {
+            $style='BI';
+    }
     if($file=='') {
        if ($uni) {
         $file = str_replace(' ','',$family).strtolower($style).'.ttf';
-       }
-       else {
+       } else {
         $file = str_replace(' ','',$family).strtolower($style).'.php';
        }
     }
     $fontkey = $family.$style;
-    if(isset($this->fonts[$fontkey]))
-        return;
+    if(isset($this->fonts[$fontkey])) {
+            return;
+    }
 
     if ($uni) {
-        if (defined("_SYSTEM_TTFONTS") && file_exists(_SYSTEM_TTFONTS.$file )) { $ttffilename = _SYSTEM_TTFONTS.$file ; }
-        else { $ttffilename = $this->_getfontpath().'unifont/'.$file ; }
+        if (defined("_SYSTEM_TTFONTS") && file_exists(_SYSTEM_TTFONTS.$file )) { $ttffilename = _SYSTEM_TTFONTS.$file ; } else { $ttffilename = $this->_getfontpath().'unifont/'.$file ; }
         $unifilename = $this->_getfontpath().'unifont/'.strtolower(substr($file ,0,(strpos($file ,'.'))));
         $name = '';
         $originalsize = 0;
@@ -543,22 +564,21 @@ 
                 @unlink($unifilename.'.cw127.php');
             }
             unset($ttf);
-        }
-        else {
+        } else {
             $cw = @file_get_contents($unifilename.'.cw.dat');
         }
         $i = count($this->fonts)+1;
-        if(!empty($this->AliasNbPages))
-            $sbarr = range(0,57);
-        else
-            $sbarr = range(0,32);
+        if(!empty($this->AliasNbPages)) {
+                    $sbarr = range(0,57);
+        } else {
+                    $sbarr = range(0,32);
+        }
         $this->fonts[$fontkey] = array('i'=>$i, 'type'=>$type, 'name'=>$name, 'desc'=>$desc, 'up'=>$up, 'ut'=>$ut, 'cw'=>$cw, 'ttffile'=>$ttffile, 'fontkey'=>$fontkey, 'subset'=>$sbarr, 'unifilename'=>$unifilename);
 
         $this->FontFiles[$fontkey]=array('length1'=>$originalsize, 'type'=>"TTF", 'ttffile'=>$ttffile);
         $this->FontFiles[$file]=array('type'=>"TTF");
         unset($cw);
-    }
-    else {
+    } else {
         $info = $this->_loadfont($file);
         $info['i'] = count($this->fonts)+1;
         if(!empty($info['diff']))
@@ -575,10 +595,11 @@ 
         if(!empty($info['file']))
         {
             // Embedded font
-            if($info['type']=='TrueType')
-                $this->FontFiles[$info['file']] = array('length1'=>$info['originalsize']);
-            else
-                $this->FontFiles[$info['file']] = array('length1'=>$info['size1'], 'length2'=>$info['size2']);
+            if($info['type']=='TrueType') {
+                            $this->FontFiles[$info['file']] = array('length1'=>$info['originalsize']);
+            } else {
+                            $this->FontFiles[$info['file']] = array('length1'=>$info['size1'], 'length2'=>$info['size2']);
+            }
         }
         $this->fonts[$fontkey] = $info;
     }
@@ -587,42 +608,49 @@ 
 function SetFont($family, $style='', $size=0)
 {
     // Select a font; size given in points
-    if($family=='')
-        $family = $this->FontFamily;
-    else
-        $family = strtolower($family);
+    if($family=='') {
+            $family = $this->FontFamily;
+    } else {
+            $family = strtolower($family);
+    }
     $style = strtoupper($style);
     if(strpos($style,'U')!==false)
     {
         $this->underline = true;
         $style = str_replace('U','',$style);
+    } else {
+            $this->underline = false;
+    }
+    if($style=='IB') {
+            $style = 'BI';
+    }
+    if($size==0) {
+            $size = $this->FontSizePt;
     }
-    else
-        $this->underline = false;
-    if($style=='IB')
-        $style = 'BI';
-    if($size==0)
-        $size = $this->FontSizePt;
     // Test if font is already selected
-    if($this->FontFamily==$family && $this->FontStyle==$style && $this->FontSizePt==$size)
-        return;
+    if($this->FontFamily==$family && $this->FontStyle==$style && $this->FontSizePt==$size) {
+            return;
+    }
     // Test if font is already loaded
     $fontkey = $family.$style;
     if(!isset($this->fonts[$fontkey]))
     {
         // Test if one of the core fonts
-        if($family=='arial')
-            $family = 'helvetica';
+        if($family=='arial') {
+                    $family = 'helvetica';
+        }
         if(in_array($family,$this->CoreFonts))
         {
-            if($family=='symbol' || $family=='zapfdingbats')
-                $style = '';
+            if($family=='symbol' || $family=='zapfdingbats') {
+                            $style = '';
+            }
             $fontkey = $family.$style;
-            if(!isset($this->fonts[$fontkey]))
-                $this->AddFont($family,$style);
+            if(!isset($this->fonts[$fontkey])) {
+                            $this->AddFont($family,$style);
+            }
+        } else {
+                    $this->Error('Undefined font: '.$family.' '.$style);
         }
-        else
-            $this->Error('Undefined font: '.$family.' '.$style);
     }
     // Select it
     $this->FontFamily = $family;
@@ -630,22 +658,24 @@ 
     $this->FontSizePt = $size;
     $this->FontSize = $size/$this->k;
     $this->CurrentFont = &$this->fonts[$fontkey];
-    if ($this->fonts[$fontkey]['type']=='TTF') { $this->unifontSubset = true; }
-    else { $this->unifontSubset = false; }
-    if($this->page>0)
-        $this->_out(sprintf('BT /F%d %.2F Tf ET',$this->CurrentFont['i'],$this->FontSizePt));
-}
+    if ($this->fonts[$fontkey]['type']=='TTF') { $this->unifontSubset = true; } else { $this->unifontSubset = false; }
+    if($this->page>0) {
+            $this->_out(sprintf('BT /F%d %.2F Tf ET',$this->CurrentFont['i'],$this->FontSizePt));
+    }
+    }
 
 function SetFontSize($size)
 {
     // Set font size in points
-    if($this->FontSizePt==$size)
-        return;
+    if($this->FontSizePt==$size) {
+            return;
+    }
     $this->FontSizePt = $size;
     $this->FontSize = $size/$this->k;
-    if($this->page>0)
-        $this->_out(sprintf('BT /F%d %.2F Tf ET',$this->CurrentFont['i'],$this->FontSizePt));
-}
+    if($this->page>0) {
+            $this->_out(sprintf('BT /F%d %.2F Tf ET',$this->CurrentFont['i'],$this->FontSizePt));
+    }
+    }
 
 function AddLink()
 {
@@ -658,10 +688,12 @@ 
 function SetLink($link, $y=0, $page=-1)
 {
     // Set destination of internal link
-    if($y==-1)
-        $y = $this->y;
-    if($page==-1)
-        $page = $this->page;
+    if($y==-1) {
+            $y = $this->y;
+    }
+    if($page==-1) {
+            $page = $this->page;
+    }
     $this->links[$link] = array($page, $y);
 }
 
@@ -677,16 +709,19 @@ 
     if ($this->unifontSubset)
     {
         $txt2 = '('.$this->_escape($this->UTF8ToUTF16BE($txt, false)).')';
-        foreach($this->UTF8StringToArray($txt) as $uni)
-            $this->CurrentFont['subset'][$uni] = $uni;
+        foreach($this->UTF8StringToArray($txt) as $uni) {
+                    $this->CurrentFont['subset'][$uni] = $uni;
+        }
+    } else {
+            $txt2 = '('.$this->_escape($txt).')';
     }
-    else
-        $txt2 = '('.$this->_escape($txt).')';
     $s = sprintf('BT %.2F %.2F Td %s Tj ET',$x*$this->k,($this->h-$y)*$this->k,$txt2);
-    if($this->underline && $txt!='')
-        $s .= ' '.$this->_dounderline($x,$y,$txt);
-    if($this->ColorFlag)
-        $s = 'q '.$this->TextColor.' '.$s.' Q';
+    if($this->underline && $txt!='') {
+            $s .= ' '.$this->_dounderline($x,$y,$txt);
+    }
+    if($this->ColorFlag) {
+            $s = 'q '.$this->TextColor.' '.$s.' Q';
+    }
     $this->_out($s);
 }
 
@@ -718,45 +753,54 @@ 
             $this->_out(sprintf('%.3F Tw',$ws*$k));
         }
     }
-    if($w==0)
-        $w = $this->w-$this->rMargin-$this->x;
+    if($w==0) {
+            $w = $this->w-$this->rMargin-$this->x;
+    }
     $s = '';
     if($fill || $border==1)
     {
-        if($fill)
-            $op = ($border==1) ? 'B' : 'f';
-        else
-            $op = 'S';
+        if($fill) {
+                    $op = ($border==1) ? 'B' : 'f';
+        } else {
+                    $op = 'S';
+        }
         $s = sprintf('%.2F %.2F %.2F %.2F re %s ',$this->x*$k,($this->h-$this->y)*$k,$w*$k,-$h*$k,$op);
     }
     if(is_string($border))
     {
         $x = $this->x;
         $y = $this->y;
-        if(strpos($border,'L')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-$y)*$k,$x*$k,($this->h-($y+$h))*$k);
-        if(strpos($border,'T')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-$y)*$k);
-        if(strpos($border,'R')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',($x+$w)*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-($y+$h))*$k);
-        if(strpos($border,'B')!==false)
-            $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-($y+$h))*$k,($x+$w)*$k,($this->h-($y+$h))*$k);
+        if(strpos($border,'L')!==false) {
+                    $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-$y)*$k,$x*$k,($this->h-($y+$h))*$k);
+        }
+        if(strpos($border,'T')!==false) {
+                    $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-$y)*$k);
+        }
+        if(strpos($border,'R')!==false) {
+                    $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',($x+$w)*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-($y+$h))*$k);
+        }
+        if(strpos($border,'B')!==false) {
+                    $s .= sprintf('%.2F %.2F m %.2F %.2F l S ',$x*$k,($this->h-($y+$h))*$k,($x+$w)*$k,($this->h-($y+$h))*$k);
+        }
     }
     if($txt!=='')
     {
-        if($align=='R')
-            $dx = $w-$this->cMargin-$this->GetStringWidth($txt);
-        elseif($align=='C')
-            $dx = ($w-$this->GetStringWidth($txt))/2;
-        else
-            $dx = $this->cMargin;
-        if($this->ColorFlag)
-            $s .= 'q '.$this->TextColor.' ';
+        if($align=='R') {
+                    $dx = $w-$this->cMargin-$this->GetStringWidth($txt);
+        } elseif($align=='C') {
+                    $dx = ($w-$this->GetStringWidth($txt))/2;
+        } else {
+                    $dx = $this->cMargin;
+        }
+        if($this->ColorFlag) {
+                    $s .= 'q '.$this->TextColor.' ';
+        }
 
         // If multibyte, Tw has no effect - do word spacing using an adjustment before each space
         if ($this->ws && $this->unifontSubset) {
-            foreach($this->UTF8StringToArray($txt) as $uni)
-                $this->CurrentFont['subset'][$uni] = $uni;
+            foreach($this->UTF8StringToArray($txt) as $uni) {
+                            $this->CurrentFont['subset'][$uni] = $uni;
+            }
             $space = $this->_escape($this->UTF8ToUTF16BE(' ', false));
             $s .= sprintf('BT 0 Tw %.2F %.2F Td [',($this->x+$dx)*$k,($this->h-($this->y+.5*$h+.3*$this->FontSize))*$k);
             $t = explode(' ',$txt);
@@ -772,55 +816,63 @@ 
             }
             $s .= '] TJ';
             $s .= ' ET';
-        }
-        else {
+        } else {
             if ($this->unifontSubset)
             {
                 $txt2 = '('.$this->_escape($this->UTF8ToUTF16BE($txt, false)).')';
-                foreach($this->UTF8StringToArray($txt) as $uni)
-                    $this->CurrentFont['subset'][$uni] = $uni;
+                foreach($this->UTF8StringToArray($txt) as $uni) {
+                                    $this->CurrentFont['subset'][$uni] = $uni;
+                }
+            } else {
+                            $txt2='('.str_replace(')','\\)',str_replace('(','\\(',str_replace('\\','\\\\',$txt))).')';
             }
-            else
-                $txt2='('.str_replace(')','\\)',str_replace('(','\\(',str_replace('\\','\\\\',$txt))).')';
             $s .= sprintf('BT %.2F %.2F Td %s Tj ET',($this->x+$dx)*$k,($this->h-($this->y+.5*$h+.3*$this->FontSize))*$k,$txt2);
         }
-        if($this->underline)
-            $s .= ' '.$this->_dounderline($this->x+$dx,$this->y+.5*$h+.3*$this->FontSize,$txt);
-        if($this->ColorFlag)
-            $s .= ' Q';
-        if($link)
-            $this->Link($this->x+$dx,$this->y+.5*$h-.5*$this->FontSize,$this->GetStringWidth($txt),$this->FontSize,$link);
+        if($this->underline) {
+                    $s .= ' '.$this->_dounderline($this->x+$dx,$this->y+.5*$h+.3*$this->FontSize,$txt);
+        }
+        if($this->ColorFlag) {
+                    $s .= ' Q';
+        }
+        if($link) {
+                    $this->Link($this->x+$dx,$this->y+.5*$h-.5*$this->FontSize,$this->GetStringWidth($txt),$this->FontSize,$link);
+        }
+    }
+    if($s) {
+            $this->_out($s);
     }
-    if($s)
-        $this->_out($s);
     $this->lasth = $h;
     if($ln>0)
     {
         // Go to next line
         $this->y += $h;
-        if($ln==1)
-            $this->x = $this->lMargin;
+        if($ln==1) {
+                    $this->x = $this->lMargin;
+        }
+    } else {
+            $this->x += $w;
+    }
     }
-    else
-        $this->x += $w;
-}
 
 function MultiCell($w, $h, $txt, $border=0, $align='J', $fill=false)
 {
     // Output text with automatic or explicit line breaks
     $cw = &$this->CurrentFont['cw'];
-    if($w==0)
-        $w = $this->w-$this->rMargin-$this->x;
+    if($w==0) {
+            $w = $this->w-$this->rMargin-$this->x;
+    }
     $wmax = ($w-2*$this->cMargin);
     $s = str_replace("\r",'',$txt);
     if ($this->unifontSubset) {
         $nb=mb_strlen($s, 'utf-8');
-        while($nb>0 && mb_substr($s,$nb-1,1,'utf-8')=="\n") $nb--;
-    }
-    else {
-        $nb = strlen($s);
-        if($nb>0 && $s[$nb-1]=="\n")
+        while($nb>0 && mb_substr($s,$nb-1,1,'utf-8')=="\n") {
             $nb--;
+        }
+    } else {
+        $nb = strlen($s);
+        if($nb>0 && $s[$nb-1]=="\n") {
+                    $nb--;
+        }
     }
     $b = 0;
     if($border)
@@ -830,14 +882,15 @@ 
             $border = 'LTRB';
             $b = 'LRT';
             $b2 = 'LR';
-        }
-        else
+        } else
         {
             $b2 = '';
-            if(strpos($border,'L')!==false)
-                $b2 .= 'L';
-            if(strpos($border,'R')!==false)
-                $b2 .= 'R';
+            if(strpos($border,'L')!==false) {
+                            $b2 .= 'L';
+            }
+            if(strpos($border,'R')!==false) {
+                            $b2 .= 'R';
+            }
             $b = (strpos($border,'T')!==false) ? $b2.'T' : $b2;
         }
     }
@@ -852,8 +905,7 @@ 
         // Get next character
         if ($this->unifontSubset) {
             $c = mb_substr($s,$i,1,'UTF-8');
-        }
-        else {
+        } else {
             $c=$s[$i];
         }
         if($c=="\n")
@@ -866,8 +918,7 @@ 
             }
             if ($this->unifontSubset) {
                 $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),$b,2,$align,$fill);
-            }
-            else {
+            } else {
                 $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill);
             }
             $i++;
@@ -876,8 +927,9 @@ 
             $l = 0;
             $ns = 0;
             $nl++;
-            if($border && $nl==2)
-                $b = $b2;
+            if($border && $nl==2) {
+                            $b = $b2;
+            }
             continue;
         }
         if($c==' ')
@@ -887,16 +939,16 @@ 
             $ns++;
         }
 
-        if ($this->unifontSubset) { $l += $this->GetStringWidth($c); }
-        else { $l += $cw[$c]*$this->FontSize/1000; }
+        if ($this->unifontSubset) { $l += $this->GetStringWidth($c); } else { $l += $cw[$c]*$this->FontSize/1000; }
 
         if($l>$wmax)
         {
             // Automatic line break
             if($sep==-1)
             {
-                if($i==$j)
-                    $i++;
+                if($i==$j) {
+                                    $i++;
+                }
                 if($this->ws>0)
                 {
                     $this->ws = 0;
@@ -904,12 +956,10 @@ 
                 }
                 if ($this->unifontSubset) {
                     $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),$b,2,$align,$fill);
-                }
-                else {
+                } else {
                     $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill);
                 }
-            }
-            else
+            } else
             {
                 if($align=='J')
                 {
@@ -918,8 +968,7 @@ 
                 }
                 if ($this->unifontSubset) {
                     $this->Cell($w,$h,mb_substr($s,$j,$sep-$j,'UTF-8'),$b,2,$align,$fill);
-                }
-                else {
+                } else {
                     $this->Cell($w,$h,substr($s,$j,$sep-$j),$b,2,$align,$fill);
                 }
                 $i = $sep+1;
@@ -929,11 +978,12 @@ 
             $l = 0;
             $ns = 0;
             $nl++;
-            if($border && $nl==2)
-                $b = $b2;
+            if($border && $nl==2) {
+                            $b = $b2;
+            }
+        } else {
+                    $i++;
         }
-        else
-            $i++;
     }
     // Last chunk
     if($this->ws>0)
@@ -941,12 +991,12 @@ 
         $this->ws = 0;
         $this->_out('0 Tw');
     }
-    if($border && strpos($border,'B')!==false)
-        $b .= 'B';
+    if($border && strpos($border,'B')!==false) {
+            $b .= 'B';
+    }
     if ($this->unifontSubset) {
         $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),$b,2,$align,$fill);
-    }
-    else {
+    } else {
         $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill);
     }
     $this->x = $this->lMargin;
@@ -966,8 +1016,7 @@ 
             $this->x += $this->GetStringWidth($s);
             return;
         }
-    }
-    else {
+    } else {
         $nb = strlen($s);
     }
     $sep = -1;
@@ -980,8 +1029,7 @@ 
         // Get next character
         if ($this->unifontSubset) {
             $c = mb_substr($s,$i,1,'UTF-8');
-        }
-        else {
+        } else {
             $c = $s[$i];
         }
         if($c=="\n")
@@ -989,8 +1037,7 @@ 
             // Explicit line break
             if ($this->unifontSubset) {
                 $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),0,2,'',0,$link);
-            }
-            else {
+            } else {
                 $this->Cell($w,$h,substr($s,$j,$i-$j),0,2,'',0,$link);
             }
             $i++;
@@ -1006,11 +1053,11 @@ 
             $nl++;
             continue;
         }
-        if($c==' ')
-            $sep = $i;
+        if($c==' ') {
+                    $sep = $i;
+        }
 
-        if ($this->unifontSubset) { $l += $this->GetStringWidth($c); }
-        else { $l += $cw[$c]*$this->FontSize/1000; }
+        if ($this->unifontSubset) { $l += $this->GetStringWidth($c); } else { $l += $cw[$c]*$this->FontSize/1000; }
 
         if($l>$wmax)
         {
@@ -1028,21 +1075,19 @@ 
                     $nl++;
                     continue;
                 }
-                if($i==$j)
-                    $i++;
+                if($i==$j) {
+                                    $i++;
+                }
                 if ($this->unifontSubset) {
                     $this->Cell($w,$h,mb_substr($s,$j,$i-$j,'UTF-8'),0,2,'',0,$link);
-                }
-                else {
+                } else {
                     $this->Cell($w,$h,substr($s,$j,$i-$j),0,2,'',0,$link);
                 }
-            }
-            else
+            } else
             {
                 if ($this->unifontSubset) {
                     $this->Cell($w,$h,mb_substr($s,$j,$sep-$j,'UTF-8'),0,2,'',0,$link);
-                }
-                else {
+                } else {
                     $this->Cell($w,$h,substr($s,$j,$sep-$j),0,2,'',0,$link);
                 }
                 $i = $sep+1;
@@ -1057,16 +1102,15 @@ 
                 $wmax = ($w-2*$this->cMargin);
             }
             $nl++;
+        } else {
+                    $i++;
         }
-        else
-            $i++;
     }
     // Last chunk
     if($i!=$j) {
         if ($this->unifontSubset) {
             $this->Cell($l,$h,mb_substr($s,$j,$i-$j,'UTF-8'),0,0,'',0,$link);
-        }
-        else {
+        } else {
             $this->Cell($l,$h,substr($s,$j),0,0,'',0,$link);
         }
     }
@@ -1076,11 +1120,12 @@ 
 {
     // Line feed; default value is last cell height
     $this->x = $this->lMargin;
-    if($h===null)
-        $this->y += $this->lasth;
-    else
-        $this->y += $h;
-}
+    if($h===null) {
+            $this->y += $this->lasth;
+    } else {
+            $this->y += $h;
+    }
+    }
 
 function Image($file, $x=null, $y=null, $w=0, $h=0, $type='', $link='')
 {
@@ -1091,22 +1136,25 @@ 
         if($type=='')
         {
             $pos = strrpos($file,'.');
-            if(!$pos)
-                $this->Error('Image file has no extension and no type was specified: '.$file);
+            if(!$pos) {
+                            $this->Error('Image file has no extension and no type was specified: '.$file);
+            }
             $type = substr($file,$pos+1);
         }
         $type = strtolower($type);
-        if($type=='jpeg')
-            $type = 'jpg';
+        if($type=='jpeg') {
+                    $type = 'jpg';
+        }
         $mtd = '_parse'.$type;
-        if(!method_exists($this,$mtd))
-            $this->Error('Unsupported image type: '.$type);
+        if(!method_exists($this,$mtd)) {
+                    $this->Error('Unsupported image type: '.$type);
+        }
         $info = $this->$mtd($file);
         $info['i'] = count($this->images)+1;
         $this->images[$file] = $info;
+    } else {
+            $info = $this->images[$file];
     }
-    else
-        $info = $this->images[$file];
 
     // Automatic width and height calculation if needed
     if($w==0 && $h==0)
@@ -1115,14 +1163,18 @@ 
         $w = -96;
         $h = -96;
     }
-    if($w<0)
-        $w = -$info['w']*72/$w/$this->k;
-    if($h<0)
-        $h = -$info['h']*72/$h/$this->k;
-    if($w==0)
-        $w = $h*$info['w']/$info['h'];
-    if($h==0)
-        $h = $w*$info['h']/$info['w'];
+    if($w<0) {
+            $w = -$info['w']*72/$w/$this->k;
+    }
+    if($h<0) {
+            $h = -$info['h']*72/$h/$this->k;
+    }
+    if($w==0) {
+            $w = $h*$info['w']/$info['h'];
+    }
+    if($h==0) {
+            $h = $w*$info['h']/$info['w'];
+    }
 
     // Flowing mode
     if($y===null)
@@ -1138,12 +1190,14 @@ 
         $this->y += $h;
     }
 
-    if($x===null)
-        $x = $this->x;
+    if($x===null) {
+            $x = $this->x;
+    }
     $this->_out(sprintf('q %.2F 0 0 %.2F %.2F %.2F cm /I%d Do Q',$w*$this->k,$h*$this->k,$x*$this->k,($this->h-($y+$h))*$this->k,$info['i']));
-    if($link)
-        $this->Link($x,$y,$w,$h,$link);
-}
+    if($link) {
+            $this->Link($x,$y,$w,$h,$link);
+    }
+    }
 
 function GetX()
 {
@@ -1154,11 +1208,12 @@ 
 function SetX($x)
 {
     // Set x position
-    if($x>=0)
-        $this->x = $x;
-    else
-        $this->x = $this->w+$x;
-}
+    if($x>=0) {
+            $this->x = $x;
+    } else {
+            $this->x = $this->w+$x;
+    }
+    }
 
 function GetY()
 {
@@ -1170,11 +1225,12 @@ 
 {
     // Set y position and reset x
     $this->x = $this->lMargin;
-    if($y>=0)
-        $this->y = $y;
-    else
-        $this->y = $this->h+$y;
-}
+    if($y>=0) {
+            $this->y = $y;
+    } else {
+            $this->y = $this->h+$y;
+    }
+    }
 
 function SetXY($x, $y)
 {
@@ -1186,8 +1242,9 @@ 
 function Output($name='', $dest='')
 {
     // Output PDF to some destination
-    if($this->state<3)
-        $this->Close();
+    if($this->state<3) {
+            $this->Close();
+    }
     $dest = strtoupper($dest);
     if($dest=='')
     {
@@ -1195,9 +1252,9 @@ 
         {
             $name = 'doc.pdf';
             $dest = 'I';
+        } else {
+                    $dest = 'F';
         }
-        else
-            $dest = 'F';
     }
     switch($dest)
     {
@@ -1226,8 +1283,9 @@ 
         case 'F':
             // Save to local file
             $f = fopen($name,'wb');
-            if(!$f)
-                $this->Error('Unable to create output file: '.$name);
+            if(!$f) {
+                            $this->Error('Unable to create output file: '.$name);
+            }
             fwrite($f,$this->buffer,strlen($this->buffer));
             fclose($f);
             break;
@@ -1248,18 +1306,22 @@ 
 function _dochecks()
 {
     // Check availability of %F
-    if(sprintf('%.1F',1.0)!='1.0')
-        $this->Error('This version of PHP is not supported');
+    if(sprintf('%.1F',1.0)!='1.0') {
+            $this->Error('This version of PHP is not supported');
+    }
     // Check availability of mbstring
-    if(!function_exists('mb_strlen'))
-        $this->Error('mbstring extension is not available');
+    if(!function_exists('mb_strlen')) {
+            $this->Error('mbstring extension is not available');
+    }
     // Check mbstring overloading
-    if(ini_get('mbstring.func_overload') & 2)
-        $this->Error('mbstring overloading must be disabled');
+    if(ini_get('mbstring.func_overload') & 2) {
+            $this->Error('mbstring overloading must be disabled');
+    }
     // Ensure runtime magic quotes are disabled
-    if(get_magic_quotes_runtime())
-        @set_magic_quotes_runtime(0);
-}
+    if(get_magic_quotes_runtime()) {
+            @set_magic_quotes_runtime(0);
+    }
+    }
 
 function _getfontpath()
 {
@@ -1270,8 +1332,9 @@ 
 {
     if(PHP_SAPI!='cli')
     {
-        if(headers_sent($file,$line))
-            $this->Error("Some data has already been output, can't send PDF file (output started at $file:$line)");
+        if(headers_sent($file,$line)) {
+                    $this->Error("Some data has already been output, can't send PDF file (output started at $file:$line)");
+        }
     }
     if(ob_get_length())
     {
@@ -1280,9 +1343,9 @@ 
         {
             // It contains only a UTF-8 BOM and/or whitespace, let's clean it
             ob_clean();
+        } else {
+                    $this->Error("Some data has already been output, can't send PDF file");
         }
-        else
-            $this->Error("Some data has already been output, can't send PDF file");
     }
 }
 
@@ -1291,17 +1354,18 @@ 
     if(is_string($size))
     {
         $size = strtolower($size);
-        if(!isset($this->StdPageSizes[$size]))
-            $this->Error('Unknown page size: '.$size);
+        if(!isset($this->StdPageSizes[$size])) {
+                    $this->Error('Unknown page size: '.$size);
+        }
         $a = $this->StdPageSizes[$size];
         return array($a[0]/$this->k, $a[1]/$this->k);
-    }
-    else
+    } else
     {
-        if($size[0]>$size[1])
-            return array($size[1], $size[0]);
-        else
-            return $size;
+        if($size[0]>$size[1]) {
+                    return array($size[1], $size[0]);
+        } else {
+                    return $size;
+        }
     }
 }
 
@@ -1314,14 +1378,16 @@ 
     $this->y = $this->tMargin;
     $this->FontFamily = '';
     // Check page size and orientation
-    if($orientation=='')
-        $orientation = $this->DefOrientation;
-    else
-        $orientation = strtoupper($orientation[0]);
-    if($size=='')
-        $size = $this->DefPageSize;
-    else
-        $size = $this->_getpagesize($size);
+    if($orientation=='') {
+            $orientation = $this->DefOrientation;
+    } else {
+            $orientation = strtoupper($orientation[0]);
+    }
+    if($size=='') {
+            $size = $this->DefPageSize;
+    } else {
+            $size = $this->_getpagesize($size);
+    }
     if($orientation!=$this->CurOrientation || $size[0]!=$this->CurPageSize[0] || $size[1]!=$this->CurPageSize[1])
     {
         // New size or orientation
@@ -1329,8 +1395,7 @@ 
         {
             $this->w = $size[0];
             $this->h = $size[1];
-        }
-        else
+        } else
         {
             $this->w = $size[1];
             $this->h = $size[0];
@@ -1341,9 +1406,10 @@ 
         $this->CurOrientation = $orientation;
         $this->CurPageSize = $size;
     }
-    if($orientation!=$this->DefOrientation || $size[0]!=$this->DefPageSize[0] || $size[1]!=$this->DefPageSize[1])
-        $this->PageSizes[$this->page] = array($this->wPt, $this->hPt);
-}
+    if($orientation!=$this->DefOrientation || $size[0]!=$this->DefPageSize[0] || $size[1]!=$this->DefPageSize[1]) {
+            $this->PageSizes[$this->page] = array($this->wPt, $this->hPt);
+    }
+    }
 
 function _endpage()
 {
@@ -1355,8 +1421,9 @@ 
     // Load a font definition file from the font directory
     include($this->fontpath.$font);
     $a = get_defined_vars();
-    if(!isset($a['name']))
-        $this->Error('Could not include font definition file');
+    if(!isset($a['name'])) {
+            $this->Error('Could not include font definition file');
+    }
     return $a;
 }
 
@@ -1392,15 +1459,13 @@ 
             $c3 = ord($s[$i++]);
             $res .= chr((($c1 & 0x0F)<<4) + (($c2 & 0x3C)>>2));
             $res .= chr((($c2 & 0x03)<<6) + ($c3 & 0x3F));
-        }
-        elseif($c1>=192)
+        } elseif($c1>=192)
         {
             // 2-byte character
             $c2 = ord($s[$i++]);
             $res .= chr(($c1 & 0x1C)>>2);
             $res .= chr((($c1 & 0x03)<<6) + ($c2 & 0x3F));
-        }
-        else
+        } else
         {
             // Single-byte character
             $res .= "\0".chr($c1);
@@ -1422,16 +1487,19 @@ 
 {
     // Extract info from a JPEG file
     $a = getimagesize($file);
-    if(!$a)
-        $this->Error('Missing or incorrect image file: '.$file);
-    if($a[2]!=2)
-        $this->Error('Not a JPEG file: '.$file);
-    if(!isset($a['channels']) || $a['channels']==3)
-        $colspace = 'DeviceRGB';
-    elseif($a['channels']==4)
-        $colspace = 'DeviceCMYK';
-    else
-        $colspace = 'DeviceGray';
+    if(!$a) {
+            $this->Error('Missing or incorrect image file: '.$file);
+    }
+    if($a[2]!=2) {
+            $this->Error('Not a JPEG file: '.$file);
+    }
+    if(!isset($a['channels']) || $a['channels']==3) {
+            $colspace = 'DeviceRGB';
+    } elseif($a['channels']==4) {
+            $colspace = 'DeviceCMYK';
+    } else {
+            $colspace = 'DeviceGray';
+    }
     $bpc = isset($a['bits']) ? $a['bits'] : 8;
     $data = file_get_contents($file);
     return array('w'=>$a[0], 'h'=>$a[1], 'cs'=>$colspace, 'bpc'=>$bpc, 'f'=>'DCTDecode', 'data'=>$data);
@@ -1441,8 +1509,9 @@ 
 {
     // Extract info from a PNG file
     $f = fopen($file,'rb');
-    if(!$f)
-        $this->Error('Can\'t open image file: '.$file);
+    if(!$f) {
+            $this->Error('Can\'t open image file: '.$file);
+    }
     $info = $this->_parsepngstream($f,$file);
     fclose($f);
     return $info;
@@ -1451,33 +1520,40 @@ 
 function _parsepngstream($f, $file)
 {
     // Check signature
-    if($this->_readstream($f,8)!=chr(137).'PNG'.chr(13).chr(10).chr(26).chr(10))
-        $this->Error('Not a PNG file: '.$file);
+    if($this->_readstream($f,8)!=chr(137).'PNG'.chr(13).chr(10).chr(26).chr(10)) {
+            $this->Error('Not a PNG file: '.$file);
+    }
 
     // Read header chunk
     $this->_readstream($f,4);
-    if($this->_readstream($f,4)!='IHDR')
-        $this->Error('Incorrect PNG file: '.$file);
+    if($this->_readstream($f,4)!='IHDR') {
+            $this->Error('Incorrect PNG file: '.$file);
+    }
     $w = $this->_readint($f);
     $h = $this->_readint($f);
     $bpc = ord($this->_readstream($f,1));
-    if($bpc>8)
-        $this->Error('16-bit depth not supported: '.$file);
+    if($bpc>8) {
+            $this->Error('16-bit depth not supported: '.$file);
+    }
     $ct = ord($this->_readstream($f,1));
-    if($ct==0 || $ct==4)
-        $colspace = 'DeviceGray';
-    elseif($ct==2 || $ct==6)
-        $colspace = 'DeviceRGB';
-    elseif($ct==3)
-        $colspace = 'Indexed';
-    else
-        $this->Error('Unknown color type: '.$file);
-    if(ord($this->_readstream($f,1))!=0)
-        $this->Error('Unknown compression method: '.$file);
-    if(ord($this->_readstream($f,1))!=0)
-        $this->Error('Unknown filter method: '.$file);
-    if(ord($this->_readstream($f,1))!=0)
-        $this->Error('Interlacing not supported: '.$file);
+    if($ct==0 || $ct==4) {
+            $colspace = 'DeviceGray';
+    } elseif($ct==2 || $ct==6) {
+            $colspace = 'DeviceRGB';
+    } elseif($ct==3) {
+            $colspace = 'Indexed';
+    } else {
+            $this->Error('Unknown color type: '.$file);
+    }
+    if(ord($this->_readstream($f,1))!=0) {
+            $this->Error('Unknown compression method: '.$file);
+    }
+    if(ord($this->_readstream($f,1))!=0) {
+            $this->Error('Unknown filter method: '.$file);
+    }
+    if(ord($this->_readstream($f,1))!=0) {
+            $this->Error('Interlacing not supported: '.$file);
+    }
     $this->_readstream($f,4);
     $dp = '/Predictor 15 /Colors '.($colspace=='DeviceRGB' ? 3 : 1).' /BitsPerComponent '.$bpc.' /Columns '.$w;
 
@@ -1494,44 +1570,45 @@ 
             // Read palette
             $pal = $this->_readstream($f,$n);
             $this->_readstream($f,4);
-        }
-        elseif($type=='tRNS')
+        } elseif($type=='tRNS')
         {
             // Read transparency info
             $t = $this->_readstream($f,$n);
-            if($ct==0)
-                $trns = array(ord(substr($t,1,1)));
-            elseif($ct==2)
-                $trns = array(ord(substr($t,1,1)), ord(substr($t,3,1)), ord(substr($t,5,1)));
-            else
+            if($ct==0) {
+                            $trns = array(ord(substr($t,1,1)));
+            } elseif($ct==2) {
+                            $trns = array(ord(substr($t,1,1)), ord(substr($t,3,1)), ord(substr($t,5,1)));
+            } else
             {
                 $pos = strpos($t,chr(0));
-                if($pos!==false)
-                    $trns = array($pos);
+                if($pos!==false) {
+                                    $trns = array($pos);
+                }
             }
             $this->_readstream($f,4);
-        }
-        elseif($type=='IDAT')
+        } elseif($type=='IDAT')
         {
             // Read image data block
             $data .= $this->_readstream($f,$n);
             $this->_readstream($f,4);
+        } elseif($type=='IEND') {
+                    break;
+        } else {
+                    $this->_readstream($f,$n+4);
         }
-        elseif($type=='IEND')
-            break;
-        else
-            $this->_readstream($f,$n+4);
     }
     while($n);
 
-    if($colspace=='Indexed' && empty($pal))
-        $this->Error('Missing palette in '.$file);
+    if($colspace=='Indexed' && empty($pal)) {
+            $this->Error('Missing palette in '.$file);
+    }
     $info = array('w'=>$w, 'h'=>$h, 'cs'=>$colspace, 'bpc'=>$bpc, 'f'=>'FlateDecode', 'dp'=>$dp, 'pal'=>$pal, 'trns'=>$trns);
     if($ct>=4)
     {
         // Extract alpha channel
-        if(!function_exists('gzuncompress'))
-            $this->Error('Zlib not available, can\'t handle alpha channel: '.$file);
+        if(!function_exists('gzuncompress')) {
+                    $this->Error('Zlib not available, can\'t handle alpha channel: '.$file);
+        }
         $data = gzuncompress($data);
         $color = '';
         $alpha = '';
@@ -1548,8 +1625,7 @@ 
                 $color .= preg_replace('/(.)./s','$1',$line);
                 $alpha .= preg_replace('/.(.)/s','$1',$line);
             }
-        }
-        else
+        } else
         {
             // RGB image
             $len = 4*$w;
@@ -1566,8 +1642,9 @@ 
         unset($data);
         $data = gzcompress($color);
         $info['smask'] = gzcompress($alpha);
-        if($this->PDFVersion<'1.4')
-            $this->PDFVersion = '1.4';
+        if($this->PDFVersion<'1.4') {
+                    $this->PDFVersion = '1.4';
+        }
     }
     $info['data'] = $data;
     return $info;
@@ -1580,13 +1657,15 @@ 
     while($n>0 && !feof($f))
     {
         $s = fread($f,$n);
-        if($s===false)
-            $this->Error('Error while reading stream');
+        if($s===false) {
+                    $this->Error('Error while reading stream');
+        }
         $n -= strlen($s);
         $res .= $s;
     }
-    if($n>0)
-        $this->Error('Unexpected end of stream');
+    if($n>0) {
+            $this->Error('Unexpected end of stream');
+    }
     return $res;
 }
 
@@ -1600,13 +1679,16 @@ 
 function _parsegif($file)
 {
     // Extract info from a GIF file (via PNG conversion)
-    if(!function_exists('imagepng'))
-        $this->Error('GD extension is required for GIF support');
-    if(!function_exists('imagecreatefromgif'))
-        $this->Error('GD has no GIF read support');
+    if(!function_exists('imagepng')) {
+            $this->Error('GD extension is required for GIF support');
+    }
+    if(!function_exists('imagecreatefromgif')) {
+            $this->Error('GD has no GIF read support');
+    }
     $im = imagecreatefromgif($file);
-    if(!$im)
-        $this->Error('Missing or incorrect image file: '.$file);
+    if(!$im) {
+            $this->Error('Missing or incorrect image file: '.$file);
+    }
     imageinterlace($im,0);
     $f = @fopen('php://temp','rb+');
     if($f)
@@ -1620,15 +1702,16 @@ 
         rewind($f);
         $info = $this->_parsepngstream($f,$file);
         fclose($f);
-    }
-    else
+    } else
     {
         // Use temporary file
         $tmp = tempnam('.','gif');
-        if(!$tmp)
-            $this->Error('Unable to create a temporary file');
-        if(!imagepng($im,$tmp))
-            $this->Error('Error while saving to temporary file');
+        if(!$tmp) {
+                    $this->Error('Unable to create a temporary file');
+        }
+        if(!imagepng($im,$tmp)) {
+                    $this->Error('Error while saving to temporary file');
+        }
         imagedestroy($im);
         $info = $this->_parsepng($tmp);
         unlink($tmp);
@@ -1654,11 +1737,12 @@ 
 function _out($s)
 {
     // Add a line to the document
-    if($this->state==2)
-        $this->pages[$this->page] .= $s."\n";
-    else
-        $this->buffer .= $s."\n";
-}
+    if($this->state==2) {
+            $this->pages[$this->page] .= $s."\n";
+    } else {
+            $this->buffer .= $s."\n";
+    }
+    }
 
 function _putpages()
 {
@@ -1668,18 +1752,19 @@ 
         // Replace number of pages in fonts using subsets
         $alias = $this->UTF8ToUTF16BE($this->AliasNbPages, false);
         $r = $this->UTF8ToUTF16BE("$nb", false);
-        for($n=1;$n<=$nb;$n++)
-            $this->pages[$n] = str_replace($alias,$r,$this->pages[$n]);
+        for($n=1;$n<=$nb;$n++) {
+                    $this->pages[$n] = str_replace($alias,$r,$this->pages[$n]);
+        }
         // Now repeat for no pages in non-subset fonts
-        for($n=1;$n<=$nb;$n++)
-            $this->pages[$n] = str_replace($this->AliasNbPages,$nb,$this->pages[$n]);
+        for($n=1;$n<=$nb;$n++) {
+                    $this->pages[$n] = str_replace($this->AliasNbPages,$nb,$this->pages[$n]);
+        }
     }
     if($this->DefOrientation=='P')
     {
         $wPt = $this->DefPageSize[0]*$this->k;
         $hPt = $this->DefPageSize[1]*$this->k;
-    }
-    else
+    } else
     {
         $wPt = $this->DefPageSize[1]*$this->k;
         $hPt = $this->DefPageSize[0]*$this->k;
@@ -1691,8 +1776,9 @@ 
         $this->_newobj();
         $this->_out('<</Type /Page');
         $this->_out('/Parent 1 0 R');
-        if(isset($this->PageSizes[$n]))
-            $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]',$this->PageSizes[$n][0],$this->PageSizes[$n][1]));
+        if(isset($this->PageSizes[$n])) {
+                    $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]',$this->PageSizes[$n][0],$this->PageSizes[$n][1]));
+        }
         $this->_out('/Resources 2 0 R');
         if(isset($this->PageLinks[$n]))
         {
@@ -1702,9 +1788,9 @@ 
             {
                 $rect = sprintf('%.2F %.2F %.2F %.2F',$pl[0],$pl[1],$pl[0]+$pl[2],$pl[1]-$pl[3]);
                 $annots .= '<</Type /Annot /Subtype /Link /Rect ['.$rect.'] /Border [0 0 0] ';
-                if(is_string($pl[4]))
-                    $annots .= '/A <</S /URI /URI '.$this->_textstring($pl[4]).'>>>>';
-                else
+                if(is_string($pl[4])) {
+                                    $annots .= '/A <</S /URI /URI '.$this->_textstring($pl[4]).'>>>>';
+                } else
                 {
                     $l = $this->links[$pl[4]];
                     $h = isset($this->PageSizes[$l[0]]) ? $this->PageSizes[$l[0]][1] : $hPt;
@@ -1713,8 +1799,9 @@ 
             }
             $this->_out($annots.']');
         }
-        if($this->PDFVersion>'1.3')
-            $this->_out('/Group <</Type /Group /S /Transparency /CS /DeviceRGB>>');
+        if($this->PDFVersion>'1.3') {
+                    $this->_out('/Group <</Type /Group /S /Transparency /CS /DeviceRGB>>');
+        }
         $this->_out('/Contents '.($this->n+1).' 0 R>>');
         $this->_out('endobj');
         // Page content
@@ -1729,8 +1816,9 @@ 
     $this->_out('1 0 obj');
     $this->_out('<</Type /Pages');
     $kids = '/Kids [';
-    for($i=0;$i<$nb;$i++)
-        $kids .= (3+2*$i).' 0 R ';
+    for($i=0;$i<$nb;$i++) {
+            $kids .= (3+2*$i).' 0 R ';
+    }
     $this->_out($kids.']');
     $this->_out('/Count '.$nb);
     $this->_out(sprintf('/MediaBox [0 0 %.2F %.2F]',$wPt,$hPt));
@@ -1756,10 +1844,12 @@ 
         $this->FontFiles[$file]['n']=$this->n;
         $font='';
         $f=fopen($this->_getfontpath().$file,'rb',1);
-        if(!$f)
-            $this->Error('Font file not found');
-        while(!feof($f))
-            $font.=fread($f,8192);
+        if(!$f) {
+                    $this->Error('Font file not found');
+        }
+        while(!feof($f)) {
+                    $font.=fread($f,8192);
+        }
         fclose($f);
         $compressed=(substr($file,-2)=='.z');
         if(!$compressed && isset($info['length2']))
@@ -1777,11 +1867,13 @@ 
             }
         }
         $this->_out('<</Length '.strlen($font));
-        if($compressed)
-            $this->_out('/Filter /FlateDecode');
+        if($compressed) {
+                    $this->_out('/Filter /FlateDecode');
+        }
         $this->_out('/Length1 '.$info['length1']);
-        if(isset($info['length2']))
-            $this->_out('/Length2 '.$info['length2'].' /Length3 0');
+        if(isset($info['length2'])) {
+                    $this->_out('/Length2 '.$info['length2'].' /Length3 0');
+        }
         $this->_out('>>');
         $this->_putstream($font);
         $this->_out('endobj');
@@ -1801,12 +1893,12 @@ 
             $this->_out('<</Type /Font');
             $this->_out('/BaseFont /'.$name);
             $this->_out('/Subtype /Type1');
-            if($name!='Symbol' && $name!='ZapfDingbats')
-                $this->_out('/Encoding /WinAnsiEncoding');
+            if($name!='Symbol' && $name!='ZapfDingbats') {
+                            $this->_out('/Encoding /WinAnsiEncoding');
+            }
             $this->_out('>>');
             $this->_out('endobj');
-        }
-        elseif($type=='Type1' || $type=='TrueType')
+        } elseif($type=='Type1' || $type=='TrueType')
         {
             // Additional Type1 or TrueType font
             $this->fonts[$k]['n']=$this->n+1;
@@ -1819,10 +1911,11 @@ 
             $this->_out('/FontDescriptor '.($this->n+2).' 0 R');
             if($font['enc'])
             {
-                if(isset($font['diff']))
-                    $this->_out('/Encoding '.($nf+$font['diff']).' 0 R');
-                else
-                    $this->_out('/Encoding /WinAnsiEncoding');
+                if(isset($font['diff'])) {
+                                    $this->_out('/Encoding '.($nf+$font['diff']).' 0 R');
+                } else {
+                                    $this->_out('/Encoding /WinAnsiEncoding');
+                }
             }
             $this->_out('>>');
             $this->_out('endobj');
@@ -1830,18 +1923,21 @@ 
             $this->_newobj();
             $cw=&$font['cw'];
             $s='[';
-            for($i=32;$i<=255;$i++)
-                $s.=$cw[chr($i)].' ';
+            for($i=32;$i<=255;$i++) {
+                            $s.=$cw[chr($i)].' ';
+            }
             $this->_out($s.']');
             $this->_out('endobj');
             // Descriptor
             $this->_newobj();
             $s='<</Type /FontDescriptor /FontName /'.$name;
-            foreach($font['desc'] as $k=>$v)
-                $s.=' /'.$k.' '.$v;
+            foreach($font['desc'] as $k=>$v) {
+                            $s.=' /'.$k.' '.$v;
+            }
             $file=$font['file'];
-            if($file)
-                $s.=' /FontFile'.($type=='Type1' ? '' : '2').' '.$this->FontFiles[$file]['n'].' 0 R';
+            if($file) {
+                            $s.=' /FontFile'.($type=='Type1' ? '' : '2').' '.$this->FontFiles[$file]['n'].' 0 R';
+            }
             $this->_out($s.'>>');
             $this->_out('endobj');
         }
@@ -1960,14 +2056,14 @@ 
             $this->_putstream($fontstream);
             $this->_out('endobj');
             unset($ttf);
-        }
-        else
+        } else
         {
             // Allow for additional types
             $this->fonts[$k]['n'] = $this->n+1;
             $mtd='_put'.strtolower($type);
-            if(!method_exists($this,$mtd))
-                $this->Error('Unsupported font type: '.$type);
+            if(!method_exists($this,$mtd)) {
+                            $this->Error('Unsupported font type: '.$type);
+            }
             $this->$mtd($font);
         }
     }
@@ -1977,8 +2073,7 @@ 
     if (file_exists($font['unifilename'].'.cw127.php')) {
         include($font['unifilename'].'.cw127.php') ;
         $startcid = 128;
-    }
-    else {
+    } else {
         $rangeid = 0;
         $range = array();
         $prevcid = -2;
@@ -1997,8 +2092,7 @@ 
                 $cw127.='$rangeid='.$rangeid.";\n";
                 $cw127.='$prevcid='.$prevcid.";\n";
                 $cw127.='$prevwidth='.$prevwidth.";\n";
-                if ($interval) { $cw127.='$interval=true'.";\n"; }
-                else { $cw127.='$interval=false'.";\n"; }
+                if ($interval) { $cw127.='$interval=true'.";\n"; } else { $cw127.='$interval=false'.";\n"; }
                 $cw127.='$range='.var_export($range,true).";\n";
                 $cw127.="?>";
                 fwrite($fh,$cw127,strlen($cw127));
@@ -2014,8 +2108,7 @@ 
                 if ($width == $prevwidth) {
                     if ($width == $range[$rangeid][0]) {
                         $range[$rangeid][] = $width;
-                    }
-                    else {
+                    } else {
                         array_pop($range[$rangeid]);
                         // new range
                         $rangeid = $prevcid;
@@ -2031,8 +2124,7 @@ 
                         $rangeid = $cid;
                         $range[$rangeid] = array();
                         $range[$rangeid][] = $width;
-                    }
-                    else { $range[$rangeid][] = $width; }
+                    } else { $range[$rangeid][] = $width; }
                     $interval = false;
                 }
             } else {
@@ -2054,21 +2146,17 @@ 
             if (isset($range[$k]['interval'])) { unset($range[$k]['interval']); }
             $range[$prevk] = array_merge($range[$prevk], $range[$k]);
             unset($range[$k]);
-        }
-        else { $prevk = $k; }
+        } else { $prevk = $k; }
         $nextk = $k + $cws;
         if (isset($ws['interval'])) {
-            if ($cws > 3) { $prevint = true; }
-            else { $prevint = false; }
+            if ($cws > 3) { $prevint = true; } else { $prevint = false; }
             unset($range[$k]['interval']);
             --$nextk;
-        }
-        else { $prevint = false; }
+        } else { $prevint = false; }
     }
     $w = '';
     foreach ($range as $k => $ws) {
-        if (count(array_count_values($ws)) == 1) { $w .= ' '.$k.' '.($k + count($ws) - 1).' '.$ws[0]; }
-        else { $w .= ' '.$k.' [ '.implode(' ', $ws).' ]' . "\n"; }
+        if (count(array_count_values($ws)) == 1) { $w .= ' '.$k.' '.($k + count($ws) - 1).' '.$ws[0]; } else { $w .= ' '.$k.' [ '.implode(' ', $ws).' ]' . "\n"; }
     }
     $this->_out('/W ['.$w.' ]');
 }
@@ -2091,28 +2179,33 @@ 
     $this->_out('/Subtype /Image');
     $this->_out('/Width '.$info['w']);
     $this->_out('/Height '.$info['h']);
-    if($info['cs']=='Indexed')
-        $this->_out('/ColorSpace [/Indexed /DeviceRGB '.(strlen($info['pal'])/3-1).' '.($this->n+1).' 0 R]');
-    else
+    if($info['cs']=='Indexed') {
+            $this->_out('/ColorSpace [/Indexed /DeviceRGB '.(strlen($info['pal'])/3-1).' '.($this->n+1).' 0 R]');
+    } else
     {
         $this->_out('/ColorSpace /'.$info['cs']);
-        if($info['cs']=='DeviceCMYK')
-            $this->_out('/Decode [1 0 1 0 1 0 1 0]');
+        if($info['cs']=='DeviceCMYK') {
+                    $this->_out('/Decode [1 0 1 0 1 0 1 0]');
+        }
     }
     $this->_out('/BitsPerComponent '.$info['bpc']);
-    if(isset($info['f']))
-        $this->_out('/Filter /'.$info['f']);
-    if(isset($info['dp']))
-        $this->_out('/DecodeParms <<'.$info['dp'].'>>');
+    if(isset($info['f'])) {
+            $this->_out('/Filter /'.$info['f']);
+    }
+    if(isset($info['dp'])) {
+            $this->_out('/DecodeParms <<'.$info['dp'].'>>');
+    }
     if(isset($info['trns']) && is_array($info['trns']))
     {
         $trns = '';
-        for($i=0;$i<count($info['trns']);$i++)
-            $trns .= $info['trns'][$i].' '.$info['trns'][$i].' ';
+        for($i=0;$i<count($info['trns']);$i++) {
+                    $trns .= $info['trns'][$i].' '.$info['trns'][$i].' ';
+        }
         $this->_out('/Mask ['.$trns.']');
     }
-    if(isset($info['smask']))
-        $this->_out('/SMask '.($this->n+1).' 0 R');
+    if(isset($info['smask'])) {
+            $this->_out('/SMask '.($this->n+1).' 0 R');
+    }
     $this->_out('/Length '.strlen($info['data']).'>>');
     $this->_putstream($info['data']);
     $this->_out('endobj');
@@ -2137,9 +2230,10 @@ 
 
 function _putxobjectdict()
 {
-    foreach($this->images as $image)
-        $this->_out('/I'.$image['i'].' '.$image['n'].' 0 R');
-}
+    foreach($this->images as $image) {
+            $this->_out('/I'.$image['i'].' '.$image['n'].' 0 R');
+    }
+    }
 
 function _putresourcedict()
 {
@@ -2170,16 +2264,21 @@ 
 function _putinfo()
 {
     $this->_out('/Producer '.$this->_textstring('tFPDF '.tFPDF_VERSION));
-    if(!empty($this->title))
-        $this->_out('/Title '.$this->_textstring($this->title));
-    if(!empty($this->subject))
-        $this->_out('/Subject '.$this->_textstring($this->subject));
-    if(!empty($this->author))
-        $this->_out('/Author '.$this->_textstring($this->author));
-    if(!empty($this->keywords))
-        $this->_out('/Keywords '.$this->_textstring($this->keywords));
-    if(!empty($this->creator))
-        $this->_out('/Creator '.$this->_textstring($this->creator));
+    if(!empty($this->title)) {
+            $this->_out('/Title '.$this->_textstring($this->title));
+    }
+    if(!empty($this->subject)) {
+            $this->_out('/Subject '.$this->_textstring($this->subject));
+    }
+    if(!empty($this->author)) {
+            $this->_out('/Author '.$this->_textstring($this->author));
+    }
+    if(!empty($this->keywords)) {
+            $this->_out('/Keywords '.$this->_textstring($this->keywords));
+    }
+    if(!empty($this->creator)) {
+            $this->_out('/Creator '.$this->_textstring($this->creator));
+    }
     $this->_out('/CreationDate '.$this->_textstring('D:'.@date('YmdHis')));
 }
 
@@ -2187,21 +2286,23 @@ 
 {
     $this->_out('/Type /Catalog');
     $this->_out('/Pages 1 0 R');
-    if($this->ZoomMode=='fullpage')
-        $this->_out('/OpenAction [3 0 R /Fit]');
-    elseif($this->ZoomMode=='fullwidth')
-        $this->_out('/OpenAction [3 0 R /FitH null]');
-    elseif($this->ZoomMode=='real')
-        $this->_out('/OpenAction [3 0 R /XYZ null null 1]');
-    elseif(!is_string($this->ZoomMode))
-        $this->_out('/OpenAction [3 0 R /XYZ null null '.sprintf('%.2F',$this->ZoomMode/100).']');
-    if($this->LayoutMode=='single')
-        $this->_out('/PageLayout /SinglePage');
-    elseif($this->LayoutMode=='continuous')
-        $this->_out('/PageLayout /OneColumn');
-    elseif($this->LayoutMode=='two')
-        $this->_out('/PageLayout /TwoColumnLeft');
-}
+    if($this->ZoomMode=='fullpage') {
+            $this->_out('/OpenAction [3 0 R /Fit]');
+    } elseif($this->ZoomMode=='fullwidth') {
+            $this->_out('/OpenAction [3 0 R /FitH null]');
+    } elseif($this->ZoomMode=='real') {
+            $this->_out('/OpenAction [3 0 R /XYZ null null 1]');
+    } elseif(!is_string($this->ZoomMode)) {
+            $this->_out('/OpenAction [3 0 R /XYZ null null '.sprintf('%.2F',$this->ZoomMode/100).']');
+    }
+    if($this->LayoutMode=='single') {
+            $this->_out('/PageLayout /SinglePage');
+    } elseif($this->LayoutMode=='continuous') {
+            $this->_out('/PageLayout /OneColumn');
+    } elseif($this->LayoutMode=='two') {
+            $this->_out('/PageLayout /TwoColumnLeft');
+    }
+    }
 
 function _putheader()
 {
@@ -2237,8 +2338,9 @@ 
     $this->_out('xref');
     $this->_out('0 '.($this->n+1));
     $this->_out('0000000000 65535 f ');
-    for($i=1;$i<=$this->n;$i++)
-        $this->_out(sprintf('%010d 00000 n ',$this->offsets[$i]));
+    for($i=1;$i<=$this->n;$i++) {
+            $this->_out(sprintf('%010d 00000 n ',$this->offsets[$i]));
+    }
     // Trailer
     $this->_out('trailer');
     $this->_out('<<');
@@ -2268,18 +2370,19 @@ 
    for ($i = 0; $i < $len; $i++) {
     $uni = -1;
       $h = ord($str[$i]);
-      if ( $h <= 0x7F )
-         $uni = $h;
-      elseif ( $h >= 0xC2 ) {
-         if ( ($h <= 0xDF) && ($i < $len -1) )
-            $uni = ($h & 0x1F) << 6 | (ord($str[++$i]) & 0x3F);
-         elseif ( ($h <= 0xEF) && ($i < $len -2) )
-            $uni = ($h & 0x0F) << 12 | (ord($str[++$i]) & 0x3F) << 6
+      if ( $h <= 0x7F ) {
+               $uni = $h;
+      } elseif ( $h >= 0xC2 ) {
+         if ( ($h <= 0xDF) && ($i < $len -1) ) {
+                     $uni = ($h & 0x1F) << 6 | (ord($str[++$i]) & 0x3F);
+         } elseif ( ($h <= 0xEF) && ($i < $len -2) ) {
+                     $uni = ($h & 0x0F) << 12 | (ord($str[++$i]) & 0x3F) << 6
                                        | (ord($str[++$i]) & 0x3F);
-         elseif ( ($h <= 0xF4) && ($i < $len -3) )
-            $uni = ($h & 0x0F) << 18 | (ord($str[++$i]) & 0x3F) << 12
+         } elseif ( ($h <= 0xF4) && ($i < $len -3) ) {
+                     $uni = ($h & 0x0F) << 18 | (ord($str[++$i]) & 0x3F) << 12
                                        | (ord($str[++$i]) & 0x3F) << 6
                                        | (ord($str[++$i]) & 0x3F);
+         }
       }
     if ($uni >= 0) {
         $out[] = $uni;

includes/libraries/phpcrypt/ciphers/3DES.php

Doc Comments +1 added lines, -2 removed lines

@@ -98,7 +98,6 @@ 
 	 * it into 3 64 bit parts, and then does the following
 	 * DES ENCRYPT(key1) -> DES DECRYPT(key2) -> DES ENCRYPT(key3)
 	 *
-	 * @param string $data A plain text string
 	 * @return boolean Returns true
 	 */
 	public function encrypt(&$text)
@@ -128,7 +127,6 @@ 
 	 * it into 3 64 bit parts, and then does the following
 	 * DES DECRYPT(key1) -> DES ENCRYPT(key2) -> DES DECRYPT(key3)
 	 *
-	 * @param string $encrypted A DES encrypted string
 	 * @return boolean Returns true
 	 */
 	public function decrypt(&$text)
@@ -229,6 +227,7 @@ 
 	 * to make a 24 byte key
 	 *
 	 * @param string $key The 8 or 16 byte key to expand
+	 * @param integer $len
 	 * @return string If the key given is 8 or 16 bytes it returns the
 	 *	expanded 24 byte key, else it returns the original key unexpanded
 	 */

Indentation +201 added lines, -201 removed lines

@@ -43,209 +43,209 @@
  */
 class Cipher_3DES extends Cipher_DES
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 8; // 64 bits
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 8; // 64 bits
 
-	/** @type integer BYTES_KEY The size of the key. The key can be
+    /** @type integer BYTES_KEY The size of the key. The key can be
 	8, 16, or 24 bytes but gets expanded to 24 bytes before used */
-	const BYTES_KEY = 24;
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		$key_len = strlen($key);
-
-		if($key_len == 8 || $key_len == 16)
-			$key = self::expandKey($key, $key_len);
-		else if($key_len < self::BYTES_KEY)
-		{
-			$msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
-			$msg .= "$key_len bytes received.";
-			trigger_error($msg, E_USER_WARNING);
-		}
-		// else if the key is longer than 24 bytes, phpCrypt will shorten it
-
-		// set the 3DES key, note that we call __construct1() not __construct()
-		// this is a second contructor we created for classes that extend the
-		// DES class
-		parent::__construct1(PHP_Crypt::CIPHER_3DES, $key, self::BYTES_KEY);
-
-		// 3DES requires that data is 64 bits
-		$this->blockSize(self::BYTES_BLOCK);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using TripleDES
-	 * For encryption 3DES takes a 192 bit key, splits
-	 * it into 3 64 bit parts, and then does the following
-	 * DES ENCRYPT(key1) -> DES DECRYPT(key2) -> DES ENCRYPT(key3)
-	 *
-	 * @param string $data A plain text string
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$blocksz = $this->blockSize();
-
-		for($i = 0; $i < 3; ++$i)
-		{
-			$key = substr($this->key(), ($i * 8), $blocksz);
-			$this->keyPermutation($key);
-
-			if($i % 2) // round 1
-				$this->operation(parent::DECRYPT);
-			else // rounds 0 and 2
-				$this->operation(parent::ENCRYPT);
-
-			$this->des($text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt a TripleDES encrypted string
-	 * For decryption 3DES takes a 192 bit key, splits
-	 * it into 3 64 bit parts, and then does the following
-	 * DES DECRYPT(key1) -> DES ENCRYPT(key2) -> DES DECRYPT(key3)
-	 *
-	 * @param string $encrypted A DES encrypted string
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$blocksz = $this->blockSize();
-
-		for($i = 2; $i >= 0; --$i)
-		{
-			$key = substr($this->key(), ($i * 8), $blocksz);
-			$this->keyPermutation($key);
-
-			if($i % 2) // round 1
-				$this->operation(parent::ENCRYPT);
-			else // round 0 and 2
-				$this->operation(parent::DECRYPT);
-
-			$this->des($text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * We overload the DES::keyPermutation() function so it takes
-	 * a 64 bit key as a parameter. This is because 3DES uses a 192 bit
-	 * key which is split into 3 64 bit parts, each of which must be
-	 * passed through the keyPermutation() function
-	 * Key permutation, based on tables $_pc1 and $_pc2
-	 * Create 16 subkeys, each of which is 48-bits long.
-	 * NOTE: The $key parameter is required, however because PHP expects
-	 * an overloaded method to contain the same number of parameters
-	 * (when E_STRICT is set) as the parent class, we make it optional
-	 * to shut the 'error' up
-	 *
-	 * @param string $key A 64 bit key
-	 * @return void
-	 */
-	private function keyPermutation($key = "")
-	{
-		$this->sub_keys = array();
-		$pc1m = array();
-		$pcr = array();
-		$c = array();
-		$d = array();
-
-		// convert the key to binary
-		$binkey = parent::str2Bin($key);
-
-		// reduce the key down to 56bits based on table $_pc1
-		for($i = 0; $i < 56; ++$i)
-		{
-			$pos = parent::$_pc1[$i] - 1;
+    const BYTES_KEY = 24;
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        $key_len = strlen($key);
+
+        if($key_len == 8 || $key_len == 16)
+            $key = self::expandKey($key, $key_len);
+        else if($key_len < self::BYTES_KEY)
+        {
+            $msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
+            $msg .= "$key_len bytes received.";
+            trigger_error($msg, E_USER_WARNING);
+        }
+        // else if the key is longer than 24 bytes, phpCrypt will shorten it
+
+        // set the 3DES key, note that we call __construct1() not __construct()
+        // this is a second contructor we created for classes that extend the
+        // DES class
+        parent::__construct1(PHP_Crypt::CIPHER_3DES, $key, self::BYTES_KEY);
+
+        // 3DES requires that data is 64 bits
+        $this->blockSize(self::BYTES_BLOCK);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using TripleDES
+     * For encryption 3DES takes a 192 bit key, splits
+     * it into 3 64 bit parts, and then does the following
+     * DES ENCRYPT(key1) -> DES DECRYPT(key2) -> DES ENCRYPT(key3)
+     *
+     * @param string $data A plain text string
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $blocksz = $this->blockSize();
+
+        for($i = 0; $i < 3; ++$i)
+        {
+            $key = substr($this->key(), ($i * 8), $blocksz);
+            $this->keyPermutation($key);
+
+            if($i % 2) // round 1
+                $this->operation(parent::DECRYPT);
+            else // rounds 0 and 2
+                $this->operation(parent::ENCRYPT);
+
+            $this->des($text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt a TripleDES encrypted string
+     * For decryption 3DES takes a 192 bit key, splits
+     * it into 3 64 bit parts, and then does the following
+     * DES DECRYPT(key1) -> DES ENCRYPT(key2) -> DES DECRYPT(key3)
+     *
+     * @param string $encrypted A DES encrypted string
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $blocksz = $this->blockSize();
+
+        for($i = 2; $i >= 0; --$i)
+        {
+            $key = substr($this->key(), ($i * 8), $blocksz);
+            $this->keyPermutation($key);
+
+            if($i % 2) // round 1
+                $this->operation(parent::ENCRYPT);
+            else // round 0 and 2
+                $this->operation(parent::DECRYPT);
+
+            $this->des($text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * We overload the DES::keyPermutation() function so it takes
+     * a 64 bit key as a parameter. This is because 3DES uses a 192 bit
+     * key which is split into 3 64 bit parts, each of which must be
+     * passed through the keyPermutation() function
+     * Key permutation, based on tables $_pc1 and $_pc2
+     * Create 16 subkeys, each of which is 48-bits long.
+     * NOTE: The $key parameter is required, however because PHP expects
+     * an overloaded method to contain the same number of parameters
+     * (when E_STRICT is set) as the parent class, we make it optional
+     * to shut the 'error' up
+     *
+     * @param string $key A 64 bit key
+     * @return void
+     */
+    private function keyPermutation($key = "")
+    {
+        $this->sub_keys = array();
+        $pc1m = array();
+        $pcr = array();
+        $c = array();
+        $d = array();
+
+        // convert the key to binary
+        $binkey = parent::str2Bin($key);
+
+        // reduce the key down to 56bits based on table $_pc1
+        for($i = 0; $i < 56; ++$i)
+        {
+            $pos = parent::$_pc1[$i] - 1;
             $pc1m[$i] = $binkey[$pos];
-		}
-
-		// split $pc1m in half (C0 and D0)
-		$c[0] = array_slice($pc1m, 0, 28);
-		$d[0] = array_slice($pc1m, 28, 28);
-
-		// now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
-		// where 1 <= n <= 16
-		for($i = 1; $i <= 16; ++$i)
-		{
-			// now set the next Cn and Dn as the previous Cn and Dn
-			$c[$i] = $c[$i-1];
-			$d[$i] = $d[$i-1];
-
-			for($j = 0; $j < parent::$_key_sched[$i-1]; ++$j)
-			{
-				// do a left shift, move each bit one place to the left,
-				// except for the first bit, which is cycled to the end
-				// of the block.
-				$c[$i][] = array_shift($c[$i]);
-				$d[$i][] = array_shift($d[$i]);
-			}
-
-			// We now form the sub_keys (Kn), for 1<=n<=16, by applying the
-			// following permutation table to each of the concatenated
-			// pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
-			// of these.
-			$CnDn = array_merge($c[$i], $d[$i]);
-			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
-		}
-
-		// the sub_keys are created, we are done with the key permutation
-	}
-
-
-	/**
-	 * Triple DES accepts an 8, 16, or 24 bytes key. If the key is
-	 * 8 or 16 bytes, it is expanded to 24 bytes
-	 * An 8 byte key is expanded by repeating it 3 times to make a 24
-	 * byte key
-	 * A 16 byte key add the first 8 bytes to the end of the string
-	 * to make a 24 byte key
-	 *
-	 * @param string $key The 8 or 16 byte key to expand
-	 * @return string If the key given is 8 or 16 bytes it returns the
-	 *	expanded 24 byte key, else it returns the original key unexpanded
-	 */
-	private static function expandKey($key, $len)
-	{
-		// if we were given an 8 byte key, repeat it
-		// 3 times to produce a 24 byte key
-		if($len == 8)
-			$key = str_repeat($key, 3);
-
-		// if we were given a 16 byte key, add the first
-		// 8 bytes to the end of the key to produce 24 bytes
-		if($len == 16)
-			$key .= substr($key, 0, 8);
-
-		// return the key
-		return $key;
-	}
+        }
+
+        // split $pc1m in half (C0 and D0)
+        $c[0] = array_slice($pc1m, 0, 28);
+        $d[0] = array_slice($pc1m, 28, 28);
+
+        // now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
+        // where 1 <= n <= 16
+        for($i = 1; $i <= 16; ++$i)
+        {
+            // now set the next Cn and Dn as the previous Cn and Dn
+            $c[$i] = $c[$i-1];
+            $d[$i] = $d[$i-1];
+
+            for($j = 0; $j < parent::$_key_sched[$i-1]; ++$j)
+            {
+                // do a left shift, move each bit one place to the left,
+                // except for the first bit, which is cycled to the end
+                // of the block.
+                $c[$i][] = array_shift($c[$i]);
+                $d[$i][] = array_shift($d[$i]);
+            }
+
+            // We now form the sub_keys (Kn), for 1<=n<=16, by applying the
+            // following permutation table to each of the concatenated
+            // pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
+            // of these.
+            $CnDn = array_merge($c[$i], $d[$i]);
+            $this->sub_keys[$i-1] = "";
+            for($j = 0; $j < 48; ++$j)
+                $this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
+        }
+
+        // the sub_keys are created, we are done with the key permutation
+    }
+
+
+    /**
+     * Triple DES accepts an 8, 16, or 24 bytes key. If the key is
+     * 8 or 16 bytes, it is expanded to 24 bytes
+     * An 8 byte key is expanded by repeating it 3 times to make a 24
+     * byte key
+     * A 16 byte key add the first 8 bytes to the end of the string
+     * to make a 24 byte key
+     *
+     * @param string $key The 8 or 16 byte key to expand
+     * @return string If the key given is 8 or 16 bytes it returns the
+     *	expanded 24 byte key, else it returns the original key unexpanded
+     */
+    private static function expandKey($key, $len)
+    {
+        // if we were given an 8 byte key, repeat it
+        // 3 times to produce a 24 byte key
+        if($len == 8)
+            $key = str_repeat($key, 3);
+
+        // if we were given a 16 byte key, add the first
+        // 8 bytes to the end of the key to produce 24 bytes
+        if($len == 16)
+            $key .= substr($key, 0, 8);
+
+        // return the key
+        return $key;
+    }
 }
 ?>

Spacing +16 added lines, -16 removed lines

@@ -61,9 +61,9 @@ 
 	{
 		$key_len = strlen($key);
 
-		if($key_len == 8 || $key_len == 16)
+		if ($key_len == 8 || $key_len == 16)
 			$key = self::expandKey($key, $key_len);
-		else if($key_len < self::BYTES_KEY)
+		else if ($key_len < self::BYTES_KEY)
 		{
 			$msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
 			$msg .= "$key_len bytes received.";
@@ -105,12 +105,12 @@ 
 	{
 		$blocksz = $this->blockSize();
 
-		for($i = 0; $i < 3; ++$i)
+		for ($i = 0; $i < 3; ++$i)
 		{
 			$key = substr($this->key(), ($i * 8), $blocksz);
 			$this->keyPermutation($key);
 
-			if($i % 2) // round 1
+			if ($i % 2) // round 1
 				$this->operation(parent::DECRYPT);
 			else // rounds 0 and 2
 				$this->operation(parent::ENCRYPT);
@@ -135,12 +135,12 @@ 
 	{
 		$blocksz = $this->blockSize();
 
-		for($i = 2; $i >= 0; --$i)
+		for ($i = 2; $i >= 0; --$i)
 		{
 			$key = substr($this->key(), ($i * 8), $blocksz);
 			$this->keyPermutation($key);
 
-			if($i % 2) // round 1
+			if ($i % 2) // round 1
 				$this->operation(parent::ENCRYPT);
 			else // round 0 and 2
 				$this->operation(parent::DECRYPT);
@@ -179,7 +179,7 @@ 
 		$binkey = parent::str2Bin($key);
 
 		// reduce the key down to 56bits based on table $_pc1
-		for($i = 0; $i < 56; ++$i)
+		for ($i = 0; $i < 56; ++$i)
 		{
 			$pos = parent::$_pc1[$i] - 1;
             $pc1m[$i] = $binkey[$pos];
@@ -191,13 +191,13 @@ 
 
 		// now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
 		// where 1 <= n <= 16
-		for($i = 1; $i <= 16; ++$i)
+		for ($i = 1; $i <= 16; ++$i)
 		{
 			// now set the next Cn and Dn as the previous Cn and Dn
-			$c[$i] = $c[$i-1];
-			$d[$i] = $d[$i-1];
+			$c[$i] = $c[$i - 1];
+			$d[$i] = $d[$i - 1];
 
-			for($j = 0; $j < parent::$_key_sched[$i-1]; ++$j)
+			for ($j = 0; $j < parent::$_key_sched[$i - 1]; ++$j)
 			{
 				// do a left shift, move each bit one place to the left,
 				// except for the first bit, which is cycled to the end
@@ -211,9 +211,9 @@ 
 			// pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
 			// of these.
 			$CnDn = array_merge($c[$i], $d[$i]);
-			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
+			$this->sub_keys[$i - 1] = "";
+			for ($j = 0; $j < 48; ++$j)
+				$this->sub_keys[$i - 1] .= $CnDn[parent::$_pc2[$j] - 1];
 		}
 
 		// the sub_keys are created, we are done with the key permutation
@@ -236,12 +236,12 @@ 
 	{
 		// if we were given an 8 byte key, repeat it
 		// 3 times to produce a 24 byte key
-		if($len == 8)
+		if ($len == 8)
 			$key = str_repeat($key, 3);
 
 		// if we were given a 16 byte key, add the first
 		// 8 bytes to the end of the key to produce 24 bytes
-		if($len == 16)
+		if ($len == 16)
 			$key .= substr($key, 0, 8);
 
 		// return the key

Braces +22 added lines, -13 removed lines

@@ -61,9 +61,9 @@ 
 	{
 		$key_len = strlen($key);
 
-		if($key_len == 8 || $key_len == 16)
-			$key = self::expandKey($key, $key_len);
-		else if($key_len < self::BYTES_KEY)
+		if($key_len == 8 || $key_len == 16) {
+					$key = self::expandKey($key, $key_len);
+		} else if($key_len < self::BYTES_KEY)
 		{
 			$msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
 			$msg .= "$key_len bytes received.";
@@ -110,10 +110,13 @@ 
 			$key = substr($this->key(), ($i * 8), $blocksz);
 			$this->keyPermutation($key);
 
-			if($i % 2) // round 1
+			if($i % 2) {
+			    // round 1
 				$this->operation(parent::DECRYPT);
-			else // rounds 0 and 2
+			} else {
+			    // rounds 0 and 2
 				$this->operation(parent::ENCRYPT);
+			}
 
 			$this->des($text);
 		}
@@ -140,10 +143,13 @@ 
 			$key = substr($this->key(), ($i * 8), $blocksz);
 			$this->keyPermutation($key);
 
-			if($i % 2) // round 1
+			if($i % 2) {
+			    // round 1
 				$this->operation(parent::ENCRYPT);
-			else // round 0 and 2
+			} else {
+			    // round 0 and 2
 				$this->operation(parent::DECRYPT);
+			}
 
 			$this->des($text);
 		}
@@ -212,8 +218,9 @@ 
 			// of these.
 			$CnDn = array_merge($c[$i], $d[$i]);
 			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
+			for($j = 0; $j < 48; ++$j) {
+							$this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
+			}
 		}
 
 		// the sub_keys are created, we are done with the key permutation
@@ -236,13 +243,15 @@ 
 	{
 		// if we were given an 8 byte key, repeat it
 		// 3 times to produce a 24 byte key
-		if($len == 8)
-			$key = str_repeat($key, 3);
+		if($len == 8) {
+					$key = str_repeat($key, 3);
+		}
 
 		// if we were given a 16 byte key, add the first
 		// 8 bytes to the end of the key to produce 24 bytes
-		if($len == 16)
-			$key .= substr($key, 0, 8);
+		if($len == 16) {
+					$key .= substr($key, 0, 8);
+		}
 
 		// return the key
 		return $key;

includes/libraries/phpcrypt/ciphers/3Way.php

Doc Comments +1 added lines, -1 removed lines

@@ -247,7 +247,7 @@
 	 * NOTE: Please read the comments in the $this->gamma() function. This
 	 * function calls the $this->gamma() function which does not do anything.
 	 *
-	 * @param array $d A 3 element 32 bit integer array
+	 * @param integer[] $d A 3 element 32 bit integer array
 	 * @return void
 	 */
 	private function rho(&$d)

Indentation +277 added lines, -277 removed lines

@@ -51,186 +51,186 @@ 
  */
 class Cipher_3Way extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 12; // 96 bits;
-
-	/** @type integer BYTES_KEY The size of the key, in bytes */
-	const BYTES_KEY = 12; // 96 bits;
-
-	/** @type integer ROUNDS The number of rounds to implement */
-	const ROUNDS = 11;
-
-	/** @type array $_rconst_enc The round constants for encryption */
-	private static $_rcon_enc = array();
-
-	/** @type array $_rconst_enc The round constants for decryption */
-	private static $_rcon_dec = array();
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// set the key, make sure the required length is set in bytes
-		parent::__construct(PHP_Crypt::CIPHER_3WAY, $key, self::BYTES_KEY);
-
-		// set the block size
-		$this->blockSize(self::BYTES_BLOCK);
-
-		// initialize the round constants
-		$this->initTables();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data
-	 *
-	 * @param string $data A 96 bit plain data
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$data)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->threeway($data);
-	}
-
-
-	/**
-	 * Decrypt an encrypted string
-	 *
-	 * @param string $data A 96 bit block encrypted data
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$data)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->threeway($data);
-	}
-
-
-	/**
-	 * The same alorigthm is used for both Encryption, and Decryption
-	 *
-	 * @param string $data A 96 bit block of data
-	 * @return boolean Returns true
-	 */
-	private function threeway(&$data)
-	{
-		// first split $data into three 32 bit parts
-		$data = str_split($data, 4);
-		$data = array_map("parent::str2Dec", $data);
-
-		// split the key into three 32 bit parts
-		$key = str_split($this->key(), 4);
-		$key = array_map("parent::str2Dec", $key);
-
-		// determine which round constant to use
-		if($this->operation() == parent::ENCRYPT)
-			$rcon = self::$_rcon_enc;
-		else
-			$rcon = self::$_rcon_dec;
-
-		if($this->operation() == parent::DECRYPT)
-		{
-			$this->theta($key);
-			$this->invertBits($key);
-			$this->invertBits($data);
-		}
-
-		// 3Way uses 11 rounds
-		for($i = 0; $i < self::ROUNDS; ++$i)
-		{
-			$data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[$i] << 16));
-			$data[1] = parent::uInt32($data[1] ^ $key[1]);
-			$data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[$i]);
-
-			$this->rho($data);
-		}
-
-		$data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[self::ROUNDS] << 16));
-		$data[1] = parent::uInt32($data[1] ^ $key[1]);
-		$data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[self::ROUNDS]);
-
-		$this->theta($data);
-
-		if($this->operation() == parent::DECRYPT)
-			$this->invertBits($data);
-
-		// assemble the three 32 bit parts back to a 96 bit string
-		$data = parent::dec2Str($data[0], 4).parent::dec2Str($data[1], 4).
-				parent::dec2Str($data[2], 4);
-
-		return true;
-	}
-
-
-	/**
-	 * 3-Way's Theta function
-	 * This was translated from mcrypt's 3-Way theta() function
-	 *
-	 * @param array $d A 3 element array of 32 bit integers
-	 * @return void
-	 */
-	private function theta(&$d)
-	{
-		$tmp = array();
-
-		$tmp[0] = parent::uInt32(
-					$d[0] ^ ($d[0] >> 16) ^ ($d[1] << 16) ^ ($d[1] >> 16) ^ ($d[2] << 16) ^
-					($d[1] >> 24) ^ ($d[2] << 8) ^ ($d[2] >> 8) ^ ($d[0] << 24) ^ ($d[2] >> 16) ^
-					($d[0] << 16) ^ ($d[2] >> 24) ^ ($d[0] << 8)
-				);
-
-		$tmp[1] = parent::uInt32(
-					$d[1] ^ ($d[1] >> 16) ^ ($d[2] << 16) ^ ($d[2] >> 16) ^ ($d[0] << 16) ^
-					($d[2] >> 24) ^ ($d[0] << 8) ^ ($d[0] >> 8) ^ ($d[1] << 24) ^ ($d[0] >> 16) ^
-					($d[1] << 16) ^ ($d[0] >> 24) ^ ($d[1] << 8)
-				);
-
-		$tmp[2] = parent::uInt32(
-					$d[2] ^ ($d[2] >> 16) ^ ($d[0] << 16) ^ ($d[0] >> 16) ^ ($d[1] << 16) ^
-					($d[0] >> 24) ^ ($d[1] << 8) ^ ($d[1] >> 8) ^ ($d[2] << 24) ^ ($d[1] >> 16) ^
-					($d[2] << 16) ^ ($d[1] >> 24) ^ ($d[2] << 8)
-				);
-
-		$d = $tmp;
-	}
-
-
-	/**
-	 * 3-Ways gamma() function
-	 * NOTE: After extensive testing against mcrypt's 3way, it appears
-	 * mcrypt's 3way gamma() function does not modify the array passed into
-	 * it. During testing mcrypt's 3way gamma() function returned the exact
-	 * same values sent into it. I'm confused as to why this is, and
-	 * can't find enough information about 3-Way to know if this is correct
-	 * though I suspect it's not. For compatibility, I am going to make
-	 * phpCrypt's 3way gamma() function leave the values unmodified. I will change
-	 * this at a later date if I find this is incorrect and mcrypt has a bug
-	 *
-	 * This was translated from mcrypt's 3-Way gamma() function
-	 *
-	 * @param array $d A 3 element array of 32 bit integers
-	 * @return void
-	 */
-	private function gamma(&$d)
-	{
-		/*
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 12; // 96 bits;
+
+    /** @type integer BYTES_KEY The size of the key, in bytes */
+    const BYTES_KEY = 12; // 96 bits;
+
+    /** @type integer ROUNDS The number of rounds to implement */
+    const ROUNDS = 11;
+
+    /** @type array $_rconst_enc The round constants for encryption */
+    private static $_rcon_enc = array();
+
+    /** @type array $_rconst_enc The round constants for decryption */
+    private static $_rcon_dec = array();
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // set the key, make sure the required length is set in bytes
+        parent::__construct(PHP_Crypt::CIPHER_3WAY, $key, self::BYTES_KEY);
+
+        // set the block size
+        $this->blockSize(self::BYTES_BLOCK);
+
+        // initialize the round constants
+        $this->initTables();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data
+     *
+     * @param string $data A 96 bit plain data
+     * @return boolean Returns true
+     */
+    public function encrypt(&$data)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->threeway($data);
+    }
+
+
+    /**
+     * Decrypt an encrypted string
+     *
+     * @param string $data A 96 bit block encrypted data
+     * @return boolean Returns true
+     */
+    public function decrypt(&$data)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->threeway($data);
+    }
+
+
+    /**
+     * The same alorigthm is used for both Encryption, and Decryption
+     *
+     * @param string $data A 96 bit block of data
+     * @return boolean Returns true
+     */
+    private function threeway(&$data)
+    {
+        // first split $data into three 32 bit parts
+        $data = str_split($data, 4);
+        $data = array_map("parent::str2Dec", $data);
+
+        // split the key into three 32 bit parts
+        $key = str_split($this->key(), 4);
+        $key = array_map("parent::str2Dec", $key);
+
+        // determine which round constant to use
+        if($this->operation() == parent::ENCRYPT)
+            $rcon = self::$_rcon_enc;
+        else
+            $rcon = self::$_rcon_dec;
+
+        if($this->operation() == parent::DECRYPT)
+        {
+            $this->theta($key);
+            $this->invertBits($key);
+            $this->invertBits($data);
+        }
+
+        // 3Way uses 11 rounds
+        for($i = 0; $i < self::ROUNDS; ++$i)
+        {
+            $data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[$i] << 16));
+            $data[1] = parent::uInt32($data[1] ^ $key[1]);
+            $data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[$i]);
+
+            $this->rho($data);
+        }
+
+        $data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[self::ROUNDS] << 16));
+        $data[1] = parent::uInt32($data[1] ^ $key[1]);
+        $data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[self::ROUNDS]);
+
+        $this->theta($data);
+
+        if($this->operation() == parent::DECRYPT)
+            $this->invertBits($data);
+
+        // assemble the three 32 bit parts back to a 96 bit string
+        $data = parent::dec2Str($data[0], 4).parent::dec2Str($data[1], 4).
+                parent::dec2Str($data[2], 4);
+
+        return true;
+    }
+
+
+    /**
+     * 3-Way's Theta function
+     * This was translated from mcrypt's 3-Way theta() function
+     *
+     * @param array $d A 3 element array of 32 bit integers
+     * @return void
+     */
+    private function theta(&$d)
+    {
+        $tmp = array();
+
+        $tmp[0] = parent::uInt32(
+                    $d[0] ^ ($d[0] >> 16) ^ ($d[1] << 16) ^ ($d[1] >> 16) ^ ($d[2] << 16) ^
+                    ($d[1] >> 24) ^ ($d[2] << 8) ^ ($d[2] >> 8) ^ ($d[0] << 24) ^ ($d[2] >> 16) ^
+                    ($d[0] << 16) ^ ($d[2] >> 24) ^ ($d[0] << 8)
+                );
+
+        $tmp[1] = parent::uInt32(
+                    $d[1] ^ ($d[1] >> 16) ^ ($d[2] << 16) ^ ($d[2] >> 16) ^ ($d[0] << 16) ^
+                    ($d[2] >> 24) ^ ($d[0] << 8) ^ ($d[0] >> 8) ^ ($d[1] << 24) ^ ($d[0] >> 16) ^
+                    ($d[1] << 16) ^ ($d[0] >> 24) ^ ($d[1] << 8)
+                );
+
+        $tmp[2] = parent::uInt32(
+                    $d[2] ^ ($d[2] >> 16) ^ ($d[0] << 16) ^ ($d[0] >> 16) ^ ($d[1] << 16) ^
+                    ($d[0] >> 24) ^ ($d[1] << 8) ^ ($d[1] >> 8) ^ ($d[2] << 24) ^ ($d[1] >> 16) ^
+                    ($d[2] << 16) ^ ($d[1] >> 24) ^ ($d[2] << 8)
+                );
+
+        $d = $tmp;
+    }
+
+
+    /**
+     * 3-Ways gamma() function
+     * NOTE: After extensive testing against mcrypt's 3way, it appears
+     * mcrypt's 3way gamma() function does not modify the array passed into
+     * it. During testing mcrypt's 3way gamma() function returned the exact
+     * same values sent into it. I'm confused as to why this is, and
+     * can't find enough information about 3-Way to know if this is correct
+     * though I suspect it's not. For compatibility, I am going to make
+     * phpCrypt's 3way gamma() function leave the values unmodified. I will change
+     * this at a later date if I find this is incorrect and mcrypt has a bug
+     *
+     * This was translated from mcrypt's 3-Way gamma() function
+     *
+     * @param array $d A 3 element array of 32 bit integers
+     * @return void
+     */
+    private function gamma(&$d)
+    {
+        /*
 		$tmp = array();
 
 		$tmp[0] = parent::uInt32($d[0] ^ ($d[1] | (~$d[2])));
@@ -239,102 +239,102 @@ 
 
 		$d = $tmp;
 		*/
-	}
-
-
-	/**
-	 * Applies several of 3Way's functions used for encryption and decryption
-	 * NOTE: Please read the comments in the $this->gamma() function. This
-	 * function calls the $this->gamma() function which does not do anything.
-	 *
-	 * @param array $d A 3 element 32 bit integer array
-	 * @return void
-	 */
-	private function rho(&$d)
-	{
-		$this->theta($d);
-		$this->pi1($d);
-		$this->gamma($d);
-		$this->pi2($d);
-	}
-
-
-	/**
-	 * 3Way's PI_1 function
-	 * This was taken from mcrypt's 3-way pi_1() function
-	 *
-	 * @param array $d A 3 element 32 bit integer array
-	 * @return void
-	 */
-	private function pi1(&$d)
-	{
-		$d[0] = parent::uInt32(($d[0] >> 10) ^ ($d[0] << 22));
-		$d[2] = parent::uInt32(($d[2] << 1) ^ ($d[2] >> 31));
-	}
-
-
-	/**
-	 * 3Way's PI_2 function
-	 * This was taken from mcrypt's 3-way pi_2() function
-	 *
-	 * @param array $d A 3 element 32 bit integer array
-	 * @return void
-	 */
-	private function pi2(&$d)
-	{
-		$d[0] = parent::uInt32(($d[0] << 1) ^ ($d[0] >> 31));
-		$d[2] = parent::uInt32(($d[2] >> 10) ^ ($d[2] << 22));
-	}
-
-
-	/**
-	 * Reverse the bits of each element of array $d, and
-	 * reverses the order of array $d, used only during
-	 * decryption
-	 *
-	 * @param array $d A 3 element array of a 32 bit integers
-	 * @return void
-	 */
-	private function invertBits(&$d)
-	{
-		$d = array_map("parent::dec2Bin", $d);
-		$d = array_map("strrev", $d);
-		$d = array_map("parent::bin2Dec", $d);
-		$d = array_reverse($d);
-	}
-
-
-	/**
-	 * Initialize the tables used in 3Way Encryption.
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		// round constants for encryption
-		self::$_rcon_enc = array(
-			0x0B0B, 0x1616, 0x2C2C, 0x5858,
-			0xB0B0, 0x7171, 0xE2E2, 0xD5D5,
-			0xBBBB, 0x6767, 0xCECE, 0x8D8D
-		);
-
-		// round constants for decryption
-		self::$_rcon_dec = array(
-			0xB1B1, 0x7373, 0xE6E6, 0xDDDD,
-			0xABAB, 0x4747, 0x8E8E, 0x0D0D,
-			0x1A1A, 0x3434, 0x6868, 0xD0D0
-		);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+    }
+
+
+    /**
+     * Applies several of 3Way's functions used for encryption and decryption
+     * NOTE: Please read the comments in the $this->gamma() function. This
+     * function calls the $this->gamma() function which does not do anything.
+     *
+     * @param array $d A 3 element 32 bit integer array
+     * @return void
+     */
+    private function rho(&$d)
+    {
+        $this->theta($d);
+        $this->pi1($d);
+        $this->gamma($d);
+        $this->pi2($d);
+    }
+
+
+    /**
+     * 3Way's PI_1 function
+     * This was taken from mcrypt's 3-way pi_1() function
+     *
+     * @param array $d A 3 element 32 bit integer array
+     * @return void
+     */
+    private function pi1(&$d)
+    {
+        $d[0] = parent::uInt32(($d[0] >> 10) ^ ($d[0] << 22));
+        $d[2] = parent::uInt32(($d[2] << 1) ^ ($d[2] >> 31));
+    }
+
+
+    /**
+     * 3Way's PI_2 function
+     * This was taken from mcrypt's 3-way pi_2() function
+     *
+     * @param array $d A 3 element 32 bit integer array
+     * @return void
+     */
+    private function pi2(&$d)
+    {
+        $d[0] = parent::uInt32(($d[0] << 1) ^ ($d[0] >> 31));
+        $d[2] = parent::uInt32(($d[2] >> 10) ^ ($d[2] << 22));
+    }
+
+
+    /**
+     * Reverse the bits of each element of array $d, and
+     * reverses the order of array $d, used only during
+     * decryption
+     *
+     * @param array $d A 3 element array of a 32 bit integers
+     * @return void
+     */
+    private function invertBits(&$d)
+    {
+        $d = array_map("parent::dec2Bin", $d);
+        $d = array_map("strrev", $d);
+        $d = array_map("parent::bin2Dec", $d);
+        $d = array_reverse($d);
+    }
+
+
+    /**
+     * Initialize the tables used in 3Way Encryption.
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        // round constants for encryption
+        self::$_rcon_enc = array(
+            0x0B0B, 0x1616, 0x2C2C, 0x5858,
+            0xB0B0, 0x7171, 0xE2E2, 0xD5D5,
+            0xBBBB, 0x6767, 0xCECE, 0x8D8D
+        );
+
+        // round constants for decryption
+        self::$_rcon_dec = array(
+            0xB1B1, 0x7373, 0xE6E6, 0xDDDD,
+            0xABAB, 0x4747, 0x8E8E, 0x0D0D,
+            0x1A1A, 0x3434, 0x6868, 0xD0D0
+        );
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

Spacing +4 added lines, -4 removed lines

@@ -140,12 +140,12 @@ 
 		$key = array_map("parent::str2Dec", $key);
 
 		// determine which round constant to use
-		if($this->operation() == parent::ENCRYPT)
+		if ($this->operation() == parent::ENCRYPT)
 			$rcon = self::$_rcon_enc;
 		else
 			$rcon = self::$_rcon_dec;
 
-		if($this->operation() == parent::DECRYPT)
+		if ($this->operation() == parent::DECRYPT)
 		{
 			$this->theta($key);
 			$this->invertBits($key);
@@ -153,7 +153,7 @@ 
 		}
 
 		// 3Way uses 11 rounds
-		for($i = 0; $i < self::ROUNDS; ++$i)
+		for ($i = 0; $i < self::ROUNDS; ++$i)
 		{
 			$data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[$i] << 16));
 			$data[1] = parent::uInt32($data[1] ^ $key[1]);
@@ -168,7 +168,7 @@ 
 
 		$this->theta($data);
 
-		if($this->operation() == parent::DECRYPT)
+		if ($this->operation() == parent::DECRYPT)
 			$this->invertBits($data);
 
 		// assemble the three 32 bit parts back to a 96 bit string

Braces +8 added lines, -6 removed lines

@@ -140,10 +140,11 @@ 
 		$key = array_map("parent::str2Dec", $key);
 
 		// determine which round constant to use
-		if($this->operation() == parent::ENCRYPT)
-			$rcon = self::$_rcon_enc;
-		else
-			$rcon = self::$_rcon_dec;
+		if($this->operation() == parent::ENCRYPT) {
+					$rcon = self::$_rcon_enc;
+		} else {
+					$rcon = self::$_rcon_dec;
+		}
 
 		if($this->operation() == parent::DECRYPT)
 		{
@@ -168,8 +169,9 @@ 
 
 		$this->theta($data);
 
-		if($this->operation() == parent::DECRYPT)
-			$this->invertBits($data);
+		if($this->operation() == parent::DECRYPT) {
+					$this->invertBits($data);
+		}
 
 		// assemble the three 32 bit parts back to a 96 bit string
 		$data = parent::dec2Str($data[0], 4).parent::dec2Str($data[1], 4).

includes/libraries/phpcrypt/ciphers/ARC4.php

Doc Comments -2 removed lines

@@ -73,7 +73,6 @@ 
 	/**
 	 * Encrypt plain text data using ARC4
 	 *
-	 * @param string $data A plain text string, 8 bytes long
 	 * @return boolean Returns true
 	 */
 	public function encrypt(&$text)
@@ -86,7 +85,6 @@ 
 	/**
 	 * Decrypt a ARC4 encrypted string
 	 *
-	 * @param string $encrypted A ARC4 encrypted string, 8 bytes long
 	 * @return boolean Returns true
 	 */
 	public function decrypt(&$text)

Indentation +158 added lines, -158 removed lines

@@ -39,163 +39,163 @@
  */
 class Cipher_ARC4 extends Cipher
 {
-	/** @type string $_s The S List */
-	private $_s = "";
-
-	/** @type string $_key_stream The Key Stream */
-	private $_key_stream = "";
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// set the ARC4 key
-		parent::__construct(PHP_Crypt::CIPHER_ARC4, $key);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using ARC4
-	 *
-	 * @param string $data A plain text string, 8 bytes long
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->arc4($text);
-	}
-
-
-	/**
-	 * Decrypt a ARC4 encrypted string
-	 *
-	 * @param string $encrypted A ARC4 encrypted string, 8 bytes long
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->arc4($text);
-	}
-
-
-	/**
-	 * Performs the ARC4 algorithm, since encryption and decryption
-	 * are the same, all the work is done here
-	 *
-	 * @param string $text The string to encrypt/decrypt
-	 * @return boolean Returns true
-	 */
-	private function arc4(&$text)
-	{
-		$len = strlen($text);
-		$this->prga($len);
-
-		for($i = 0; $i < $len; ++$i)
-			$text[$i] = $text[$i] ^ $this->_key_stream[$i];
-
-		return true;
-	}
-
-
-	/**
-	 * The key scheduling algorithm (KSA)
-	 *
-	 * @return void
-	 */
-	private function ksa()
-	{
-		$j = 0;
-		$this->_s = array();
-		$keylen = $this->keySize();
-		$key = $this->key();
-
-		// fill $this->_s with all the values from 0-255
-		for($i = 0; $i < 256; ++$i)
-			$this->_s[$i] = $i;
-
-		// the changing S List
-		for($i = 0; $i < 256; ++$i)
-		{
-			$k = $key[$i % $keylen];
-			$j = ($j + $this->_s[$i] + ord($k)) % 256;
-
-			// swap bytes
-			self::swapBytes($this->_s[$i], $this->_s[$j]);
-		}
-	}
-
-
-	/**
-	 * The Pseudo-Random Generation Algorithm (PGRA)
-	 * Creates the key stream used for encryption / decryption
-	 *
-	 * @param integer $data_len The length of the data we are encrypting/decrypting
-	 * @return void
-	 */
-	private function prga($data_len)
-	{
-		$i = 0;
-		$j = 0;
-		$this->_key_stream = "";
-
-		// set up the key schedule
-		$this->ksa();
-
-		for($c = 0; $c < $data_len; ++$c)
-		{
-			$i = ($i + 1) % 256;
-			$j = ($j + $this->_s[$i]) % 256;
-
-			// swap bytes
-			self::swapBytes($this->_s[$i], $this->_s[$j]);
-
-			$pos = ($this->_s[$i] + $this->_s[$j]) % 256;
-			$this->_key_stream .= chr($this->_s[$pos]);
-		}
-	}
-
-
-	/**
-	 * Swap two individual bytes
-	 *
-	 * @param string $a A single byte
-	 * @param string $b A single byte
-	 * @return void
-	 */
-	private static function swapBytes(&$a, &$b)
-	{
-		$tmp = $a;
-		$a = $b;
-		$b = $tmp;
-	}
-
-
-	/**
-	 * Indicates that this is a stream cipher
-	 *
-	 * @return integer Returns Cipher::STREAM
-	 */
-	public function type()
-	{
-		return parent::STREAM;
-	}
+    /** @type string $_s The S List */
+    private $_s = "";
+
+    /** @type string $_key_stream The Key Stream */
+    private $_key_stream = "";
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // set the ARC4 key
+        parent::__construct(PHP_Crypt::CIPHER_ARC4, $key);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using ARC4
+     *
+     * @param string $data A plain text string, 8 bytes long
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->arc4($text);
+    }
+
+
+    /**
+     * Decrypt a ARC4 encrypted string
+     *
+     * @param string $encrypted A ARC4 encrypted string, 8 bytes long
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->arc4($text);
+    }
+
+
+    /**
+     * Performs the ARC4 algorithm, since encryption and decryption
+     * are the same, all the work is done here
+     *
+     * @param string $text The string to encrypt/decrypt
+     * @return boolean Returns true
+     */
+    private function arc4(&$text)
+    {
+        $len = strlen($text);
+        $this->prga($len);
+
+        for($i = 0; $i < $len; ++$i)
+            $text[$i] = $text[$i] ^ $this->_key_stream[$i];
+
+        return true;
+    }
+
+
+    /**
+     * The key scheduling algorithm (KSA)
+     *
+     * @return void
+     */
+    private function ksa()
+    {
+        $j = 0;
+        $this->_s = array();
+        $keylen = $this->keySize();
+        $key = $this->key();
+
+        // fill $this->_s with all the values from 0-255
+        for($i = 0; $i < 256; ++$i)
+            $this->_s[$i] = $i;
+
+        // the changing S List
+        for($i = 0; $i < 256; ++$i)
+        {
+            $k = $key[$i % $keylen];
+            $j = ($j + $this->_s[$i] + ord($k)) % 256;
+
+            // swap bytes
+            self::swapBytes($this->_s[$i], $this->_s[$j]);
+        }
+    }
+
+
+    /**
+     * The Pseudo-Random Generation Algorithm (PGRA)
+     * Creates the key stream used for encryption / decryption
+     *
+     * @param integer $data_len The length of the data we are encrypting/decrypting
+     * @return void
+     */
+    private function prga($data_len)
+    {
+        $i = 0;
+        $j = 0;
+        $this->_key_stream = "";
+
+        // set up the key schedule
+        $this->ksa();
+
+        for($c = 0; $c < $data_len; ++$c)
+        {
+            $i = ($i + 1) % 256;
+            $j = ($j + $this->_s[$i]) % 256;
+
+            // swap bytes
+            self::swapBytes($this->_s[$i], $this->_s[$j]);
+
+            $pos = ($this->_s[$i] + $this->_s[$j]) % 256;
+            $this->_key_stream .= chr($this->_s[$pos]);
+        }
+    }
+
+
+    /**
+     * Swap two individual bytes
+     *
+     * @param string $a A single byte
+     * @param string $b A single byte
+     * @return void
+     */
+    private static function swapBytes(&$a, &$b)
+    {
+        $tmp = $a;
+        $a = $b;
+        $b = $tmp;
+    }
+
+
+    /**
+     * Indicates that this is a stream cipher
+     *
+     * @return integer Returns Cipher::STREAM
+     */
+    public function type()
+    {
+        return parent::STREAM;
+    }
 }
 ?>

Spacing +4 added lines, -4 removed lines

@@ -108,7 +108,7 @@ 
 		$len = strlen($text);
 		$this->prga($len);
 
-		for($i = 0; $i < $len; ++$i)
+		for ($i = 0; $i < $len; ++$i)
 			$text[$i] = $text[$i] ^ $this->_key_stream[$i];
 
 		return true;
@@ -128,11 +128,11 @@ 
 		$key = $this->key();
 
 		// fill $this->_s with all the values from 0-255
-		for($i = 0; $i < 256; ++$i)
+		for ($i = 0; $i < 256; ++$i)
 			$this->_s[$i] = $i;
 
 		// the changing S List
-		for($i = 0; $i < 256; ++$i)
+		for ($i = 0; $i < 256; ++$i)
 		{
 			$k = $key[$i % $keylen];
 			$j = ($j + $this->_s[$i] + ord($k)) % 256;
@@ -159,7 +159,7 @@ 
 		// set up the key schedule
 		$this->ksa();
 
-		for($c = 0; $c < $data_len; ++$c)
+		for ($c = 0; $c < $data_len; ++$c)
 		{
 			$i = ($i + 1) % 256;
 			$j = ($j + $this->_s[$i]) % 256;

Braces +6 added lines, -4 removed lines

@@ -108,8 +108,9 @@ 
 		$len = strlen($text);
 		$this->prga($len);
 
-		for($i = 0; $i < $len; ++$i)
-			$text[$i] = $text[$i] ^ $this->_key_stream[$i];
+		for($i = 0; $i < $len; ++$i) {
+					$text[$i] = $text[$i] ^ $this->_key_stream[$i];
+		}
 
 		return true;
 	}
@@ -128,8 +129,9 @@ 
 		$key = $this->key();
 
 		// fill $this->_s with all the values from 0-255
-		for($i = 0; $i < 256; ++$i)
-			$this->_s[$i] = $i;
+		for($i = 0; $i < 256; ++$i) {
+					$this->_s[$i] = $i;
+		}
 
 		// the changing S List
 		for($i = 0; $i < 256; ++$i)