Views¶

View Templates¶

The view layer of CakePHP is how you speak to your users. Most of the time your views will be showing (X)HTML documents to browsers, but you might also need to serve AMF data to a Flash object, reply to a remote application via SOAP, or output a CSV file for a user.

By default CakePHP view files are written in plain PHP and have a default extension of .ctp (CakePHP Template). These files contain all the presentational logic needed to get the data it received from the controller in a format that is ready for the audience you’re serving to. If you’d prefer using a templating language like Twig, or Smarty, a subclass of View will bridge your templating language and CakePHP.

A view file is stored in /app/View/, in a subfolder named after the controller that uses the file. It has a filename corresponding to its action. For example, the view file for the Products controller’s “view()” action would normally be found in /app/View/Products/view.ctp.

The view layer in CakePHP can be made up of a number of different parts. Each part has different uses, and will be covered in this chapter:

• views: Views are the part of the page that is unique to the action being run. They form the meat of your application’s response.

• elements: smaller, reusable bits of view code. Elements are usually rendered inside views.

• layouts: view files that contain presentational code that wraps many interfaces in your application. Most views are rendered inside a layout.

• helpers: these classes encapsulate view logic that is needed in many places in the view layer. Among other things, helpers in CakePHP can help you build forms, build AJAX functionality, paginate model data, or serve RSS feeds.

// app/View/Common/view.ctp
<h1><?php echo $this->fetch('title'); ?></h1>
<?php echo $this->fetch('content'); ?>

<div class="actions">
    <h3>Related actions</h3>
    <ul>
    <?php echo $this->fetch('sidebar'); ?>
    </ul>
</div>

<?php
// app/View/Posts/view.ctp
$this->extend('/Common/view');

$this->assign('title', $post);

$this->start('sidebar');
?>
<li>
<?php
echo $this->Html->link('edit', array(
    'action' => 'edit',
    $post['Post']['id']
)); ?>
</li>
<?php $this->end(); ?>

// The remaining content will be available as the 'content' block
// in the parent view.
<?php echo h($post['Post']['body']);

$this->extend('/Common/view');
$this->extend('/Common/index');

Using view blocks¶

View blocks replace $scripts_for_layout and provide a flexible API that allows you to define slots or blocks in your views/layouts that will be defined elsewhere. For example, blocks are ideal for implementing things such as sidebars, or regions to load assets at the bottom/top of the layout. Blocks can be defined in two ways: either as a capturing block, or by direct assignment. The start(), append() and end() methods allow you to work with capturing blocks:

// Create the sidebar block.
$this->start('sidebar');
echo $this->element('sidebar/recent_topics');
echo $this->element('sidebar/recent_comments');
$this->end();


// Append into the sidebar later on.
$this->append('sidebar');
echo $this->element('sidebar/popular_topics');
$this->end();

You can also append into a block using start() multiple times. assign() can be used to clear or overwrite a block at any time:

// Clear the previous content from the sidebar block.
$this->assign('sidebar', '');

In 2.3, a few new methods were added for working with blocks. The prepend() method was added to prepend content to an existing block:

// Prepend to sidebar
$this->prepend('sidebar', 'this content goes on top of sidebar');

The method startIfEmpty() can be used to start a block only if it is empty or undefined. If the block already exists, the captured content will be discarded. This is useful when you want to conditionally define default content for a block if it does not already exist:

// In a view file.
// Create a navbar block
$this->startIfEmpty('navbar');
echo $this->element('navbar');
echo $this->element('notifications');
$this->end();

// In a parent view/layout
<?php $this->startIfEmpty('navbar'); ?>
<p>If the block is not defined by now - show this instead</p>
<?php $this->end(); ?>

// Somewhere later in the parent view/layout
echo $this->fetch('navbar');

In the above example, the navbar block will only contain the content added in the first section. Since the block was defined in the child view, the default content with the <p> tag will be discarded.

echo $this->fetch('sidebar');

// In app/View/Layouts/default.ctp
<?php if ($this->fetch('menu')): ?>
<div class="menu">
    <h3>Menu options</h3>
    <?php echo $this->fetch('menu'); ?>
</div>
<?php endif; ?>

<div class="shopping-cart">
    <h3>Your Cart</h3>
    <?php echo $this->fetch('cart', 'Your cart is empty'); ?>
</div>

<?php
// In your view file
$this->Html->script('carousel', array('inline' => false));
$this->Html->css('carousel', array('inline' => false));
?>

// In your layout file.
<!DOCTYPE html>
<html lang="en">
    <head>
    <title><?php echo $this->fetch('title'); ?></title>
    <?php echo $this->fetch('script'); ?>
    <?php echo $this->fetch('css'); ?>
    </head>
    // Rest of the layout follows

