View Phalcon

View Phalcon mewakili antarmuka pengguna aplikasi Anda. Views seringnya berupa file HTML dengan kode PHP yang melakukan tugas-tugas yang semata-mata hanya untuk penyajian data. Views menangani pekerjaan penyediaan data ke browser web atau alat lain yang digunakan untuk membuat request dari aplikasi Anda.

The Phalcon \ MVC \ View dan Phalcon \ MVC \ View \ Simple bertanggung jawab atas pengelolaan lapisan view dari aplikasi MVC Anda.

Mengintegrasikan View Phalcon dengan Controller 

Phalcon otomatis melanjutkan eksekusi ke komponen view segera setelah suatu controller telah menyelesaikan siklus eksekusinya. Komponen view akan terlihat dibawah folder views pada folder yg memiliki nama yang sama dari controller terakhir yang dieksekusi dan kemudian untuk sebuah file bernama sama dgn action terakhir yang dijalankan. Misalnya, jika request untuk URL http://127.0.0.1/blog/posts/show/301, Phalcon akan mengurai URL sebagai berikut:

Server Alamat 127.0.0.1
Direktori Phalcon blog
Controller posts
Action show
Parameter 301

Dispatcher akan mencari “PostsController” dan action “showAction”. Sebuah file controller sederhana untuk contoh ini:

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function indexAction()
    {

    }

    public function showAction($postId)
    {
        // Pass the $postId parameter to the view
        $this->view->setVar("postId", $postId);
    }

}

SetVar ini membantu kita untuk membuat variabel pada view sehingga dapat digunakan dalam template view. Contoh di atas menunjukkan bagaimana untuk memberikan parameter $postID ke tampilan template yg dimaksud.

Hirarki Render 

Phalcon \ MVC \ View mendukung hirarki file dan merupakan komponen standar untuk tampilan render di Phalcon. Hirarki ini memungkinkan untuk poin tata letak umum (view yg sering digunakan), serta controller sbg nama folder mendefinisikan masing-masing tampilan template.

Komponen ini secara default menggunakan PHP sebagai mesin template, karena itu view harus memiliki ekstensi .phtml. Jika direktori yg dilihat adalah app/views kemudian komponen view akan secara otomatis mencari untuk ini 3 file view.

Nama Berkas Deskripsi
Action View app / views / posts / show.phtml Ini adalah view yang berkaitan dengan action. Ini hanya akan ditampilkan ketika action “show”  dieksekusi.
Controller
Layout
app / views / layouts / posts.phtml Ini adalah view yang berkaitan dengan controller. Ini hanya akan ditampilkan untuk setiap action yang dilakukan dalam “posts” controller. Semua kode diimplementasikan dalam tata letak akan digunakan kembali untuk semua tindakan dalam kontroler ini.
Main Layout app / views / index.phtml Ini adalah tindakan utama yg akan ditampilkan untuk setiap controller atau action yang dilakukan dalam aplikasi.

Anda tidak diharuskan untuk melaksanakan semua file yang disebutkan di atas. Phalcon \ MVC \ View hanya akan pindah ke tingkat tampilan berikutnya dalam hirarki file. Jika ketiga file tampilan dilaksanakan, mereka akan diproses sebagai berikut:

<!-- app/views/posts/show.phtml -->

<h3>This is show view!</h3>

<p>I have received the parameter <?php echo $postId ?></p>
<!-- app/views/layouts/posts.phtml -->

<h2>This is the "posts" controller layout!</h2>

<?php echo $this->getContent() ?>
<!-- app/views/index.phtml -->
<html>
    <head>
        <title>Example</title>
    </head>
    <body>

        <h1>This is main layout!</h1>

        <?php echo $this->getContent() ?>

    </body>
</html>

Perhatikan baris di mana metode $this->getContent() dipanggil. Metode ini menginstruksikan Phalcon \ MVC \ View di mana untuk menyuntikkan isi dari tampilan sebelumnya dieksekusi dalam hirarki. Untuk contoh di atas, output akan:

