330 lines
7.4 KiB
PHP
330 lines
7.4 KiB
PHP
<?php defined('SYSPATH') OR die('No direct access allowed.');
|
|
/**
|
|
* Loads and displays Kohana view files. Can also handle output of some binary
|
|
* files, such as image, Javascript, and CSS files.
|
|
*
|
|
* $Id: View.php 4679 2009-11-10 01:45:52Z isaiah $
|
|
*
|
|
* @package Core
|
|
* @author Kohana Team
|
|
* @copyright (c) 2007-2009 Kohana Team
|
|
* @license http://kohanaphp.com/license
|
|
*/
|
|
class View_Core {
|
|
|
|
// The view file name and type
|
|
protected $kohana_filename = FALSE;
|
|
protected $kohana_filetype = FALSE;
|
|
|
|
// View variable storage
|
|
protected $kohana_local_data = array();
|
|
|
|
/**
|
|
* Creates a new View using the given parameters.
|
|
*
|
|
* @param string view name
|
|
* @param array pre-load data
|
|
* @param string type of file: html, css, js, etc.
|
|
* @return object
|
|
*/
|
|
public static function factory($name = NULL, $data = NULL, $type = NULL)
|
|
{
|
|
return new View($name, $data, $type);
|
|
}
|
|
|
|
/**
|
|
* Attempts to load a view and pre-load view data.
|
|
*
|
|
* @throws Kohana_Exception if the requested view cannot be found
|
|
* @param string view name
|
|
* @param array pre-load data
|
|
* @param string type of file: html, css, js, etc.
|
|
* @return void
|
|
*/
|
|
public function __construct($name = NULL, $data = NULL, $type = NULL)
|
|
{
|
|
if (is_string($name) AND $name !== '')
|
|
{
|
|
// Set the filename
|
|
$this->set_filename($name, $type);
|
|
}
|
|
|
|
if (is_array($data) AND ! empty($data))
|
|
{
|
|
// Preload data using array_merge, to allow user extensions
|
|
$this->kohana_local_data = array_merge($this->kohana_local_data, $data);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Magic method access to test for view property
|
|
*
|
|
* @param string View property to test for
|
|
* @return boolean
|
|
*/
|
|
public function __isset($key = NULL)
|
|
{
|
|
return $this->is_set($key);
|
|
}
|
|
|
|
/**
|
|
* Sets the view filename.
|
|
*
|
|
* @chainable
|
|
* @param string view filename
|
|
* @param string view file type
|
|
* @return object
|
|
*/
|
|
public function set_filename($name, $type = NULL)
|
|
{
|
|
if ($type == NULL)
|
|
{
|
|
// Load the filename and set the content type
|
|
$this->kohana_filename = Kohana::find_file('views', $name, TRUE);
|
|
$this->kohana_filetype = EXT;
|
|
}
|
|
else
|
|
{
|
|
// Check if the filetype is allowed by the configuration
|
|
if ( ! in_array($type, Kohana::config('view.allowed_filetypes')))
|
|
throw new Kohana_Exception('The requested filetype, .:type:, is not allowed in your view configuration file', array(':type:' => $type));
|
|
|
|
// Load the filename and set the content type
|
|
$this->kohana_filename = Kohana::find_file('views', $name, TRUE, $type);
|
|
$this->kohana_filetype = Kohana::config('mimes.'.$type);
|
|
|
|
if ($this->kohana_filetype == NULL)
|
|
{
|
|
// Use the specified type
|
|
$this->kohana_filetype = $type;
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets a view variable.
|
|
*
|
|
* @param string|array name of variable or an array of variables
|
|
* @param mixed value when using a named variable
|
|
* @return object
|
|
*/
|
|
public function set($name, $value = NULL)
|
|
{
|
|
if (is_array($name))
|
|
{
|
|
foreach ($name as $key => $value)
|
|
{
|
|
$this->__set($key, $value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$this->__set($name, $value);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Checks for a property existence in the view locally or globally. Unlike the built in __isset(),
|
|
* this method can take an array of properties to test simultaneously.
|
|
*
|
|
* @param string $key property name to test for
|
|
* @param array $key array of property names to test for
|
|
* @return boolean property test result
|
|
* @return array associative array of keys and boolean test result
|
|
*/
|
|
public function is_set( $key = FALSE )
|
|
{
|
|
// Setup result;
|
|
$result = FALSE;
|
|
|
|
// If key is an array
|
|
if (is_array($key))
|
|
{
|
|
// Set the result to an array
|
|
$result = array();
|
|
|
|
// Foreach key
|
|
foreach ($key as $property)
|
|
{
|
|
// Set the result to an associative array
|
|
$result[$property] = (array_key_exists($property, $this->kohana_local_data)) ? TRUE : FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Otherwise just check one property
|
|
$result = (array_key_exists($key, $this->kohana_local_data)) ? TRUE : FALSE;
|
|
}
|
|
|
|
// Return the result
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Sets a bound variable by reference.
|
|
*
|
|
* @param string name of variable
|
|
* @param mixed variable to assign by reference
|
|
* @return object
|
|
*/
|
|
public function bind($name, & $var)
|
|
{
|
|
$this->kohana_local_data[$name] =& $var;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Magically sets a view variable.
|
|
*
|
|
* @param string variable key
|
|
* @param string variable value
|
|
* @return void
|
|
*/
|
|
public function __set($key, $value)
|
|
{
|
|
$this->kohana_local_data[$key] = $value;
|
|
}
|
|
|
|
/**
|
|
* Magically gets a view variable.
|
|
*
|
|
* @param string variable key
|
|
* @return mixed variable value if the key is found
|
|
* @return void if the key is not found
|
|
*/
|
|
public function &__get($key)
|
|
{
|
|
if (isset($this->kohana_local_data[$key]))
|
|
{
|
|
return $this->kohana_local_data[$key];
|
|
}
|
|
elseif (isset($this->$key))
|
|
{
|
|
return $this->$key;
|
|
}
|
|
else
|
|
{
|
|
throw new Kohana_Exception('Undefined view variable: :var',
|
|
array(':var' => $key));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Magically converts view object to string.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function __toString()
|
|
{
|
|
try
|
|
{
|
|
return $this->render();
|
|
}
|
|
catch (Exception $e)
|
|
{
|
|
Kohana_Exception::handle($e);
|
|
return (string) '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renders a view.
|
|
*
|
|
* @param boolean set to TRUE to echo the output instead of returning it
|
|
* @param callback special renderer to pass the output through
|
|
* @param callback modifier to pass the data through before rendering
|
|
* @return string if print is FALSE
|
|
* @return void if print is TRUE
|
|
*/
|
|
public function render($print = FALSE, $renderer = FALSE, $modifier = FALSE)
|
|
{
|
|
if (empty($this->kohana_filename))
|
|
throw new Kohana_Exception('You must set the the view filename before calling render');
|
|
|
|
if (is_string($this->kohana_filetype))
|
|
{
|
|
// Merge global and local data, local overrides global with the same name
|
|
$data = $this->kohana_local_data;
|
|
|
|
if ($modifier !== FALSE AND is_callable($modifier, TRUE))
|
|
{
|
|
// Pass the data through the user defined modifier
|
|
$data = call_user_func($modifier, $data);
|
|
}
|
|
|
|
$output = $this->load_view($this->kohana_filename, $data);
|
|
|
|
if ($renderer !== FALSE AND is_callable($renderer, TRUE))
|
|
{
|
|
// Pass the output through the user defined renderer
|
|
$output = call_user_func($renderer, $output);
|
|
}
|
|
|
|
if ($print === TRUE)
|
|
{
|
|
// Display the output
|
|
echo $output;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Set the content type and size
|
|
header('Content-Type: '.$this->kohana_filetype[0]);
|
|
|
|
if ($print === TRUE)
|
|
{
|
|
if ($file = fopen($this->kohana_filename, 'rb'))
|
|
{
|
|
// Display the output
|
|
fpassthru($file);
|
|
fclose($file);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Fetch the file contents
|
|
$output = file_get_contents($this->kohana_filename);
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Includes a View within the controller scope.
|
|
*
|
|
* @param string view filename
|
|
* @param array array of view variables
|
|
* @return string
|
|
*/
|
|
public function load_view($kohana_view_filename, $kohana_input_data)
|
|
{
|
|
if ($kohana_view_filename == '')
|
|
return;
|
|
|
|
// Buffering on
|
|
ob_start();
|
|
|
|
// Import the view variables to local namespace
|
|
extract($kohana_input_data, EXTR_SKIP);
|
|
|
|
try
|
|
{
|
|
include $kohana_view_filename;
|
|
}
|
|
catch (Exception $e)
|
|
{
|
|
ob_end_clean();
|
|
throw $e;
|
|
}
|
|
|
|
// Fetch the output and close the buffer
|
|
return ob_get_clean();
|
|
}
|
|
} // End View
|