Source for file jResponseBasicHtml.class.php

Documentation is available at jResponseBasicHtml.class.php

  1. <?php
  2. /**
  3.  * @package     jelix
  4.  * @subpackage  core_response
  5.  * @author      Laurent Jouanneau
  6.  * @contributor Julien Issler, Brice Tence
  7.  * @copyright   2010-2012 Laurent Jouanneau
  8.  * @copyright   2011 Julien Issler, 2011 Brice Tence
  9.  * @link        http://www.jelix.org
  10.  * @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  11.  */
  12.  
  13.  
  14. /**
  15.  * interface for plugins for jResponseBasicHtml or jResponseHtml, which allows
  16.  * to make changes in the response at several step
  17.  */
  18. interface jIHTMLResponsePlugin {
  19.  
  20.     public function __construct(jResponse $c);
  21.  
  22.     /**
  23.      * called just before the jResponseBasicHtml::doAfterActions() call
  24.      */
  25.     public function afterAction();
  26.  
  27.     /**
  28.      * called just before the final output. This is the opportunity
  29.      * to make changes before the head and body output. At this step
  30.      * the main content (if any) is already generated.
  31.      */
  32.     public function beforeOutput();
  33.  
  34.     /**
  35.      * called when the content is generated, and potentially sent, except
  36.      * the body end tag and the html end tags. This method can output
  37.      * directly some contents.
  38.      */
  39.     public function atBottom();
  40.  
  41.     /**
  42.      * called just before the output of an error page
  43.      */
  44.     public function beforeOutputError();
  45. }
  46.  
  47. /**
  48.  * Basic HTML response. the HTML content should be provided by a simple php file.
  49.  * @package  jelix
  50.  * @subpackage core_response
  51.  */
  52. class jResponseBasicHtml extends jResponse {
  53.     /**
  54.     * jresponse id
  55.     * @var string 
  56.     */
  57.     protected $_type = 'html';
  58.  
  59.     /**
  60.      * the charset of the document
  61.      * @var string 
  62.      */
  63.     protected $_charset;
  64.  
  65.     /**
  66.      * the lang of the document
  67.      * @var string 
  68.      */
  69.     protected $_lang;
  70.  
  71.     /**
  72.      * says if the document is in xhtml or html
  73.      */
  74.     protected $_isXhtml = false;
  75.  
  76.     /**
  77.      * says if xhtml content type should be send or not.
  78.      * it true, a verification of HTTP_ACCEPT is done.
  79.      * @var boolean 
  80.      */
  81.     public $xhtmlContentType = false;
  82.  
  83.     /**
  84.      * top content for head
  85.      */
  86.     protected $_headTop  = array ();
  87.  
  88.     /**
  89.      * bottom content for head
  90.      */
  91.     protected $_headBottom  = array ();
  92.  
  93.     /**#@+
  94.      * content for the body
  95.      * @var array
  96.      */
  97.     protected $_bodyTop = array();
  98.     protected $_bodyBottom = array();
  99.     /**#@-*/
  100.  
  101.     /**
  102.      * full path of php file to output. it should content php instruction
  103.      * to display these variables:
  104.      * - $HEADTOP: content added just after the opening <head> tag
  105.      * - $HEADBOTTOM: content before the closing </head> tag
  106.      * - $BODYTOP: content just after the <body> tag, at the top of the page
  107.      * - $BODYBOTTOM: content just before the </body> tag, at the bottom of the page
  108.      * - $BASEPATH: base path of the application, for links of your style sheets etc..
  109.      * @var string 
  110.      */
  111.     public $htmlFile = '';
  112.  
  113.     /**
  114.      * list of plugins
  115.      * @var array  array of jIHTMLResponsePlugin
  116.      * @since 1.3a1
  117.      */
  118.     protected $plugins = array();
  119.  
  120.     /**
  121.     * constructor;
  122.     * setup the charset, the lang
  123.     */
  124.     function __construct (){
  125.  
  126.         $this->_charset = jApp::config()->charset;
  127.         $this->_lang = jApp::config()->locale;
  128.  
  129.         // load plugins
  130.         $plugins jApp::config()->jResponseHtml['plugins'];
  131.         if ($plugins{
  132.             $plugins preg_split('/ *, */'$plugins);
  133.             foreach ($plugins as $name{
  134.                 if (!$name)
  135.                     continue;
  136.                 $plugin jApp::loadPlugin($name'htmlresponse''.htmlresponse.php'$name.'HTMLResponsePlugin'$this);
  137.                 if ($plugin)
  138.                     $this->plugins[$name$plugin;
  139.                 // do nothing if the plugin does not exist, we could be already into the error handle
  140.             }
  141.         }
  142.  
  143.         parent::__construct();
  144.     }
  145.  
  146.     /**
  147.      * return the corresponding plugin
  148.      * @param string $name the name of the plugin
  149.      * @return jIHTMLResponsePlugin|nullthe plugin or null if it isn't loaded
  150.      * @since 1.3a1
  151.      */
  152.     function getPlugin($name{
  153.         if (isset($this->plugins[$name]))
  154.             return $this->plugins[$name];
  155.         return null;
  156.     }
  157.  
  158.     /**
  159.      * add additional content into the document head
  160.      * @param string $content 
  161.      * @param boolean $toTop true if you want to add it at the top of the head content, else false for the bottom
  162.      * @since 1.0b1
  163.      */
  164.     final public function addHeadContent ($content$toTop false{
  165.         if ($toTop{
  166.             $this->_headTop[$content;
  167.         }
  168.         else {
  169.             $this->_headBottom[$content;
  170.         }
  171.     }
  172.  
  173.     /**
  174.      * add content to the body
  175.      * you can add additionnal content, before or after the content of body
  176.      * @param string $content additionnal html content
  177.      * @param boolean $before true if you want to add it before the content, else false for after
  178.      */
  179.     function addContent($content$before false){
  180.         if ($before{
  181.             $this->_bodyTop[]=$content;
  182.         }
  183.         else {
  184.             $this->_bodyBottom[]=$content;
  185.         }
  186.     }
  187.  
  188.     /**
  189.      *  set the content-type in the http headers
  190.      */
  191.     protected function setContentType({
  192.         if($this->_isXhtml && $this->xhtmlContentType && strstr($_SERVER['HTTP_ACCEPT'],'application/xhtml+xml')){
  193.             $this->_httpHeaders['Content-Type']='application/xhtml+xml;charset='.$this->_charset;
  194.         }else{
  195.             $this->_httpHeaders['Content-Type']='text/html;charset='.$this->_charset;
  196.         }
  197.     }
  198.  
  199.     /**
  200.      * output the html content
  201.      *
  202.      * @return boolean    true if the generated content is ok
  203.      */
  204.     public function output(){
  205.  
  206.         if($this->_outputOnlyHeaders){
  207.             $this->sendHttpHeaders();
  208.             return true;
  209.         }
  210.     
  211.         foreach($this->plugins as $name=>$plugin)
  212.             $plugin->afterAction();
  213.  
  214.         $this->doAfterActions();
  215.  
  216.         if ($this->htmlFile == '')
  217.             throw new Exception('static page is missing');
  218.  
  219.         $this->setContentType();
  220.  
  221.         jLog::outputLog($this);
  222.  
  223.         foreach($this->plugins as $name=>$plugin)
  224.             $plugin->beforeOutput();
  225.  
  226.         $HEADTOP implode("\n"$this->_headTop);
  227.         $HEADBOTTOM implode("\n"$this->_headBottom);
  228.         $BODYTOP implode("\n"$this->_bodyTop);
  229.         $BODYBOTTOM implode("\n"$this->_bodyBottom);
  230.         $BASEPATH jApp::config()->urlengine['basePath'];
  231.  
  232.         ob_start();
  233.         foreach($this->plugins as $name=>$plugin)
  234.             $plugin->atBottom();
  235.         $BODYBOTTOM .= ob_get_clean();
  236.  
  237.         $this->sendHttpHeaders();
  238.         include($this->htmlFile);
  239.  
  240.         return true;
  241.     }
  242.  
  243.     /**
  244.      * The method you can overload in your inherited html response
  245.      * overload it if you want to add processes (stylesheet, head settings, additionnal content etc..)
  246.      * after any actions
  247.      * @since 1.1
  248.      */
  249.     protected function doAfterActions(){
  250.  
  251.     }
  252.  
  253.     /**
  254.      * output errors
  255.      */
  256.     public function outputErrors(){
  257.  
  258.         if (file_exists(jApp::appPath('responses/error.en_US.php')))
  259.             $file jApp::appPath('responses/error.en_US.php');
  260.         else
  261.             $file JELIX_LIB_CORE_PATH.'response/error.en_US.php';
  262.         // we erase already generated content
  263.         $this->_headTop = array();
  264.         $this->_headBottom = array();
  265.         $this->_bodyBottom = array();
  266.         $this->_bodyTop = array();
  267.  
  268.         jLog::outputLog($this);
  269.  
  270.         foreach($this->plugins as $name=>$plugin)
  271.             $plugin->beforeOutputError();
  272.  
  273.         $HEADTOP implode("\n"$this->_headTop);
  274.         $HEADBOTTOM implode("\n"$this->_headBottom);
  275.         $BODYTOP implode("\n"$this->_bodyTop);
  276.         $BODYBOTTOM implode("\n"$this->_bodyBottom);
  277.         $BASEPATH jApp::config()->urlengine['basePath'];
  278.  
  279.         header("HTTP/{$this->httpVersion} 500 Internal jelix error");
  280.         header('Content-Type: text/html;charset='.$this->_charset);
  281.         include($file);
  282.     }
  283.  
  284.     /**
  285.      * change the type of html for the output
  286.      * @param boolean $xhtml true if you want xhtml, false if you want html
  287.      */
  288.     public function setXhtmlOutput($xhtml = true){
  289.         $this->_isXhtml = $xhtml;
  290.     }
  291.  
  292.     /**
  293.      * says if the response will be xhtml or html
  294.      * @return boolean true if it is xhtml
  295.      */
  296.     final public function isXhtml(){ return $this->_isXhtml}
  297.  

Documentation generated on Wed, 04 Jan 2017 22:56:10 +0100 by phpDocumentor 1.4.3