HTML yang dihasilkan oleh permintaan akan:

<!-- app/views/index.phtml -->
<html>
    <head>
        <title>Example</title>
    </head>
    <body>

        <h1>This is main layout!</h1>

        <!-- app/views/layouts/posts.phtml -->

        <h2>This is the "posts" controller layout!</h2>

        <!-- app/views/posts/show.phtml -->

        <h3>This is show view!</h3>

        <p>I have received the parameter 101</p>

    </body>
</html>

Menggunakan Template 

Template adalah view yang dapat digunakan untuk berbagi kode view umum. File ini bertindak sebagai layout controller, sehingga Anda perlu menempatkan mereka di direktori layout.

<?php

class PostsController extends \Phalcon\Mvc\Controller
{
    public function initialize()
    {
        $this->view->setTemplateAfter('common');
    }

    public function lastAction()
    {
        $this->flash->notice("These are the latest posts");
    }
}
<!-- app/views/index.phtml -->
<!DOCTYPE html>
<html>
    <head>
        <title>Blog's title</title>
    </head>
    <body>
        <?php echo $this->getContent() ?>
    </body>
</html>
<!-- app/views/layouts/common.phtml -->

<ul class="menu">
    <li><a href="/">Home</a></li>
    <li><a href="/articles">Articles</a></li>
    <li><a href="/contact">Contact us</a></li>
</ul>

<div class="content"><?php echo $this->getContent() ?></div>
<!-- app/views/layouts/posts.phtml -->

<h1>Blog Title</h1>

<?php echo $this->getContent() ?>
<!-- app/views/posts/last.phtml -->

<article>
    <h2>This is a title</h2>
    <p>This is the post content</p>
</article>

<article>
    <h2>This is another title</h2>
    <p>This is another post content</p>
</article>

Hasil akhir akan menjadi sebagai berikut:

<!-- app/views/index.phtml -->
<!DOCTYPE html>
<html>
    <head>
        <title>Blog's title</title>
    </head>
    <body>

        <!-- app/views/layouts/common.phtml -->

        <ul class="menu">
            <li><a href="/">Home</a></li>
            <li><a href="/articles">Articles</a></li>
            <li><a href="/contact">Contact us</a></li>
        </ul>

        <div class="content">

            <!-- app/views/layouts/posts.phtml -->

            <h1>Blog Title</h1>

            <!-- app/views/posts/last.phtml -->

            <article>
                <h2>This is a title</h2>
                <p>This is the post content</p>
            </article>

            <article>
                <h2>This is another title</h2>
                <p>This is another post content</p>
            </article>

        </div>

    </body>
</html>

Mengontrol Level Render 

Seperti yang terlihat di atas, Phalcon \ MVC \ View mendukung tampilan hirarki. Anda mungkin perlu untuk mengontrol tingkat render yg diproduksi oleh komponen view. Metode Phalcon\Mvc\View::setRenderLevel() menawarkan fungsi ini.

Metode ini dapat dipanggil dari controller atau dari pandangan lapisan pertama untuk mendahului proses rendering.

<?php

use Phalcon\Mvc\Controller,
    Phalcon\Mvc\View;

class PostsController extends Controller
{

    public function indexAction()
    {

    }

    public function findAction()
    {

        // This is an Ajax response so it doesn't generate any kind of view
        $this->view->setRenderLevel(View::LEVEL_NO_RENDER);

        //...
    }

    public function showAction($postId)
    {
        // Shows only the view related to the action
        $this->view->setRenderLevel(View::LEVEL_ACTION_VIEW);
    }

}

Render level yang tersedia adalah:

