linea21-externals
[ class tree: linea21-externals ] [ index: linea21-externals ] [ all elements ]

Source for file Div.php

Documentation is available at Div.php

  1. <?php
  2.  
  3. /**
  4.  * Class of the HTML_Div renderer
  5.  *
  6.  * Idea from the debug system of the symfony PHP framework
  7.  * @package    linea21.externals
  8.  * @subpackage PHP_DEBUG
  9.  * @author     Vernet Loïc <qrf_coil[at]yahoo.fr>, Fabien Potencier, François Zaninotto
  10.  * @see http://www.symfony-project.org
  11.  *
  12.  * @version CVS: $Id: Div.php,v 1.3 2008/10/05 14:41:37 c0il Exp $
  13.  */
  14.  
  15. require_once dirname(__FILE__.'/DivConfig.php';
  16.  
  17.  
  18. /**
  19.  * A floating div renderer for PHP_Debug
  20.  *
  21.  * Returns a floating based representation of the debug infos in XHTML sctrict
  22.  * format
  23.  *
  24.  * @package    linea21.externals
  25.  * @subpackage PHP_DEBUG
  26.  * @category PHP
  27.  * @author Loïc Vernet <qrf_coil at yahoo dot fr>
  28.  * @since V2.1.0 - 30 march 2007
  29.  *
  30.  * @filesource
  31.  */
  32.  
  33. {
  34.   // debug types for Vars & Config
  35.   protected static $settingsType array(
  36.   PHP_DebugLine::TYPE_ENV,
  37.   );
  38.  
  39.   // debug types for Log & Message tab
  40.   protected static $msgTypes array(
  41.   PHP_DebugLine::TYPE_STD,
  42.   PHP_DebugLine::TYPE_PAGEACTION,
  43.   PHP_DebugLine::TYPE_APPERROR,
  44.   PHP_DebugLine::TYPE_CREDITS,
  45.   PHP_DebugLine::TYPE_DUMP,
  46.   PHP_DebugLine::TYPE_WATCH,
  47.   PHP_DebugLine::TYPE_PHPERROR
  48.   );
  49.  
  50.   // debug types for Database tab
  51.   protected static $databaseTypes array(
  52.   PHP_DebugLine::TYPE_QUERY,
  53.   PHP_DebugLine::TYPE_QUERYREL,
  54.   PHP_DebugLine::TYPE_SQLPARSE,
  55.   );
  56.  
  57.   /**
  58.    * Debug_Renderer_HTML_Div class constructor
  59.    *
  60.    * @since V2.1.0 - 3 apr 2007
  61.    */
  62.   function __construct($DebugObject$options)
  63.   {
  64.     $this->DebugObject = $DebugObject;
  65.     $this->defaultOptions = PHP_Debug_Renderer_HTML_DivConfig::singleton()->getConfig();
  66.     $this->setOptions($options);
  67.  
  68.     if ($this->options['HTML_DIV_disable_credits'== false{
  69.       $this->DebugObject->addDebugFirst($this->options['HTML_DIV_credits'],
  70.       PHP_DebugLine::TYPE_CREDITS);
  71.     }
  72.  
  73.     // Add execution time
  74.     $this->DebugObject->addProcessPerf();
  75.   }
  76.  
  77.   /**
  78.    * This is the function to display the debug informations
  79.    *
  80.    * @since V2.0.0 - 07 Apr 2006
  81.    * @see PHP_Debug::Render()
  82.    */
  83.   public function display()
  84.   {
  85.     $buffer '';
  86.  
  87.     // Header
  88.     $buffer .= $this->displayHeader();
  89.  
  90.     // Infos
  91.     $debugInfos $this->DebugObject->getDebugBuffer();
  92.      
  93.     // Vars & config
  94.     $buffer .= $this->showVarsAndConfig($debugInfos);
  95.  
  96.     // Logs & msg
  97.     $buffer .= $this->showLogsAndMsg($debugInfos);
  98.  
  99.     // Database
  100.     $buffer .= $this->showDatabaseInfos($debugInfos);
  101.  
  102.     // W3C Validation
  103.     $buffer .= $this->showW3cValidation($debugInfos);
  104.  
  105.     // Process time
  106.     $buffer .= $this->showProcessTime($debugInfos);
  107.  
  108.     // Footer
  109.     $buffer .= $this->displayFooter();
  110.  
  111.     return $buffer;
  112.   }
  113.  
  114.   /**
  115.    * Show W3C validator tab
  116.    *
  117.    * @author COil
  118.    * @since V2.1.1 - 23 apr 2007
  119.    */
  120.   protected function showW3cValidation()
  121.   {
  122.     return str_replace(
  123.     array(
  124.                 '{$imagesPath}',
  125.     ),
  126.     array(
  127.     $this->options['HTML_DIV_images_path']
  128.     ),
  129.     $this->options['HTML_DIV_sfWebDebugW3CDetails']
  130.     );
  131.   }
  132.  
  133.   /**
  134.    * Add the debug informations of the W3C validation process
  135.    *
  136.    * @author Vernet Loïc
  137.    * @since 2.1.0 - 23 avr. 2007
  138.    */
  139.   protected function addW3CErrorInfos($res$key)
  140.   {
  141.     $title ucwords($key);
  142.     $type 'sfW3C'$title;
  143.     $errorCpt 1;
  144.     $results str_replace(
  145.           '{$title}',
  146.     $title,
  147.     $this->options['HTML_DIV_sfWebDebugW3CTableHeader']
  148.     );
  149.  
  150.     foreach ($res->$key as $error{
  151.       $id $errorCpt($error->messageid ' ('$error->messageid')' '');
  152.       $results .= str_replace(
  153.       array(
  154.                     '{$type}',
  155.                     '{$cpt}',
  156.                     '{$line}',
  157.                     '{$col}',
  158.                     '{$message}',
  159.                     '{$source}',
  160.       ),
  161.       array(
  162.       $type,
  163.       $id,
  164.       $error->line,
  165.       $error->col,
  166.       $error->message,
  167.                     '&nbsp',
  168.       ),
  169.       $this->options['HTML_DIV_sfWebDebugW3CErrorRow']
  170.       );
  171.       $errorCpt++;
  172.     }
  173.     $results .= '</table>';
  174.  
  175.     return $results;
  176.   }
  177.  
  178.   /**
  179.    * Shows vars & config
  180.    *
  181.    * @param array debug row
  182.    *
  183.    * @author COil
  184.    * @since V2.1.0 - 30 march 2007
  185.    */
  186.   protected function showDatabaseInfos($debugInfos)
  187.   {
  188.     $idx 1;
  189.     $buffer '';
  190.  
  191.     foreach ($debugInfos as $debugInfo{
  192.       $properties $debugInfo->getProperties();
  193.       if (in_array($properties['type']self::$databaseTypes)) {
  194.         $buffer.= '<li>['$this->processExecTime($properties)'] '.
  195.         $this->processDebugInfo($properties.'</li>'CR;
  196.       }
  197.     }
  198.  
  199.     return str_replace(
  200.     array('{$buffer}'),
  201.     array($buffer $buffer '<li>No database debug available</li>'),
  202.     $this->options['HTML_DIV_sfWebDebugDatabaseDetails']
  203.     );
  204.   }
  205.  
  206.   /**
  207.    * Shows vars & config
  208.    *
  209.    * @author COil
  210.    * @since V2.1.0 - 30 march 2007
  211.    */
  212.   protected function showLogsAndMsg($debugInfos)
  213.   {
  214.     $idx 1;
  215.     $buffer '';
  216.  
  217.     foreach($debugInfos as $debugInfo{
  218.       $properties $debugInfo->getProperties();
  219.       if (in_array($properties['type']self::$msgTypes)) {
  220.  
  221.         // Error level of debug information
  222.         $level $this->getLogInfoLevel($properties);
  223.         $infoImg $this->getImageInfo($level);
  224.  
  225.         $buffer .= '<tr class=\'sfWebDebugLogLine '$this->getDebugLevelClass($level)'\'>
  226.                     <td class="sfWebDebugLogNumber"># '$idx'</td>
  227.                     <td class="sfWebDebugLogType">
  228.                         <img src="'$this->options['HTML_DIV_images_path']'/'$infoImg .'" alt="" />&nbsp;'$this->processType($properties).
  229.                     '</td>
  230.                     <td class="sfWebDebugLogFile">'$this->processFile($properties)'</td>
  231.                     <td class="sfWebDebugLogLine">'$this->processLine($properties)'</td>
  232.                     <td class="sfWebDebugLogClass">'$this->processClass($properties)'</td>
  233.                     <td class="sfWebDebugLogFunction">'$this->processFunction($properties)'</td>
  234.                     <td class="sfWebDebugLogTime">'$this->processExecTime($properties)'</td>
  235.                     <td class="sfWebDebugLogMessage">'$this->processDebugInfo($properties)'</td>
  236.                 </tr>'CR;
  237.         $idx++;
  238.       }
  239.     }
  240.  
  241.     return str_replace(
  242.     array(
  243.                 '{$buffer}',
  244.                 '{$imagesPath}',
  245.     ),
  246.     array(
  247.     $buffer,
  248.     $this->options['HTML_DIV_images_path']
  249.     ),
  250.     $this->options['HTML_DIV_sfWebDebugLog']
  251.     );
  252.   }
  253.  
  254.   /**
  255.    * Get the log level of the debug info
  256.    *
  257.    * @author COil
  258.    * @since V2.1.0 - 2 avr. 2007
  259.    *
  260.    * @param array debug row
  261.    */
  262.   protected function getLogInfoLevel($properties)
  263.   {
  264.     $level PHP_DebugLine::INFO_LEVEL;
  265.  
  266.     switch ($properties['type']{
  267.       case PHP_DebugLine::TYPE_PAGEACTION:
  268.       case PHP_DebugLine::TYPE_CREDITS:
  269.       case PHP_DebugLine::TYPE_DUMP:
  270.       case PHP_DebugLine::TYPE_WATCH:
  271.         break;
  272.  
  273.       case PHP_DebugLine::TYPE_APPERROR:
  274.         $level PHP_DebugLine::ERROR_LEVEL;
  275.         break;
  276.  
  277.       case PHP_DebugLine::TYPE_PHPERROR:
  278.         $level $this->getPhpErrorLevel($properties);
  279.         break;
  280.     }
  281.  
  282.     return $level;
  283.   }
  284.  
  285.   /**
  286.    * Return the global error level corresponding to the related php error
  287.    * level
  288.    *
  289.    * @param array debug row
  290.    *
  291.    * @author COil
  292.    * @since 2.1.0 - 3 apr 2007
  293.    */
  294.   protected function getPhpErrorLevel($properties)
  295.   {
  296.     $infos $properties['info'];
  297.  
  298.     switch ($infos[0]{
  299.       case E_ERROR:
  300.       case E_PARSE:
  301.       case E_CORE_ERROR:
  302.       case E_COMPILE_ERROR:
  303.       case E_USER_ERROR:
  304.         return PHP_DebugLine::ERROR_LEVEL;
  305.         break;
  306.  
  307.       case E_WARNING:
  308.       case E_CORE_WARNING:
  309.       case E_NOTICE:
  310.       case E_COMPILE_WARNING:
  311.       case E_USER_WARNING:
  312.       case E_USER_NOTICE:
  313.       case E_ALL:
  314.       case E_STRICT:
  315.       case E_RECOVERABLE_ERROR:
  316.         return PHP_DebugLine::WARNING_LEVEL;
  317.         break;
  318.  
  319.       default:
  320.         return PHP_DebugLine::ERROR_LEVEL;
  321.         break;
  322.     }
  323.   }
  324.  
  325.   /**
  326.    * Get the image info for the current debug type
  327.    *
  328.    * @author COil
  329.    * @since V2.1.0 - 2 avp 2007
  330.    */
  331.   protected function getDebugLevelClass($debug_level)
  332.   {
  333.     return $this->options['HTML_DIV_debug_level_classes'][$debug_level];
  334.   }
  335.  
  336.   /**
  337.    * Get the image info for the current debug type
  338.    *
  339.    * @author COil
  340.    * @since V2.1.0 - 2 avp 2007
  341.    */
  342.   protected function getImageInfo($debug_level)
  343.   {
  344.     $info $this->options['HTML_DIV_image_info'];
  345.     $warning $this->options['HTML_DIV_image_warning'];
  346.     $error   $this->options['HTML_DIV_image_error'];
  347.  
  348.     switch ($debug_level{
  349.       case PHP_DebugLine::INFO_LEVEL:
  350.         $level $info;
  351.         break;
  352.  
  353.       case PHP_DebugLine::WARNING_LEVEL:
  354.         $level $warning;
  355.         break;
  356.  
  357.       case PHP_DebugLine::ERROR_LEVEL:
  358.         $level $error;
  359.         break;
  360.     }
  361.  
  362.     return $level;
  363.   }
  364.  
  365.   /**
  366.    * Shows vars & config
  367.    *
  368.    * @author COil
  369.    * @since V2.1.0 - 30 march 2007
  370.    */
  371.   protected function showVarsAndConfig($debugInfos)
  372.   {
  373.     return str_replace(
  374.     array(
  375.                 '{$sfWebDebugRequest}',
  376.                 '{$sfWebDebugResponse}',
  377.                 '{$sfWebDebugSettings}',
  378.                 '{$sfWebDebugConstants}',
  379.                 '{$sfWebDebugGlobals}',
  380.                 '{$sfWebDebugPhp}',
  381.                 '{$sfWebDebugFiles}',
  382.                 '{$imagesPath}',
  383.     ),
  384.     array(
  385.     $this->showSuperArray(PHP_Debug::GLOBAL_REQUEST),
  386.     $this->showSuperArray(PHP_Debug::GLOBAL_COOKIE),
  387.     $this->showArray($this->settingsAsArray($debugInfos)'Settings'),
  388.     $this->showArray(get_defined_constants(true)),
  389.     $this->showArray($this->globalsAsArray()'Globals'),
  390.     $this->showArray($this->phpInfoAsArray()'PHP Infos'),
  391.     $this->showTemplates(),
  392.     $this->options['HTML_DIV_images_path'],
  393.     ),
  394.     $this->options['HTML_DIV_sfWebDebugConfig']
  395.     );
  396.   }
  397.  
  398.   /**
  399.    * Return all settings of application
  400.    *
  401.    * @author COil
  402.    * @since V2.1.0 - 2 apr 2007
  403.    */
  404.   public function settingsAsArray($debugInfos)
  405.   {
  406.     $settings array();
  407.     foreach($debugInfos as $debugInfo{
  408.       $infos $debugInfo->getProperties();
  409.       if (in_array($infos['type']self::$settingsType)) {
  410.         $settings[$infos['info'];
  411.       }
  412.     }
  413.  
  414.     return $settings;
  415.   }
  416.  
  417.   /**
  418.    * Returns PHP globals variables as a sorted array.
  419.    *
  420.    * @return array PHP globals
  421.    * @since V2.1.0 - 2 apr 2007
  422.    */
  423.   public static function globalsAsArray()
  424.   {
  425.     $values array();
  426.     foreach (array('cookie''server''get''post''files''env''session'as $name{
  427.  
  428.       if (!isset($GLOBALS['_'.strtoupper($name)])) {
  429.         continue;
  430.       }
  431.  
  432.       $values[$namearray();
  433.       foreach ($GLOBALS['_'strtoupper($name)as $key => $value{
  434.         $values[$name][$key$value;
  435.       }
  436.       ksort($values[$name]);
  437.     }
  438.  
  439.     ksort($values);
  440.  
  441.     return $values;
  442.   }
  443.  
  444.   /**
  445.    * Returns PHP information as an array.
  446.    *
  447.    * @return  array An array of php information
  448.    * @since V2.1.0 - 2 apr 2007
  449.    */
  450.   public static function phpInfoAsArray()
  451.   {
  452.     $values array(
  453.             'php'        => phpversion(),
  454.             'os'         => php_uname(),
  455.             'extensions' => get_loaded_extensions(),
  456.     );
  457.  
  458.     // assign extension version if available
  459.     if ($values['extensions']{
  460.       foreach ($values['extensions'as $lkey => $extension{
  461.         $values['extensions'][$lkeyphpversion($extension$extension.
  462.                     ' ('phpversion($extension)')' $extension;
  463.       }
  464.     }
  465.  
  466.     return $values;
  467.   }
  468.  
  469.   /**
  470.    * Add the process time information to the debug information
  471.    *
  472.    * @since V2.0.0 - 18 Apr 2006
  473.    */
  474.   protected function showProcessTime($debugInfos)
  475.   {
  476.     // Lang
  477.     $txtExecutionTime 'Global execution time ';
  478.     $txtPHP           'PHP';
  479.     $txtSQL           'SQL';
  480.     $txtSECOND        's';
  481.     $txtOneQry        ' query';
  482.     $txtMultQry       ' queries';
  483.     $queryCount       $this->DebugObject->getQueryCount();
  484.     $txtQuery         $queryCount $txtMultQry $txtOneQry;
  485.     $buffer           '';
  486.  
  487.     // Performance Debug
  488.     $processTime $this->DebugObject->getProcessTime();
  489.     $sqlTime    $this->DebugObject->getQueryTime();
  490.     $phpTime    $processTime $sqlTime;
  491.  
  492.     $sqlPercent round(($sqlTime $processTime1002);
  493.     $phpPercent round(($phpTime $processTime1002);
  494.  
  495.     $processTime $processTime*1000;
  496.     $sqlTime    $sqlTime*1000;
  497.     $phpTime    $phpTime*1000;
  498.  
  499.     if ($debugInfos{
  500.       $buffer .= '
  501.             <tr>
  502.                 <th>message</th>
  503.                 <th>time (ms)</th>
  504.                 <th>percent</th>
  505.             </tr>'CR;
  506.  
  507.       foreach($debugInfos as $debugInfo{
  508.         $properties $debugInfo->getProperties();
  509.         if ($properties['startTime'&& $properties['endTime']{
  510.  
  511.           $localPercent round((($properties['endTime'-
  512.           $properties['startTime'])*1000 $processTime1002);
  513.           $buffer .= '
  514.                     <tr>
  515.                         <td class="sfWebDebugLogMessagePerf">'$this->ProcessDebugInfo($properties)'</td>
  516.                         <td style="text-align: right">'$this->ProcessExecTime($properties)'</td>
  517.                         <td style="text-align: right">'$localPercent'%</td>
  518.                     </tr>'CR;
  519.         }
  520.       }
  521.     }
  522.  
  523.     return str_replace(
  524.     array(
  525.                 '{$txtExecutionTime}',
  526.                 '{$processTime}',
  527.                 '{$txtPHP}',
  528.                 '{$phpTime}',
  529.                 '{$phpPercent}',
  530.                 '{$txtSQL}',
  531.                 '{$sqlTime}',
  532.                 '{$sqlPercent}',
  533.                 '{$queryCount}',
  534.                 '{$txtQuery}',
  535.                 '{$buffer}'
  536.                 
  537.                 ),
  538.                 array(
  539.                 $txtExecutionTime,
  540.                 $processTime,
  541.                 $txtPHP,
  542.                 $phpTime,
  543.                 $phpPercent,
  544.                 $txtSQL,
  545.                 $sqlTime,
  546.                 $sqlPercent,
  547.                 $queryCount,
  548.                 $txtQuery,
  549.                 $buffer
  550.                 ),
  551.                 $this->options['HTML_DIV_sfWebDebugTimeDetails']
  552.                 );
  553.   }
  554.  
  555.   /**
  556.    * Default render function for HTML_Div renderer
  557.    *
  558.    * @since V2.0.0 - 11 Apr 2006
  559.    * @see Renderer
  560.    */
  561.   public function render()
  562.   {
  563.     return $this->display();
  564.   }
  565.  
  566.   /**
  567.    * Displays the header of the PHP_Debug object
  568.    *
  569.    * @since V2.0.0 - 08 Apr 2006
  570.    * @see PHP_Debug
  571.    */
  572.   protected function displayHeader()
  573.   {
  574.     return str_replace(
  575.     array(
  576.                 '{$nb_queries}',
  577.                 '{$exec_time}',
  578.                 '{$imagesPath}',
  579.                 '{$phpDebugVersion}'
  580.                 ),
  581.                 array(
  582.                 $this->DebugObject->getQueryCount(),
  583.                 $this->DebugObject->getProcessTime(1000,
  584.                 $this->options['HTML_DIV_images_path'],
  585.                 PHP_Debug::PEAR_RELEASE
  586.                 ),
  587.                 $this->options['HTML_DIV_header']);
  588.   }
  589.  
  590.   /**
  591.    * Diplays the footer of the PHP_Debug object
  592.    *
  593.    * @since V2.0.0 - 08 Apr 2006
  594.    * @see PHP_Debug
  595.    */
  596.   protected function displayFooter()
  597.   {
  598.     return $this->options['HTML_DIV_footer'];
  599.   }
  600.  
  601.   /**
  602.    * process display of the execution time of debug information
  603.    *
  604.    * @param array $properties Properties of the debug line
  605.    * @return string Formatted string containing the main debug info
  606.    * @since V2.0.0 - 28 Apr 2006
  607.    */
  608.   protected function processExecTime($properties)
  609.   {
  610.     // Lang
  611.     $txtPHP 'PHP';
  612.     $txtSQL 'SQL';
  613.     $txtSECOND 's';
  614.  
  615.     if (!empty($properties['endTime'])) {
  616.  
  617.       $time round(PHP_Debug::getElapsedTime(
  618.       $properties['startTime'],
  619.       $properties['endTime']
  620.       1000);
  621.  
  622.       $buffer $this->span($time $time' ms' '&lt; 1 ms''time');
  623.  
  624.     else {
  625.       $buffer '&nbsp;';
  626.     }
  627.  
  628.     return $buffer;
  629.   }
  630.  
  631.   /**
  632.    * process display of the main information of debug
  633.    *
  634.    * @param array $properties Properties of the debug line
  635.    * @return string Formatted string containing the main debug info
  636.    * @since V2.0.0 - 28 Apr 2006
  637.    */
  638.   protected function processDebugInfo($properties)
  639.   {
  640.     $buffer '';
  641.  
  642.     switch($properties['type']{
  643.  
  644.       // Case for each of the debug lines types
  645.       // 1 : Standard
  646.       case PHP_DebugLine::TYPE_STD:
  647.         $buffer .= $this->span($properties['info']'std');
  648.         break;
  649.  
  650.         // 2 : Query
  651.       case PHP_DebugLine::TYPE_QUERY:
  652.         $buffer .= preg_replace('/\b(SELECT|FROM|AS|LIMIT|ASC|COUNT|DESC|WHERE|LEFT JOIN|INNER JOIN|RIGHT JOIN|ORDER BY|GROUP BY|IN|LIKE|DISTINCT|DELETE|INSERT|INTO|VALUES)\b/',
  653.                     '<span class="sfWebDebugLogInfo">\\1</span>',
  654.         $properties['info']);
  655.         break;
  656.  
  657.         // 3 : Query related
  658.       case PHP_DebugLine::TYPE_QUERYREL:
  659.         $buffer .= $this->span($properties['info']'query');
  660.         break;
  661.  
  662.         // 4 : Environment
  663.       case PHP_DebugLine::TYPE_ENV:
  664.         $buffer .= $this->showSuperArray($properties['info']);
  665.         break;
  666.  
  667.         // 6 : User app error
  668.       case PHP_DebugLine::TYPE_APPERROR:
  669.         $buffer .= $this->span('/!\\ User error : '.
  670.         $properties['info']' /!\\''app-error');
  671.         break;
  672.  
  673.         // 7
  674.       case PHP_DebugLine::TYPE_CREDITS:
  675.         $buffer .= $this->span($properties['info']'credits');
  676.         break;
  677.  
  678.         // 9
  679.       case PHP_DebugLine::TYPE_DUMP:
  680.         $buffer .= $this->showDump($properties);
  681.         break;
  682.  
  683.         // 10
  684.       case PHP_DebugLine::TYPE_PROCESSPERF:
  685.         $buffer .= $this->showProcessTime();
  686.         break;
  687.  
  688.         // 12 : Main Page Action
  689.       case PHP_DebugLine::TYPE_PAGEACTION;
  690.       $buffer .= $this->span('[Action : '.
  691.       $properties['info']']''pageaction');
  692.       break;
  693.  
  694.       // 14 : SQL parse
  695.       case PHP_DebugLine::TYPE_SQLPARSE:
  696.         $buffer .= $properties['info'];
  697.         break;
  698.  
  699.         // 15 : Watches
  700.       case PHP_DebugLine::TYPE_WATCH:
  701.         $infos $properties['info'];
  702.         $buffer .= 'Variable '$this->span($infos[0]'watch').
  703.                            ' changed from value '.
  704.         $this->span($infos[1]'watch-val')' ('gettype($infos[1]).
  705.                             ') to value '$this->span($infos[2]'watch-val').
  706.                             ' ('gettype($infos[2])')';
  707.         break;
  708.  
  709.         // 16 : PHP errors
  710.       case PHP_DebugLine::TYPE_PHPERROR:
  711.         $buffer .= $this->showError($properties['info']);
  712.         break;
  713.  
  714.       default:
  715.         $buffer .= '<b>Default('$properties['type'].
  716.                            ')</b>: TO IMPLEMENT OR TO CORRECT : &gt;'.
  717.         $properties['info']'&lt;';
  718.         break;
  719.     }
  720.  
  721.     return $buffer;
  722.   }
  723.  
  724.   /**
  725.    * Return a string with applying a span style on it
  726.    *
  727.    * @param string $info String to apply the style
  728.    * @param string $class CSS style to apply to the string
  729.    * @return string Formatted string with style applied
  730.    * @since V2.0.0 - 05 May 2006
  731.    */
  732.   protected function span($info$class)
  733.   {
  734.     return '<span class="'$class .'">'$info .'</span>';
  735.   }
  736.  
  737.   /**
  738.    * process display of the type of the debug information
  739.    *
  740.    * @param array $properties Properties of the debug line
  741.    * @return string Formatted string containing the debug type
  742.    * @since V2.0.0 - 26 Apr 2006
  743.    */
  744.   protected function processType($properties)
  745.   {
  746.     $buffer PHP_DebugLine::$debugLineLabels[$properties['type']];
  747.     return $buffer;
  748.   }
  749.  
  750.   /**
  751.    * process display of Class
  752.    *
  753.    * @param array $properties Properties of the debug line
  754.    * @return string Formatted string containing the class
  755.    * @since V2.0.0 - 26 Apr 2006
  756.    */
  757.   protected function processClass($properties)
  758.   {
  759.     $buffer '';
  760.  
  761.     switch ($properties['type'])
  762.     {
  763.       case PHP_DebugLine::TYPE_STD:
  764.       case PHP_DebugLine::TYPE_QUERY:
  765.       case PHP_DebugLine::TYPE_QUERYREL:
  766.       case PHP_DebugLine::TYPE_APPERROR:
  767.       case PHP_DebugLine::TYPE_PAGEACTION:
  768.       case PHP_DebugLine::TYPE_PHPERROR:
  769.       case PHP_DebugLine::TYPE_SQLPARSE:
  770.       case PHP_DebugLine::TYPE_WATCH:
  771.       case PHP_DebugLine::TYPE_DUMP:
  772.  
  773.         if (!empty($properties['class'])) {
  774.           $buffer .= $properties['class'];
  775.         else {
  776.           $buffer .= '&nbsp;';
  777.         }
  778.  
  779.         break;
  780.  
  781.       case PHP_DebugLine::TYPE_CREDITS:
  782.       case PHP_DebugLine::TYPE_SEARCH:
  783.       case PHP_DebugLine::TYPE_PROCESSPERF:
  784.       case PHP_DebugLine::TYPE_TEMPLATES:
  785.       case PHP_DebugLine::TYPE_ENV:
  786.  
  787.         $buffer .= '&nbsp;';
  788.  
  789.         break;
  790.  
  791.       default:
  792.         break;
  793.     }
  794.  
  795.     return $buffer;
  796.   }
  797.  
  798.   /**
  799.    * process display of function
  800.    *
  801.    * @param array $properties Properties of the debug line
  802.    * @return string Formatted string containing the function
  803.    * @since V2.0.0 - 26 Apr 2006
  804.    */
  805.   protected function processFunction($properties)
  806.   {
  807.     $buffer '';
  808.  
  809.     switch ($properties['type'])
  810.     {
  811.       case PHP_DebugLine::TYPE_STD:
  812.       case PHP_DebugLine::TYPE_QUERY:
  813.       case PHP_DebugLine::TYPE_QUERYREL:
  814.       case PHP_DebugLine::TYPE_APPERROR:
  815.       case PHP_DebugLine::TYPE_PAGEACTION:
  816.       case PHP_DebugLine::TYPE_PHPERROR:
  817.       case PHP_DebugLine::TYPE_SQLPARSE:
  818.       case PHP_DebugLine::TYPE_WATCH:
  819.       case PHP_DebugLine::TYPE_DUMP:
  820.  
  821.         if (!empty($properties['function'])) {
  822.           if ($properties['function'!= 'unknown'{
  823.             $buffer .= $properties['function']'()';
  824.           else {
  825.             $buffer .= '&nbsp;';
  826.           }
  827.         else {
  828.           $buffer .= '&nbsp;';
  829.         }
  830.  
  831.         break;
  832.  
  833.       case PHP_DebugLine::TYPE_CREDITS:
  834.       case PHP_DebugLine::TYPE_SEARCH:
  835.       case PHP_DebugLine::TYPE_PROCESSPERF:
  836.       case PHP_DebugLine::TYPE_TEMPLATES:
  837.       case PHP_DebugLine::TYPE_ENV:
  838.  
  839.         $buffer .= '&nbsp;';
  840.         break;
  841.  
  842.       default:
  843.         break;
  844.     }
  845.  
  846.     return $buffer;
  847.   }
  848.  
  849.  
  850.   /**
  851.    * process display of line number
  852.    *
  853.    * @param array $properties Properties of the debug line
  854.    * @return string Formatted string containing the line number
  855.    * @since V2.0.0 - 26 Apr 2006
  856.    */
  857.   protected function processLine($properties)
  858.   {
  859.     $buffer '';
  860.  
  861.     switch ($properties['type'])
  862.     {
  863.       case PHP_DebugLine::TYPE_STD:
  864.       case PHP_DebugLine::TYPE_QUERY:
  865.       case PHP_DebugLine::TYPE_QUERYREL:
  866.       case PHP_DebugLine::TYPE_APPERROR:
  867.       case PHP_DebugLine::TYPE_PAGEACTION:
  868.       case PHP_DebugLine::TYPE_PHPERROR:
  869.       case PHP_DebugLine::TYPE_SQLPARSE:
  870.       case PHP_DebugLine::TYPE_WATCH:
  871.       case PHP_DebugLine::TYPE_DUMP:
  872.  
  873.         if (!empty($properties['line'])) {
  874.           $buffer.= '<span class="line">'.
  875.           $properties['line']'</span>';
  876.         else {
  877.           $buffer.= '&nbsp;';
  878.         }
  879.  
  880.         break;
  881.  
  882.       case PHP_DebugLine::TYPE_CREDITS:
  883.       case PHP_DebugLine::TYPE_SEARCH:
  884.       case PHP_DebugLine::TYPE_PROCESSPERF:
  885.       case PHP_DebugLine::TYPE_TEMPLATES:
  886.       case PHP_DebugLine::TYPE_ENV:
  887.  
  888.         $buffer.= '&nbsp;';
  889.  
  890.         break;
  891.  
  892.       default:
  893.         break;
  894.     }
  895.  
  896.     return $buffer;
  897.   }
  898.  
  899.   /**
  900.    * process display of file name
  901.    *
  902.    * @param array $properties Properties of the debug line
  903.    * @return string Formatted string containing the file
  904.    * @since V2.0.0 - 26 Apr 2006
  905.    */
  906.   protected function processFile($properties)
  907.   {
  908.     $buffer '';
  909.  
  910.     switch ($properties['type'])
  911.     {
  912.       case PHP_DebugLine::TYPE_STD:
  913.       case PHP_DebugLine::TYPE_QUERY:
  914.       case PHP_DebugLine::TYPE_QUERYREL:
  915.       case PHP_DebugLine::TYPE_APPERROR:
  916.       case PHP_DebugLine::TYPE_PAGEACTION:
  917.       case PHP_DebugLine::TYPE_PHPERROR:
  918.       case PHP_DebugLine::TYPE_SQLPARSE:
  919.       case PHP_DebugLine::TYPE_WATCH:
  920.       case PHP_DebugLine::TYPE_DUMP:
  921.  
  922.         if (!empty($properties['file'])) {
  923.           if (!empty($this->options['HTML_DIV_view_source_script_path']&&
  924.           !empty($this->options['HTML_DIV_view_source_script_name'])) {
  925.             $buffer .= '<a href="'.
  926.             $this->options['HTML_DIV_view_source_script_path'].
  927.                                 '/'.
  928.             $this->options['HTML_DIV_view_source_script_name'].
  929.                                 '?file='urlencode($properties['file']);
  930.  
  931.             $buffer .= '">'basename($properties['file'])'</a>';
  932.  
  933.           else {
  934.             $buffer .= basename($properties['file']);
  935.           }
  936.         else {
  937.           $buffer .=  '&nbsp;';
  938.         }
  939.  
  940.         break;
  941.  
  942.       case PHP_DebugLine::TYPE_CREDITS:
  943.       case PHP_DebugLine::TYPE_SEARCH:
  944.       case PHP_DebugLine::TYPE_PROCESSPERF:
  945.       case PHP_DebugLine::TYPE_TEMPLATES:
  946.       case PHP_DebugLine::TYPE_ENV:
  947.  
  948.         $buffer .=  '&nbsp;';
  949.  
  950.         break;
  951.  
  952.       default:
  953.         break;
  954.     }
  955.  
  956.     return $buffer;
  957.   }
  958.  
  959.   /**
  960.    * Dump of a variable
  961.    *
  962.    * @since V2.0.0 - 26 Apr 2006
  963.    */
  964.   protected function showDump($properties)
  965.   {
  966.     $buffer '';
  967.  
  968.     // Check display with a <pre> design
  969.     if (is_array($properties['info'][1])) {
  970.       $preDisplay true;
  971.     elseif (is_object($properties['info'][1])) {
  972.       $preDisplay true;
  973.     else {
  974.       $preDisplay false;
  975.     }
  976.  
  977.     // Check var name
  978.     if (empty($properties['info'][0])) {
  979.       if (is_array($properties['info'][1])) {
  980.         $varName 'Array';
  981.       elseif (is_object($properties['info'][1])) {
  982.         $varName get_class($properties['info'][1]);
  983.       else {
  984.         $varName 'Variable';
  985.       }
  986.     else {
  987.       $varName $properties['info'][0];
  988.     }
  989.  
  990.     // Output
  991.     if ($properties['type'!= PHP_DebugLine::TYPE_ENV{
  992.       $title 'dump of \'';
  993.     }
  994.  
  995.     $title .= $varName'\' ('.  gettype($properties['info'][1].') : ';
  996.  
  997.     $buffer .= $this->span($title 'dump-title');
  998.  
  999.     if ($preDisplay == true){
  1000.       $buffer .= '<pre>';
  1001.       $buffer .= PHP_Debug::dumpVar(
  1002.       $properties['info'][1],
  1003.                 '',
  1004.       false,
  1005.       PHP_Debug::DUMP_STR);
  1006.     else {
  1007.       $buffer .= $this->span(
  1008.       PHP_Debug::dumpVar(
  1009.       $properties['info'][1],
  1010.                     '',
  1011.       false,
  1012.       PHP_Debug::DUMP_STR
  1013.       )'dump-val');
  1014.     }
  1015.  
  1016.     if ($preDisplay == true{
  1017.       $buffer .= '</pre>';
  1018.     }
  1019.  
  1020.     return $buffer;
  1021.   }
  1022.  
  1023.   /**
  1024.    * Get the templates info
  1025.    *
  1026.    * @since V2.0.0 - 26 Apr 2006
  1027.    */
  1028.   protected function showTemplates()
  1029.   {
  1030.     $txtMainFile 'MAIN File';
  1031.     $idx 1;
  1032.     $buffer '<br />';
  1033.  
  1034.     foreach($this->DebugObject->getRequiredFiles(as $lvalue{
  1035.        
  1036.       $isToDisplay true;
  1037.  
  1038.       if ($this->options['HTML_DIV_view_source_excluded_template']{
  1039.         foreach ($this->options['HTML_DIV_view_source_excluded_template'as $template{
  1040.           if (stristr($lvalue$template)) {
  1041.             $isToDisplay false;
  1042.           }
  1043.         }
  1044.       }
  1045.  
  1046.       if ($isToDisplay == true{
  1047.  
  1048.         $buffer .= '<div class="source">';
  1049.         $buffer .= $this->span($this->truncate($lvalue)'files');
  1050.         if (!empty($this->options['HTML_DIV_view_source_script_path']&&
  1051.         !empty($this->options['HTML_DIV_view_source_script_name'])) {
  1052.           $buffer .= ' <a href="'.
  1053.           $this->options['HTML_DIV_view_source_script_path'].
  1054.                              '/'$this->options['HTML_DIV_view_source_script_name'].
  1055.                              '?file='urlencode($lvalue)'">View source</a> ';
  1056.         }
  1057.         // main file
  1058.         if ($idx == 1{
  1059.           $buffer .= $this->span('&laquo; '$txtMainFile'main-file');
  1060.         }
  1061.         $idx++;
  1062.         $buffer .= '</div><br />'CR;
  1063.       }
  1064.     }
  1065.  
  1066.     $buffer .= '<br />'CR;
  1067.     return $buffer;
  1068.   }
  1069.  
  1070.  
  1071.   /**
  1072.    * Truncate/replace a pattern from the file path
  1073.    *
  1074.    * @param string full file path
  1075.    *
  1076.    * @author COil
  1077.    * @since V2.1.0 - 3 apr 2007
  1078.    *
  1079.    * @see
  1080.    *  - HTML_DIV_remove_templates_pattern
  1081.    *  - HTML_DIV_templates_pattern
  1082.    */
  1083.   protected function truncate($file)
  1084.   {
  1085.     if ($this->options['HTML_DIV_remove_templates_pattern'&&
  1086.     $this->options['HTML_DIV_templates_pattern']{
  1087.       return strtr($file$this->options['HTML_DIV_templates_pattern']);
  1088.     }
  1089.  
  1090.     return $file;
  1091.   }
  1092.  
  1093.   /**
  1094.    * Process an error info
  1095.    *
  1096.    * @param array $info Array containing information about the error
  1097.    *
  1098.    * @since V2.0.0 - 25 Apr 2006
  1099.    * @see PHP_DebugLine::TYPE_PHPERROR
  1100.    */
  1101.   protected function showError($infos)
  1102.   {
  1103.     $buffer '';
  1104.     $infos[1str_replace("'"'"'$infos[1]);
  1105.     $infos[1str_replace(
  1106.             'href="function.',
  1107.             ' href="http://www.php.net/'.
  1108.     $this->options['lang']'/'$infos[1]);
  1109.  
  1110.     switch ($infos[0])
  1111.     {
  1112.       case E_WARNING:
  1113.         $errorlevel 'PHP WARNING : ';
  1114.         $buffer .= '<span class="pd-php-warning"> /!\\ '.
  1115.         $errorlevel$infos[1' /!\\ </span>';
  1116.         break;
  1117.  
  1118.       case E_NOTICE:
  1119.         $errorlevel 'PHP notice : ';
  1120.         $buffer .= '<span class="pd-php-notice">'.
  1121.         $errorlevel$infos[1'</span>';
  1122.         break;
  1123.  
  1124.       case E_USER_ERROR:
  1125.         $errorlevel 'PHP User error : ';
  1126.         $buffer .= '<span class="pd-php-user-error"> /!\\ '.
  1127.         $errorlevel$infos[1' /!\\ </span>';
  1128.         break;
  1129.  
  1130.       case E_STRICT:
  1131.  
  1132.         $errorlevel 'PHP STRICT error : ';
  1133.         $buffer .= '<span class="pd-php-user-error"> /!\\ '.
  1134.         $errorlevel$infos[1' /!\\ </span>';
  1135.         break;
  1136.  
  1137.       default:
  1138.         $errorlevel 'PHP errorlevel = '$infos[0]' : ';
  1139.         $buffer .= $errorlevel.
  1140.                     ' is not implemented in PHP_Debug ('. __FILE__. ','. __LINE__. ')';
  1141.         break;
  1142.     }
  1143.  
  1144.     return $buffer;
  1145.   }
  1146.  
  1147.   /**
  1148.    * Show a super array
  1149.    *
  1150.    * @param string $SuperArrayType Type of super en array to add
  1151.    * @since V2.0.0 - 07 Apr 2006
  1152.    */
  1153.   protected function showSuperArray($SuperArrayType)
  1154.   {
  1155.     // Lang
  1156.     $txtVariable   'Var';
  1157.     $txtNoVariable 'NO VARIABLE';
  1158.     $NoVariable    ' -- '$txtNoVariable' -- ';
  1159.     $SuperArray    null;
  1160.     $buffer        '';
  1161.  
  1162.     $ArrayTitle PHP_Debug::$globalEnvConstantsCorresp[$SuperArrayType];
  1163.     $SuperArray $GLOBALS[$ArrayTitle];
  1164.     $Title $ArrayTitle' '$txtVariable;
  1165.     $SectionBasetitle '<b>'$Title'('count($SuperArray)') :';
  1166.  
  1167.     if (count($SuperArray)) {
  1168.       $buffer .= $SectionBasetitle'</b>';
  1169.       $buffer .= '<pre>'.
  1170.       PHP_Debug::dumpVar(
  1171.       $SuperArray,
  1172.       $ArrayTitle,
  1173.       false,
  1174.       PHP_Debug::DUMP_STR
  1175.       )'</pre>';
  1176.     else {
  1177.       $buffer .= $SectionBasetitle$NoVariable'</b>';
  1178.     }
  1179.  
  1180.     return $buffer;
  1181.   }
  1182.  
  1183.   /**
  1184.    * Displays an array.
  1185.    *
  1186.    * @param string $SuperArrayType Type of super en array to add
  1187.    * @since V2.0.0 - 07 Apr 2006
  1188.    */
  1189.   protected function showArray($array$name)
  1190.   {
  1191.     // Lang
  1192.     $txtNoVariable 'NO VARIABLE';
  1193.     $NoVariable    ' -- '$txtNoVariable' -- ';
  1194.     $buffer        '';
  1195.     $SectionBasetitle '<b>'$name'('count($array)') :';
  1196.  
  1197.     if (count($array)) {
  1198.       $buffer .= $SectionBasetitle'</b>';
  1199.       $buffer .= '<pre>'PHP_Debug::dumpVar(
  1200.       $array,
  1201.       $name,
  1202.       false,
  1203.       PHP_Debug::DUMP_STR)'</pre>';
  1204.     else {
  1205.       $buffer .= $SectionBasetitle$NoVariable'</b>';
  1206.     }
  1207.  
  1208.     return $buffer;
  1209.   }
  1210. }

Documentation generated on Thu, 03 May 2012 15:04:24 +0200 by phpDocumentor 1.4.1