// In your view
$this->Html->script('carousel', array('block' => 'scriptBottom'));

// In your layout
echo $this->fetch('scriptBottom');

Layouts¶

A layout contains presentation code that wraps around a view. Anything you want to see in all of your views should be placed in a layout.

CakePHP’s default layout is located at /app/View/Layouts/default.ctp. If you want to change the overall look of your application, then this is the right place to start, because controller-rendered view code is placed inside of the default layout when the page is rendered.

Other layout files should be placed in /app/View/Layouts. When you create a layout, you need to tell CakePHP where to place the output of your views. To do so, make sure your layout includes a place for $this->fetch('content') Here’s an example of what a default layout might look like:

<!DOCTYPE html>
<html lang="en">
<head>
<title><?php echo $this->fetch('title'); ?></title>
<link rel="shortcut icon" href="favicon.ico" type="image/x-icon">
<!-- Include external files and scripts here (See HTML helper for more info.) -->
<?php
echo $this->fetch('meta');
echo $this->fetch('css');
echo $this->fetch('script');
?>
</head>
<body>

<!-- If you'd like some sort of menu to
show up on all of your views, include it here -->
<div id="header">
    <div id="menu">...</div>
</div>

<!-- Here's where I want my views to be displayed -->
<?php echo $this->fetch('content'); ?>

<!-- Add a footer to each displayed page -->
<div id="footer">...</div>

</body>
</html>

The script, css and meta blocks contain any content defined in the views using the built-in HTML helper. Useful for including JavaScript and CSS files from views.

The content block contains the contents of the rendered view.

$title_for_layout contains the page title. This variable is generated automatically, but you can override it by setting it in your controller/view as you would any other view variable.

You can create as many layouts as you wish: just place them in the app/View/Layouts directory, and switch between them inside of your controller actions using the controller or view’s $layout property:

// From a controller
public function admin_view() {
    // Stuff
    $this->layout = 'admin';
}

// From a view file
$this->layout = 'loggedin';

For example, if a section of my site included a smaller ad banner space, I might create a new layout with the smaller advertising space and specify it as the layout for all controllers’ actions using something like:

class UsersController extends AppController {
    public function view_active() {
        $this->set('title_for_layout', 'View Active Users');
        $this->layout = 'default_small_ad';
    }

    public function view_image() {
        $this->layout = 'image';
        // Output user image
    }
}

CakePHP features two core layouts (besides CakePHP’s default layout) you can use in your own application: ‘ajax’ and ‘flash’. The Ajax layout is handy for crafting AJAX responses - it’s an empty layout. (Most AJAX calls only require a bit of markup in return, rather than a fully-rendered interface.) The flash layout is used for messages shown by Controller::flash() method.

Three other layouts, xml, js, and rss, exist in the core for a quick and easy way to serve up content that isn’t text/html.

class UsersController extends AppController {
    public function view_active() {
        $this->layout = 'Contacts.contact';
    }
}

Elements¶

Many applications have small blocks of presentation code that need to be repeated from page to page, sometimes in different places in the layout. CakePHP can help you repeat parts of your website that need to be reused. These reusable parts are called Elements. Ads, help boxes, navigational controls, extra menus, login forms, and callouts are often implemented in CakePHP as elements. An element is basically a mini-view that can be included in other views, in layouts, and even within other elements. Elements can be used to make a view more readable, placing the rendering of repeating elements in its own file. They can also help you re-use content fragments in your application.

Elements live in the /app/View/Elements/ folder, and have the .ctp filename extension. They are output using the element method of the view:

echo $this->element('helpbox');

echo $this->element('helpbox', array(
    "helptext" => "Oh, this text is very helpful."
));

// Inside app/View/Elements/helpbox.ctp
echo $helptext; // Outputs "Oh, this text is very helpful."

echo $this->element('helpbox', array(
        "helptext" => "This is passed to the element as $helptext",
        "foobar" => "This is passed to the element as $foobar",
    ),
    array(
        // Uses the "long_view" cache configuration
        "cache" => "long_view",
        // Set to true to have before/afterRender called for the element
        "callbacks" => true
    )
);

$this->element('helpbox', array(), array(
        "cache" => array('config' => 'short', 'key' => 'unique value')
    )
);

class PostsController extends AppController {
    // ...
    public function index() {
        $posts = $this->paginate();
        if ($this->request->is('requested')) {
            return $posts;
        }
        $this->set('posts', $posts);
    }
}

<h2>Latest Posts</h2>
<?php
  $posts = $this->requestAction(
    'posts/index/sort:created/direction:asc/limit:5'
  );
?>
<ol>
<?php foreach ($posts as $post): ?>
      <li><?php echo $post['Post']['title']; ?></li>
<?php endforeach; ?>
</ol>

echo $this->element('helpbox', array(), array('cache' => true));