Kelas Konstan Deskripsi Urutan
LEVEL_NO_RENDER Menunjukkan untuk menghindari menghasilkan presentasi apapun.
LEVEL_ACTION_VIEW Menghasilkan presentasi ke tampilan terkait dengan action. 1
LEVEL_BEFORE_TEMPLATE Menghasilkan template presentasi sebelum layout kontroler. 2
LEVEL_LAYOUT Menghasilkan presentasi untuk layout kontroler. 3
LEVEL_AFTER_TEMPLATE Menghasilkan presentasi ke template setelah layout kontroler. 4
LEVEL_MAIN_LAYOUT Menghasilkan presentasi untuk layout utama.Views / file index.phtml 5

Menonaktifkan Level Render 

Anda dapat permanen atau sementara menonaktifkan level render. Satu lapisan bisa dinonaktifkan secara permanen jika tidak digunakan sama sekali dalam seluruh aplikasi:

<?php

use Phalcon\Mvc\View;

$di->set('view', function(){

    $view = new View();

    //Disable several levels
    $view->disableLevel(array(
        View::LEVEL_LAYOUT => true,
        View::LEVEL_MAIN_LAYOUT => true
    ));

    return $view;

}, true);

Atau menonaktifkan sementara di beberapa bagian dari aplikasi:

<?php

use Phalcon\Mvc\View,
    Phalcon\Mvc\Controller;

class PostsController extends Controller
{

    public function indexAction()
    {

    }

    public function findAction()
    {
        $this->view->disableLevel(View::LEVEL_MAIN_LAYOUT);
    }

}

Memilih Views 

Sebagaimana disebutkan di atas, ketika Phalcon \ MVC \ View dikelola oleh Phalcon \ MVC \ Application view yang diberikan adalah yang terkait dengan kontroler terakhir dan tindakan yang dilakukan. Anda bisa mengganti ini dengan menggunakan metode Phalcon\MVC\View::pick():

<?php

class ProductsController extends \Phalcon\Mvc\Controller
{

    public function listAction()
    {
        // Pick "views-dir/products/search" as view to render
        $this->view->pick("products/search");

        // Pick "views-dir/products/list" as view to render
        $this->view->pick(array('products'));

        // Pick "views-dir/products/list" as view to render
        $this->view->pick(array(1 => 'search'));
    }

}

Menonaktifkan View 

Jika controller tidak menghasilkan output dalam tampilan (atau bahkan tidak memiliki sama sekali) Anda dapat menonaktifkan komponen view menghindari pengolahan yang tidak perlu:

<?php

class UsersController extends \Phalcon\Mvc\Controller
{

    public function closeSessionAction()
    {
        //Close session
        //...

        //An HTTP Redirect
        $this->response->redirect('index/index');

        //Disable the view to avoid rendering
        $this->view->disable();
    }

}

Anda dapat mengembalikan objek ‘response’ untuk menghindari menonaktifkan tampilan secara manual:

<?php

class UsersController extends \Phalcon\Mvc\Controller
{

    public function closeSessionAction()
    {
        //Close session
        //...

        //An HTTP Redirect
        return $this->response->redirect('index/index');
    }

}

Rendering Sederhana 

Phalcon \ MVC \ View \ Simple merupakan komponen alternatif untuk Phalcon \ MVC \ View . Komponen ini membuat sebagian besar filosofi Phalcon \ MVC \ View tetapi tidak mendukung hirarki file, yg pada kenyataannya, menjadi fitur utamanya.

Komponen ini membantu pengembang untuk memiliki kontrol ketika view yang dirender dan lokasinya. Selain itu, komponen ini dapat memanfaatkan view inheritance yg tersedia dalam mesin template seperti Volt dan lain-lain.

Komponen standar harus diganti dalam wadah layanan:

<?php

$di->set('view', function() {

    $view = new Phalcon\Mvc\View\Simple();

    $view->setViewsDir('../app/views/');

    return $view;

}, true);

Render otomatis harus dinonaktifkan Phalcon \ MVC \ Application (jika diperlukan):

<?php

try {

    $application = new Phalcon\Mvc\Application($di);

    $application->useImplicitView(false);

    echo $application->handle()->getContent();

} catch (\Exception $e) {
    echo $e->getMessage();
}

