This is a title
This is the post content
This is another title
This is another post content
```
### Render Levels
As seen above, [Phalcon\Mvc\View][mvc-view] supports a view hierarchy. You might need to control the level of rendering produced by the view component. The method `Phalcon\Mvc\View::setRenderLevel()` offers this functionality.
This method can be invoked from the controller or from a superior view layer to interfere with the rendering process.
```php
view->setRenderLevel(
View::LEVEL_NO_RENDER
);
// ...
}
public function viewAction($invoiceId)
{
$this->view->setRenderLevel(
View::LEVEL_ACTION_VIEW
);
}
}
```
The available render levels are:
| Class Constant | Description | Order |
|-------------------------|--------------------------------------------------------------------------|:-----:|
| `LEVEL_NO_RENDER` | Indicates to avoid generating any kind of presentation. | |
| `LEVEL_ACTION_VIEW` | Generates the presentation to the view associated with the action. | 1 |
| `LEVEL_BEFORE_TEMPLATE` | Generates presentation templates prior to the controller layout. | 2 |
| `LEVEL_LAYOUT` | Generates the presentation to the controller layout. | 3 |
| `LEVEL_AFTER_TEMPLATE` | Generates the presentation to the templates after the controller layout. | 4 |
| `LEVEL_MAIN_LAYOUT` | Generates the presentation to the main layout. File views/index.phtml | 5 |
### Disabling Render Levels
You can permanently or temporarily disable render levels. A level could be permanently disabled if it isn't used at all in the whole application:
```php
set(
'view',
function () {
$view = new View();
// Disable several levels
$view->disableLevel(
[
View::LEVEL_LAYOUT => true,
View::LEVEL_MAIN_LAYOUT => true,
]
);
return $view;
},
true
);
```
Or disable temporarily in some part of the application:
```php
view->disableLevel(
View::LEVEL_MAIN_LAYOUT
);
}
}
```
### Disabling the View
If your controller does not produce any output for the view (or does not even have one) you may disable the view component to avoid unnecessary processing:
```php
view->disable();
}
}
```
Alternatively, you can return `false` to produce the same effect:
```php
response
->redirect('index/index')
;
}
}
```
## Simple Rendering
:::warning[WARNING]
You can use `echo` when calling `$view->render()`, which will output the contents of the rendering process on screen. This **only works** with [Phalcon\Mvc\View\Simple][mvc-view-simple] and **not** with [Phalcon\Mvc\View][mvc-view]. Using `echo` with the latter will produce a warning.
:::
[Phalcon\Mvc\View\Simple][mvc-view-simple] is an alternative component to [Phalcon\Mvc\View][mvc-view]. It keeps most of the philosophy of [Phalcon\Mvc\View][mvc-view] but lacks a hierarchy of files which is, in fact, the main feature of its counterpart.
This component allows you to have control of when a view is rendered and its location. In addition, this component can leverage view inheritance available in template engines such as [Volt][volt] and others.
The default component must be replaced in the service container:
```php
set(
'view',
function () {
$view = new Simple();
$view->setViewsDir('../app/views/');
return $view;
},
true
);
```
Automatic rendering must be disabled in [Phalcon\Mvc\Application][application] (if needed):
```php
useImplicitView(false);
$response = $application->handle(
$_SERVER["REQUEST_URI"]
);
$response->send();
} catch (Exception $e) {
echo $e->getMessage();
}
```
To render a view it is necessary to call the render method explicitly indicating the relative path to the view you want to display:
```php
view->render('index');
// 'views-dir/posts/show.phtml'
echo $this->view->render('posts/show');
// 'views-dir/index.phtml' passing variables
echo $this->view->render(
'index',
[
'posts' => Invoices::find(),
]
);
// 'views-dir/invoices/view.phtml' passing variables
echo $this->view->render(
'invoices/view',
[
'posts' => Invoices::find(),
]
);
}
}
```
This is different to the `render` that [Phalcon\Mvc\View][mvc-view] implements, which uses controllers and actions as parameters:
```php
Invoices::find(),
];
// Phalcon\Mvc\View
$view = new View();
$view->render('invoices', 'view', $params);
// Phalcon\Mvc\View\Simple
$simpleView = new Simple();
echo $simpleView->render('invoices/view', $params);
```
### Picking Views
As mentioned above, when [Phalcon\Mvc\View][mvc-view] is managed by [Phalcon\Mvc\Application][application], the view rendered is the one related to the last controller and action executed. You could override this by using the `pick()` method:
```php
view->pick('invoices/search');
// Pick 'views-dir/invoices/list' as a view to render
$this->view->pick(
[
'invoices',
]
);
// Pick 'views-dir/invoices/search' as a view to render
$this->view->pick(
[
1 => 'search',
]
);
}
}
```
## Partials
Partial templates are another way of breaking the rendering process into simpler more manageable chunks that can be reused by different parts of the application. With a partial, you can move the code for rendering a particular piece of a response to its own file.
One way to use partials is to treat them as HTML fragments that can be injected wherever needed with any necessary parameters:
```php