echo $this->element(
    'helpbox',
    array('var' => $var),
    array('cache' => array('key' => 'first_use', 'config' => 'view_long')
);

echo $this->element(
    'helpbox',
    array('var' => $differenVar),
    array('cache' => array('key' => 'second_use', 'config' => 'view_long')
);

echo $this->element('helpbox', array(), array('plugin' => 'Contacts'));

echo $this->element('Contacts.helpbox');

echo $this->element('helpbox');
// and
echo $this->element('Contacts.helpbox');

Creating your own view classes¶

You may need to create custom view classes to enable new types of data views, or add additional custom view-rendering logic to your application. Like most components of CakePHP, view classes have a few conventions:

• View class files should be put in App/View. For example: App/View/PdfView.php

• View classes should be suffixed with View. For example: PdfView.

• When referencing view class names you should omit the View suffix. For example: $this->viewClass = 'Pdf';.

You’ll also want to extend View to ensure things work correctly:

// In App/View/PdfView.php

App::uses('View', 'View');
class PdfView extends View {
    public function render($view = null, $layout = null) {
        // Custom logic here.
    }
}

Replacing the render method lets you take full control over how your content is rendered.

View API¶

class View¶

View methods are accessible in all view, element and layout files. To call any view method use $this->method()

View::set(string $var, mixed $value)¶

Views have a set() method that is analogous to the set() found in Controller objects. Using set() from your view file will add the variables to the layout and elements that will be rendered later. See Controller Methods for more information on using set().

In your view file you can do:

$this->set('activeMenuButton', 'posts');

Then, in your layout, the $activeMenuButton variable will be available and contain the value ‘posts’.

View::get(string $var, $default = null)¶

Get the value of a viewVar with the name $var.

As of 2.5, you can provide a default value in case the variable is not already set.

Changed in version 2.5: The $default argument was added in 2.5.

View::getVar(string $var)¶

Gets the value of the viewVar with the name $var.

Deprecated since version 2.3: Use View::get() instead.

View::getVars()¶

Gets a list of all the available view variables in the current rendering scope. Returns an array of variable names.

View::element(string $elementPath, array $data, array $options = array())¶

Renders an element or view partial. See the section on Elements for more information and examples.

View::uuid(string $object, mixed $url)¶

Generates a unique non-random DOM ID for an object, based on the object type and URL. This method is often used by helpers that need to generate unique DOM ID’s for elements such as the JsHelper:

$uuid = $this->uuid(
  'form',
  array('controller' => 'posts', 'action' => 'index')
);
// $uuid contains 'form0425fe3bad'

View::addScript(string $name, string $content)¶

Adds content to the internal scripts buffer. This buffer is made available in the layout as $scripts_for_layout. This method is helpful when creating helpers that need to add javascript or css directly to the layout. Keep in mind that scripts added from the layout and elements in the layout will not be added to $scripts_for_layout. This method is most often used from inside helpers, such as the JsHelper and HtmlHelper Helpers.

Deprecated since version 2.1: Use the Using view blocks features instead.

View::blocks()¶

Get the names of all defined blocks as an array.

View::start($name)¶

Start a capturing block for a view block. See the section on Using view blocks for examples.

New in version 2.1.

View::end()¶

End the top most open capturing block. See the section on Using view blocks for examples.

New in version 2.1.

View::append($name, $content)¶

Append into the block with $name. See the section on Using view blocks for examples.

New in version 2.1.

View::prepend($name, $content)¶

Prepend to the block with $name. See the section on Using view blocks for examples.

New in version 2.3.

View::startIfEmpty($name)¶

Start a block if it is empty. All content in the block will be captured and discarded if the block is already defined.

New in version 2.3.

View::assign($name, $content)¶

Assign the value of a block. This will overwrite any existing content. See the section on Using view blocks for examples.

New in version 2.1.

View::fetch($name, $default = '')¶

Fetch the value of a block. If a block is empty or undefined, ‘’ will be returned. See the section on Using view blocks for examples.

New in version 2.1.

View::extend($name)¶

Extend the current view/element/layout with the named one. See the section on Extending Views for examples.

New in version 2.1.

property View::$layout¶

Set the layout the current view will be wrapped in.

property View::$elementCache¶

The cache configuration used to cache elements. Setting this property will change the default configuration used to cache elements. This default can be overridden using the ‘cache’ option in the element method.

property View::$request¶

An instance of CakeRequest. Use this instance to access information about the current request.

property View::$output¶

Contains the last rendered content from a view, either the view file, or the layout content.

Deprecated since version 2.1: Use $view->Blocks->get('content'); instead.

property View::$Blocks¶

An instance of ViewBlock. Used to provide view block functionality in view rendering.

New in version 2.1.

More about Views¶