Untuk membuat tampilan itu perlu untuk memanggil metode render secara eksplisit menunjukkan path relatif ke tampilan yang ingin ditampilkan:

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function indexAction()
    {
        //Render 'views-dir/index.phtml'
        echo $this->view->render('index');

        //Render 'views-dir/posts/show.phtml'
        echo $this->view->render('posts/show');

        //Render 'views-dir/index.phtml' passing variables
        echo $this->view->render('index', array('posts' => Posts::find()));

        //Render 'views-dir/posts/show.phtml' passing variables
        echo $this->view->render('posts/show', array('posts' => Posts::find()));
    }

}

Menggunakan parsial 

Template parsial adalah cara lain untuk variasi proses rendering menjadi lebih potongan sederhana yg lebih mudah dikelola yang dapat digunakan kembali oleh bagian-bagian yang berbeda dari aplikasi. Dengan parsial, Anda dapat memindahkan kode untuk rendering bagian tertentu dari respon pada file tersendiri.

Salah satu cara untuk menggunakan parsial adalah dengan memperlakukannya setara dengan subrutin: sebagai cara untuk memindahkan rincian dari pandangan sehingga kode Anda dapat lebih mudah dipahami. Sebagai contoh, Anda mungkin memiliki view yang terlihat seperti ini:

<div class="top"><?php $this->partial("shared/ad_banner") ?></div>

<div class="content">
    <h1>Robots</h1>

    <p>Check out our specials for robots:</p>
    ...
</div>

<div class="footer"><?php $this->partial("shared/footer") ?></div>

Metode parsial() menerima parameter kedua berupa array berisi variabel / parameter yang hanya akan ada di lingkup parsial, hendak diolah pada view parsial tsb:

<?php $this->partial("shared/ad_banner", array('id' => $site->id, 'size' => 'big')) ?>

Mentransfer nilai-nilai dari controller ke view 

Phalcon \ MVC \ View tersedia dalam setiap controller menggunakan variabel view ($this->view). Anda dapat menggunakan objek tsb u/ menyiapkan variabel langsung ke view dari aksi kontroler dengan menggunakan method setVar() .

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function indexAction()
    {

    }

    public function showAction()
    {
        //Pass all the posts to the views
        $this->view->setVar("posts", Posts::find());

        //Using the magic setter
        $this->view->posts = Posts::find();

        //Passing more than one variable at the same time
        $this->view->setVars(array(
            'title' => $post->title,
            'content' => $post->content
        ));
    }

}

Sebuah nama variabel yg disebut pada parameter pertama setVar() akan dibuat dalam tampilan ini, siap untuk digunakan. Variabel dapat dari jenis apa pun, dari string sederhana, integer dll. variabel untuk struktur yang lebih kompleks seperti array, koleksi dll

<div class="post">
<?php

  foreach ($posts as $post) {
    echo "<h1>", $post->title, "</h1>";
  }

?>
</div>

Menggunakan model dalam lapisan view 

Model aplikasi selalu tersedia di lapisan view. The Phalcon \ Loader akan instantiate mereka di runtime secara otomatis:

<div class="categories">
<?php

    foreach (Categories::find("status = 1") as $category) {
       echo "<span class='category'>", $category->name, "</span>";
    }

?>
</div>

Meskipun Anda dapat melakukan operasi manipulasi Model seperti insert() atau update() di lapisan view, akan tetapi tidak dianjurkan karena tidak mungkin untuk meneruskan aliran eksekusi ke controller lain dalam kasus kesalahan atau pengecualian.

Cache Fragmen View 

Kadang-kadang ketika Anda mengembangkan website dinamis dan beberapa area tidak sering berubah, output persis sama antar request. Phalcon \ MVC \ View menawarkan cache sebagian atau seluruh output yg dirender untuk meningkatkan kinerja.

