# Zend_Layout Configuration Options

`Zend_Layout` has a variety of configuration options. These may be set by calling the appropriate accessors, passing an array or `Zend_Config` object to the constructor or `startMvc()`, passing an array of options to `setOptions()`, or passing a `Zend_Config` object to `setConfig()`.

- layout: the layout to use. Uses the current inflector to resolve the name provided to the appropriate layout view script. By default, this value is 'layout' and resolves to 'layout.phtml'. Accessors are `setLayout()` and `getLayout()`.

- layoutPath: the base path to layout view scripts. Accessors are `setLayoutPath()` and `getLayoutPath()`.

- contentKey: the layout variable used for default content (when used with the MVC). Default value is 'content'. Accessors are `setContentKey()` and `getContentKey()`.

- mvcSuccessfulActionOnly: when using the MVC, if an action throws an exception and this flag is true, the layout will not be rendered (this is to prevent double-rendering of the layout when the ErrorHandler plugin is in use). By default, the flat is true. Accessors are `setMvcSuccessfulActionOnly()` and `getMvcSuccessfulActionOnly()`.

- view: the view object to use when rendering. When used with the MVC, `Zend_Layout` will attempt to use the view object registered with the ViewRenderer if no view object has been passed to it explicitly. Accessors are `setView()` and `getView()`.

- helperClass: the action helper class to use when using `Zend_Layout` with the MVC components. By default, this is `Zend_Layout_Controller_Action_Helper_Layout`. Accessors are `setHelperClass()` and `getHelperClass()`.

- pluginClass: the front controller plugin class to use when using `Zend_Layout` with the MVC components. By default, this is `Zend_Layout_Controller_Plugin_Layout`. Accessors are `setPluginClass()` and `getPluginClass()`.

- inflector: the inflector to use when resolving layout names to layout view script paths; see the `Zend_Layout` inflector documentation for more details. Accessors are `setInflector()` and `getInflector()`.

## helperClass and pluginClass must be passed to startMvc()

In order for the `helperClass` and `pluginClass` settings to have effect, they must be passed in as options to `startMvc()`; if set later, they have no affect.

## Examples

The following examples assume the following `$options` array and `$config` object:

    $options = array(
        'layout'     => 'foo',
        'layoutPath' => '/path/to/layouts',
        'contentKey' => 'CONTENT',           // ignored when MVC not used
    );

    /**
    [layout]
    layout = "foo"
    layoutPath = "/path/to/layouts"
    contentKey = "CONTENT"
    */
    $config = new Zend_Config_Ini('/path/to/layout.ini', 'layout');

### Passing options to the constructor or startMvc()

Both the constructor and the `startMvc()` static method can accept either an array of options or a `Zend_Config` object with options in order to configure the `Zend_Layout` instance.

First, let's look at passing an array:

    // Using constructor:
    $layout = new Zend_Layout($options);

    // Using startMvc():
    $layout = Zend_Layout::startMvc($options);

And now using a config object:

    $config = new Zend_Config_Ini('/path/to/layout.ini', 'layout');

    // Using constructor:
    $layout = new Zend_Layout($config);

    // Using startMvc():
    $layout = Zend_Layout::startMvc($config);

Basically, this is the easiest way to customize your `Zend_Layout` instance.

### Using setOption() and setConfig()

Sometimes you need to configure the `Zend_Layout` object after it has already been instantiated; `setOptions()` and `setConfig()` give you a quick and easy way to do so:

    // Using an array of options:
    $layout->setOptions($options);

    // Using a Zend_Config object:
    $layout->setConfig($options);

Note, however, that certain options, such as `pluginClass` and `helperClass`, will have no affect when passed using this method; they need to be passed to the constructor or `startMvc()` method.

### Using Accessors

Finally, you can also configure your `Zend_Layout` instance via accessors. All accessors implement a fluent interface, meaning their calls may be chained:

    $layout->setLayout('foo')
           ->setLayoutPath('/path/to/layouts')
           ->setContentKey('CONTENT');