Acts as an object wrapper for HTML pages with embedded PHP, called "views". Variables can be assigned with the view object and referenced locally within the view.
Class declared in SYSPATH/classes/kohana/view.php on line 13.
array(0) Sets the initial view filename and local data. Views should almost always only be created using View::factory.
$view = new View($file);
string
$file
= NULL - View filenamearray
$data
= NULL - Array of valuesvoidpublic function __construct($file = NULL, array $data = NULL)
{
if ($file !== NULL)
{
$this->set_filename($file);
}
if ($data !== NULL)
{
// Add the values to the current data
$this->_data = $data + $this->_data;
}
}Magic method, searches for the given variable and returns its value. Local variables will be returned before global variables.
$value = $view->foo;
If the variable has not yet been set, an exception will be thrown.
string
$key
required - Variable namemixedpublic function & __get($key)
{
if (array_key_exists($key, $this->_data))
{
return $this->_data[$key];
}
elseif (array_key_exists($key, View::$_global_data))
{
return View::$_global_data[$key];
}
else
{
throw new Kohana_Exception('View variable is not set: :var',
array(':var' => $key));
}
}Magic method, determines if a variable is set.
isset($view->foo);
NULL variables are not considered to be set by isset.
string
$key
required - Variable namebooleanpublic function __isset($key)
{
return (isset($this->_data[$key]) OR isset(View::$_global_data[$key]));
}Magic method, calls View::set with the same parameters.
$view->foo = 'something';
string
$key
required - Variable namemixed
$value
required - Valuevoidpublic function __set($key, $value)
{
$this->set($key, $value);
}Magic method, returns the output of View::render.
stringpublic function __toString()
{
try
{
return $this->render();
}
catch (Exception $e)
{
// Display the exception message
Kohana_Exception::handler($e);
return '';
}
}Magic method, unsets a given variable.
unset($view->foo);
string
$key
required - Variable namevoidpublic function __unset($key)
{
unset($this->_data[$key], View::$_global_data[$key]);
}Assigns a value by reference. The benefit of binding is that values can be altered without re-setting them. It is also possible to bind variables before they have values. Assigned values will be available as a variable within the view file:
// This reference can be accessed as $ref within the view
$view->bind('ref', $bar);
string
$key
required - Variable namebyref mixed
$value
required - Referenced variable$thispublic function bind($key, & $value)
{
$this->_data[$key] =& $value;
return $this;
}Assigns a global variable by reference, similar to View::bind, except that the variable will be accessible to all views.
View::bind_global($key, $value);
string
$key
required - Variable namebyref mixed
$value
required - Referenced variablevoidpublic static function bind_global($key, & $value)
{
View::$_global_data[$key] =& $value;
}Returns a new View object. If you do not define the "file" parameter, you must call View::set_filename.
$view = View::factory($file);
string
$file
= NULL - View filenamearray
$data
= NULL - Array of valuesViewpublic static function factory($file = NULL, array $data = NULL)
{
return new View($file, $data);
}Renders the view object to a string. Global and local data are merged and extracted to create local variables within the view file.
$output = $view->render();
Global variables with the same key name as local variables will be overwritten by the local variable.
string
$file
= NULL - View filenamestringpublic function render($file = NULL)
{
if ($file !== NULL)
{
$this->set_filename($file);
}
if (empty($this->_file))
{
throw new Kohana_View_Exception('You must set the file to use within your view before rendering');
}
// Combine local and global data and capture the output
return View::capture($this->_file, $this->_data);
}Assigns a variable by name. Assigned values will be available as a variable within the view file:
// This value can be accessed as $foo within the view
$view->set('foo', 'my value');
You can also use an array to set several values at once:
// Create the values $food and $beverage in the view
$view->set(array('food' => 'bread', 'beverage' => 'water'));
string
$key
required - Variable name or an array of variablesmixed
$value
= NULL - Value$thispublic function set($key, $value = NULL)
{
if (is_array($key))
{
foreach ($key as $name => $value)
{
$this->_data[$name] = $value;
}
}
else
{
$this->_data[$key] = $value;
}
return $this;
}Sets the view filename.
$view->set_filename($file);
string
$file
required - View filenameViewpublic function set_filename($file)
{
if (($path = Kohana::find_file('views', $file)) === FALSE)
{
throw new Kohana_View_Exception('The requested view :file could not be found', array(
':file' => $file,
));
}
// Store the file path locally
$this->_file = $path;
return $this;
}Sets a global variable, similar to View::set, except that the variable will be accessible to all views.
View::set_global($name, $value);
string
$key
required - Variable name or an array of variablesmixed
$value
= NULL - Valuevoidpublic static function set_global($key, $value = NULL)
{
if (is_array($key))
{
foreach ($key as $key2 => $value)
{
View::$_global_data[$key2] = $value;
}
}
else
{
View::$_global_data[$key] = $value;
}
}Captures the output that is generated when a view is included. The view data will be extracted to make local variables. This method is static to prevent object scope resolution.
$output = View::capture($file, $data);
string
$kohana_view_filename
required - Filenamearray
$kohana_view_data
required - Variablesstringprotected static function capture($kohana_view_filename, array $kohana_view_data)
{
// Import the view variables to local namespace
extract($kohana_view_data, EXTR_SKIP);
if (View::$_global_data)
{
// Import the global view variables to local namespace
extract(View::$_global_data, EXTR_SKIP | EXTR_REFS);
}
// Capture the view output
ob_start();
try
{
// Load the view within the current scope
include $kohana_view_filename;
}
catch (Exception $e)
{
// Delete the output buffer
ob_end_clean();
// Re-throw the exception
throw $e;
}
// Get the captured output and close the buffer
return ob_get_clean();
}