Phalcon \ MVC \ View terintegrasi dengan Phalcon \ Cache untuk menyediakan cara yang lebih mudah untuk cache fragmen output. Anda bisa secara manual mengatur pengendali cache atau menetapkan handler global:

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function showAction()
    {
        //Cache the view using the default settings
        $this->view->cache(true);
    }

    public function showArticleAction()
    {
        // Cache this view for 1 hour
        $this->view->cache(array(
            "lifetime" => 3600
        ));
    }

    public function resumeAction()
    {
        //Cache this view for 1 day with the key "resume-cache"
        $this->view->cache(
            array(
                "lifetime" => 86400,
                "key"      => "resume-cache",
            )
        );
    }

    public function downloadAction()
    {
        //Passing a custom service
        $this->view->cache(
            array(
                "service"  => "myCache",
                "lifetime" => 86400,
                "key"      => "resume-cache",
            )
        );
    }

}

Ketika kita tidak mendefinisikan key untuk cache, komponen otomatis membuat satu md5 dr nama view saat diberikan. Ini adalah praktik yang baik untuk menentukan key untuk setiap tindakan sehingga Anda dapat dengan mudah mengidentifikasi cache yang terkait dengan setiap tampilan.

Ketika komponen View memerlukan cache sesuatu, maka akan meminta layanan cache di wadah layanan. Nama (kaidah) layanan ini adalah “viewCache”:

<?php

use Phalcon\Cache\Frontend\Output as OutputFrontend,
    Phalcon\Cache\Backend\Memcache as MemcacheBackend;

//Set the views cache service
$di->set('viewCache', function() {

    //Cache data for one day by default
    $frontCache = new OutputFrontend(array(
        "lifetime" => 86400
    ));

    //Memcached connection settings
    $cache = new MemcacheBackend($frontCache, array(
        "host" => "localhost",
        "port" => "11211"
    ));

    return $cache;
});

Frontend harus selalu Phalcon\Cache\Frontend\output dan layanan ‘viewCache’ harus terdaftar sebagai selalu terbuka (tidak dibagi) dalam layanan wadah (DI)

Menggunakan cache view juga berguna untuk mencegah controller melakukan proses yang menghasilkan data yang akan ditampilkan dalam view.

Untuk mencapai hal ini kita harus mengidentifikasi secara unik setiap Cache dengan key. Pertama kita memverifikasi bahwa cache tidak ada atau telah berakhir, untuk membuat perhitungan / query & menampilkan data dalam tampilan:

<?php

class DownloadController extends \Phalcon\Mvc\Controller
{

    public function indexAction()
    {

        //Check whether the cache with key "downloads" exists or has expired
        if ($this->view->getCache()->exists('downloads')) {

            //Query the latest downloads
            $latest = Downloads::find(array(
                'order' => 'created_at DESC'
            ));

            $this->view->latest = $latest;
        }

        //Enable the cache with the same key "downloads"
        $this->view->cache(array(
            'key' => 'downloads'
        ));
    }

}

The lokasi alternatif PHP adalah contoh penerapan caching fragmen.

Template Engine 

Mesin Template membantu desainer untuk membuat tampilan tanpa menggunakan sintaks yang rumit. Phalcon memiliki mesin template yang kuat dan cepat yang disebut Volt .

Selain itu, Phalcon \ MVC \ View memungkinkan Anda untuk menggunakan mesin template lain, bukan plain-PHP atau Volt.

Menggunakan mesin template yang berbeda, biasanya membutuhkan parsing teks yang kompleks menggunakan library PHP eksternal untuk menghasilkan hasil akhir bagi pengguna. Hal ini biasanya meningkatkan jumlah sumber daya yang aplikasi Anda gunakan.

Jika mesin template eksternal digunakan, Phalcon \ MVC \ View menyediakan fasilitas hirarki view yang sama dan itu masih bisa untuk mengakses API di dalam template ini dengan sedikit usaha.

Komponen ini menggunakan adapter, ini membantu Phalcon untuk berbicara dengan mesin template eksternal dengan cara universal, mari kita lihat bagaimana melakukan integrasi itu.

Membuat Template Engine Adapter  Anda sendiri

Ada banyak mesin template, yang mungkin ingin Anda integrasikan atau membuat salah satunya sendiri. Langkah pertama untuk mulai menggunakan mesin template eksternal adalah membuat adaptor untuk itu.

Sebuah adaptor template engine adalah kelas yang bertindak sebagai jembatan antara Phalcon \ MVC \ View dan mesin template itu sendiri. Biasanya hanya membutuhkan dua metode yang diterapkan: __ construct() dan render(). Yang pertama menerima instance Phalcon \ MVC \ View yang menciptakan adaptor mesin dan wadah DI yang digunakan oleh aplikasi.

Metode render() menerima path absolut ke file view dan parameter tampilan diatur menggunakan $this->lihat->setVar(). Anda bisa membaca atau memerlukannya bila perlu.

<?php

class MyTemplateAdapter extends \Phalcon\Mvc\View\Engine
{

    /**
     * Adapter constructor
     *
     * @param \Phalcon\Mvc\View $view
     * @param \Phalcon\DI $di
     */
    public function __construct($view, $di)
    {
        //Initialize here the adapter
        parent::__construct($view, $di);
    }

    /**
     * Renders a view using the template engine
     *
     * @param string $path
     * @param array $params
     */
    public function render($path, $params)
    {

        // Access view
        $view = $this->_view;

        // Access options
        $options = $this->_options;

        //Render the view
        //...
    }

}

Mengubah Template Engine 

Anda dapat mengganti atau menambahkan mesin template dari controller sebagai berikut:

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function indexAction()
    {
        // Set the engine
        $this->view->registerEngines(
            array(
                ".my-html" => "MyTemplateAdapter"
            )
        );
    }

    public function showAction()
    {
        // Using more than one template engine
        $this->view->registerEngines(
            array(
                ".my-html" => 'MyTemplateAdapter',
                ".phtml" => 'Phalcon\Mvc\View\Engine\Php'
            )
        );
    }

}

Anda dapat mengganti mesin template sepenuhnya atau menggunakan lebih dari satu template engine pada saat yang sama. Metode Phalcon\MVC\View::registerEngines() menerima sebuah array data yang berisi opsi yang menentukan mesin template. Kunci dari masing-masing mesin adalah ekstensi file (view) yang membantu dalam membedakan satu dari yang lain. File template terkait dengan mesin tertentu harus memiliki mereka ekstensi.

Urutan mesin template yg didefinisikan dengan Phalcon\MVC\View::registerEngines() mendefinisikan relevansi/urutan eksekusi. Jika Phalcon \ MVC \ View menemukan dua view dengan nama yang sama namun ekstensi yang berbeda, maka hanya akan me-render file yang pertama.

Jika Anda ingin mendaftar mesin template atau satu set untuk setiap permintaan dalam aplikasi. Anda bisa mendaftar ketika tampilan layanan dibuat:

<?php

//Setting up the view component
$di->set('view', function() {

    $view = new \Phalcon\Mvc\View();

    //A trailing directory separator is required
    $view->setViewsDir('../app/views/');

    $view->registerEngines(array(
        ".my-html" => 'MyTemplateAdapter'
    ));

    return $view;

}, true);

Ada beberapa adapter yang tersedia untuk berbagai mesin template pada Phalcon Incubator

Penyuntikan Service di View 

Setiap view yg dieksekusi disertakan di dalamnya sebuah instance Phalcon \ DI \ Injection, menyediakan akses mudah ke wadah layanan aplikasi.

Contoh berikut menunjukkan bagaimana menulis sebuah jQuery permintaan ajax menggunakan url dengan kaidah framework. Layanan “url” (biasanya Phalcon \ MVC \ Url ) disuntikkan dalam tampilan dengan mengakses properti dengan nama yang sama:

<script type="text/javascript">

$.ajax({
    url: "<?php echo $this->url->get("cities/get") ?>"
})
.done(function() {
    alert("Done!");
});

</script>

Komponen Stand-Alone  

Semua komponen dalam Phalcon dapat digunakan sebagai komponen penghubung karena masing-masing loosely coupled satu sama lain:

Render hirarki 

Menggunakan Phalcon \ Mvc \ View dalam mode stand-alone dapat ditunjukkan di bawah ini

<?php

$view = new \Phalcon\Mvc\View();

//A trailing directory separator is required
$view->setViewsDir("../app/views/");

// Passing variables to the views, these will be created as local variables
$view->setVar("someProducts", $products);
$view->setVar("someFeatureEnabled", true);

//Start the output buffering
$view->start();

//Render all the view hierarchy related to the view products/list.phtml
$view->render("products", "list");

//Finish the output buffering
$view->finish();

echo $view->getContent();

Sebuah sintaks pendek juga tersedia:

<?php

$view = new \Phalcon\Mvc\View();

echo $view->getRender('products', 'list',
    array(
        "someProducts" => $products,
        "someFeatureEnabled" => true
    ),
    function($view) {
        //Set any extra options here
        $view->setViewsDir("../app/views/");
        $view->setRenderLevel(Phalcon\Mvc\View::LEVEL_LAYOUT);
    }
);

Rendering sederhana 

Menggunakan Phalcon \ MVC \ View \ Simple dalam mode stand-alone dapat ditunjukkan di bawah ini:

<?php

$view = new \Phalcon\Mvc\View\Simple();

//A trailing directory separator is required
$view->setViewsDir("../app/views/");

// Render a view and return its contents as a string
echo $view->render("templates/welcomeMail");

// Render a view passing parameters
echo $view->render("templates/welcomeMail", array(
    'email' => $email,
    'content' => $content
));

Event View 

Phalcon \ MVC \ View dan Phalcon \ MVC \ View dapat mengirim event ke EventsManager jika ada. Event yang dipicu bertipe “view”. Beberapa event ketika mengembalikan boolean false bisa menghentikan operasi aktif. Peristiwa berikut ini didukung:

Nama Acara Dipicu Bisa menghentikan operasi?
beforeRender Dipicu sebelum memulai proses render Ya
beforeRenderView Dipicu sebelum menampilkan pandangan yang ada Ya
afterRenderView Dipicu setelah render pandangan yang ada Tidak
afterRender Dipicu setelah menyelesaikan proses render Tidak
notFoundView Dipicu ketika pandangan tidak ditemukan Tidak

Contoh berikut menunjukkan bagaimana untuk melampirkan pendengar untuk komponen ini:

<?php

$di->set('view', function() {

    //Create an events manager
    $eventsManager = new Phalcon\Events\Manager();

    //Attach a listener for type "view"
    $eventsManager->attach("view", function($event, $view) {
        echo $event->getType(), ' - ', $view->getActiveRenderPath(), PHP_EOL;
    });

    $view = new \Phalcon\Mvc\View();
    $view->setViewsDir("../app/views/");

    //Bind the eventsManager to the view component
    $view->setEventsManager($eventsManager);

    return $view;

}, true);

Contoh berikut ini menunjukkan bagaimana untuk membuat sebuah plugin yang bersih / memperbaiki HTML yang dihasilkan oleh proses render menggunakan Tidy :

<?php

class TidyPlugin
{

    public function afterRender($event, $view)
    {

        $tidyConfig = array(
            'clean' => true,
            'output-xhtml' => true,
            'show-body-only' => true,
            'wrap' => 0,
        );

        $tidy = tidy_parse_string($view->getContent(), $tidyConfig, 'UTF8');
        $tidy->cleanRepair();

        $view->setContent((string) $tidy);
    }

}

//Attach the plugin as a listener
$eventsManager->attach("view:afterRender", new TidyPlugin());
Terjemahan dari Menggunakan View Phalcon
http://docs.phalconphp.com/en/latest/reference/views.html