The easiest way that i have found so far is to create Twig extension. In our default bundle we need to create folder Twig/Extension for example Acme/PageBundle/Twig/Extension and place there our Twig extension class:

<?php
// src/Acme/PageBundle/Twig/Extension/AcmePageExtension.php

namespace Acme\PageBundle\Twig\Extension;

use Symfony\Component\HttpFoundation\Request;

class AcmePageExtension extends \Twig_Extension
{
	protected $request;
	/**
	 *
	 * @var \Twig_Environment
	 */
	protected $environment;

	public function __construct(Request $request)
	{
		$this->request = $request;
	}

	public function initRuntime(\Twig_Environment $environment)
	{
		$this->environment = $environment;
	}

	public function getFunctions()
	{
		return array(
	            'get_controller_name' => new \Twig_Function_Method($this, 'getControllerName'),
	            'get_action_name' => new \Twig_Function_Method($this, 'getActionName'),
		);
	}

	/**
	 * Get current controller name
	 */
	public function getControllerName()
	{
		$pattern = "#Controller\\\([a-zA-Z]*)Controller#";
		$matches = array();
		preg_match($pattern, $this->request->get('_controller'), $matches);

		return strtolower($matches[1]);
	}

	/**
	 * Get current action name
	 */
	public function getActionName()
	{
		$pattern = "#::([a-zA-Z]*)Action#";
		$matches = array();
		preg_match($pattern, $this->request->get('_controller'), $matches);

		return $matches[1];
	}

	public function getName()
	{
		return 'acme_page';
	}
}

Next step is to register this service:

// src/Acme/PageBundle/Resources/config/services.yml
    request:
        class:        Symfony\Component\HttpFoundation\Reques

    acme.twig.extension:
        class: Acme\PageBundle\Twig\Extension\AcmePageExtension
        arguments:  [@request]
        tags:
            - { name: 'twig.extension' }

and then in twig templates we can simply call:

Controller name: {{ get_controller_name() }}
Action name: {{ get_action_name() }}

Ogromną zaletą Symfony2 jest w pełni przepisany silnik frameworka, który w pełni wykorzystuje możliwości PHP 5.3. Przestrzenie nazw nie tylko rozwiązuje problem konfliktów i długich nazw ale także sprawiają, że ładowanie potrzebnych klas jest teraz znacznie prostsze.

Instalacja
Do ściągnięcia dostępna jest gotowa paczka zawierająca wszystkie biblioteki niezbędne do rozpoczęcia pracy. Osobiście polecam instalację framewokra z Gita (najwygodniej pod Linuxem, chociaż jest też ciekawa wersja pod Windowsa dla zainteresowanych). Dzięki temu wszelkie aktualizacje zewnętrznych bibliotek, czy tez bibliotek frameworka sprowadzają się do aktualizacji plików deps i deps.lock, a następnie wywołania z wiersza poleceń komendy:

php bin/vendors update

Bundles
Symfony2 to przede wszystkim ogromne zmiany w architekturze i organizacji kodu aplikacji. Każda aplikacja składa się teraz z pakietów: bundles – coś na wzór modułu z symfony 1.X, z tym że każdy bundle jest teraz dużo bardziej niezależny: posiada odrębną logikę, konfigurację, klasy Entity czy usługi. Dzięki temu nowy mechanizm rozszerzeń Symfony2 jest w całości oparty o bundles – w sieci można znaleźć wiele ciekawie napisanych rozszerzeń: rozbudowany panel administracyjny wzorowany na Django (SonataAdmin) + szereg rozszerzeń, biblioteka do manipulacji/modyfikacji obrazków inspirowana Pythonowym PILem (Imagine), Goutte, biblioteka do budowania scenariuszy, które są następnie wykorzystywane do testowania funkcjonalności (Behat + Mink).

Formularze
Początkowo bardzo toporne – brakuje dobrej dokumentacji. Stworzenie formularza rejestracji, dodanie walidacji (dodanie zależności między polami) stanowi nie lada wyzwanie. Nie podoba mi się przeniesienie walidacji do klasy yml/xml – tak jakbyśmy wracali do symfony 1.0. Na szczęście są annotacje, które można wykorzystać zarówno w klasach Entity, jak i Models. UWAGA na problem z eAcceleratorem – straciłem kilka dobrych godzin przez problem z obcinaniem komentarzy na serwerze produkcyjnym. eAccelerator nie współpracuje poprawnie z nowymi bibliotekami: Symfony2, Doctrine2, Zend Framework, PHP Unit, … . Niestety po kilku godzinach pracy z formularzami miałem odczucie jakby cały mechanizm był teraz znacznie bardziej skomplikowany i trudny do opanowania.

Doctrine2
Nowa wersja Doctrine niesie ze sobą szereg udogodnień – zwłaszcza jeśli chodzi o wydajność działania biblioteki. Z biblioteki zostały usunięte magiczne metody setterów i getterów.

    $user= new User();
    $user->setName('Kamil Adryjanek');

    $em = $this->getDoctrine()->getEntityManager();
    $em->persist($user);
    $em->flush();

Usprawniono model cachowania danych.
Z Core usunięte zostały funkcjonalności behaviours, które zostały przeniesione do zewnętrznych bibliotek.
Niestety miałem okazję trafić na kilka problemów, które dość znacząco utrudniają pracę, np:

php app\console doctrine:generate:entities

dla klas dziedziczących po innych Entity, powoduje wygenerowanie prywatnych atrybutów klasy w klasie pochodnej – problem jak narazie nie jest rozwiązany.
Warto też wspomnieć o ciekawym mechanizmie aktualizacji schema bazy danych, który porównuje strukturę bazy danych i aktualny stan naszych klas Entity. Dzięki skrypt temu wywołuje tylko te zapytania, które są naprawdę niezbędne.

Twig
Jest to wg mnie jedna najciekawszych i najlepszych zmian w nowej wersji Symfony. Dziedziczenie szablonów, definiowalne makra, szereg rozszerzeń i wbudowanych funkcji to tylko niektóre z funkcjonalności Twiga. Twig jest rewelacyjny, daje ogromne możliwości, a zarazem jest bardzo prosty w użyciu. Początkowo może sprawiać problemy webmasterom przyzwyczajonym do czystego PHP, jednak trud włożony w poznanie w Twig powinien zaprocentować w przyszłości. Odsyłam do dokumentacji projektu, bo dokumentacja na stronie symfony.com pozwala na zapoznanie się tylko z podstawowymie elementami składni.

<h1>Użytkownicy</h1>
<ul>
    {% for user in users if user.active %}
        <li>{{ user.username|e }}</li>
    {% endfor %}
</ul>

Inne problemy
Muszę wspomnieć o bardzo dziwnym (myślę, że to najlepsze określenie) mechanizmie logowania, który sprowadza się do konfiguracji szeregu predefiniowanych opcji. Nie mamy pełnej kontroli nad tym co się dzieje z danymi, które są wysyłane przez formularz logowania, albo przynajmniej mi nie udało się znaleźć sposobu. Możemy ustawić success_handler i failure_handler, ale to nie daje pełnej kontroli nad sesją i uprawnieniami użytkownika. Rozwiązanie na chwilę obecną wydaje mi się być trochę przekombinowane.

Co dalej?
W Symfony2 koduje się szybko i sprawnie, wszelkie błędy okresu dojrzewania nowej wersji frameworka są eliminowane na bieżąco. To czego wg mnie brakuje w tym momencie to duża liczba przykładów wykorzystania nowych mechanizmów frameworka. Dokumentacja jest bardzo dobra ale momentami brakuje w niej podstawowych informacji – m.in. na temat wykorzystania nowego systemu formularzy (jeden rozdział nie wyczerpuje tematu). Warto zapoznać się z kodem niektórych rozszerzeń Symfony2 i standardami kodowania jakie przyjęli programiści. Po cichu liczę na to, że autorzy pokuszą się z końcem roku na wydanie nowej wersji Advent Calendar, która zademonstruje pełnię możliwości Symfony2, a tym samym przekona użytkowników że warto wykorzystać framework w następnym projekcie. Myślę, że to znakomity moment na migrację do PHP 5.3 i Symfony2.

<?php

/**
 * sfImageFileValidator allows you to apply constraints to image file upload, it extend the sfFileValidator functions.
 *
 * @author     Kamil Adryjanek <kamil.adryjanek@gmail.com>
 */
class sfImageFileValidator extends sfValidatorFile
{
    /**
     * Configures the current validator.
     *
     * Available options:
     *
     *  * max_height:             The maximum file height in pixels
     *  * min_height:             The minimum file height in pixels
     *  * max_width:              The maximum file width in pixels
     *  * min_width:              The minimum file width in pixels
     *
     * Available error codes:
     *
     *  * max_height
     *  * min_height
     *  * max_width
     *  * min_width
     *
     * @param array $options   An array of options
     * @param array $messages  An array of error messages
     *
     * @see sfValidatorBase
     */
    public function configure($options = array(), $messages = array())
    {
        parent::configure($options, $messages);

        $this->addOption('max_height');
        $this->addOption('min_height');
        $this->addOption('max_width');
        $this->addOption('min_width');

        $this->addMessage('max_height', 'File is too high (maximum is %max_height% pixels, %height% given).');
        $this->addMessage('min_height', 'File is too short (minimum is %min_height% pixels, %height% given).');
        $this->addMessage('max_width', 'File is too wide (maximum is %max_width% pixels, %width% given).');
        $this->addMessage('min_width', 'File is too thin (minimum is %min_width% pixels, %width% given).');
    }

    /**
     * This validator always returns a sfValidatedFile object.
     *
     * The input value must be an array with the following keys:
     *
     *  * tmp_name: The absolute temporary path to the file
     *  * name:     The original file name (optional)
     *  * type:     The file content type (optional)
     *  * error:    The error code (optional)
     *  * size:     The file size in bytes (optional)
     *
     * @see sfValidatorBase
     */
    protected function doClean($value)
    {
        if (!is_array($value) || !isset($value['tmp_name'])) {
            throw new sfValidatorError($this, 'invalid', array('value' => (string) $value));
        }

        // get image dimensions
        list($width, $height) = getimagesize($value['tmp_name']);

        // check file height
        if ($this->hasOption('max_height') && $this->getOption('max_height') < (int) $height) {
            throw new sfValidatorError($this, 'max_height', array('max_height' => $this->getOption('max_height'), 'height' => (int) $height));
        }

        if ($this->hasOption('min_height') && $this->getOption('min_height') > (int) $height) {
            throw new sfValidatorError($this, 'min_height', array('min_height' => $this->getOption('min_height'), 'height' => (int) $height));
        }

        // check file width
        if ($this->hasOption('max_width') && $this->getOption('max_width') < (int) $width) {
            throw new sfValidatorError($this, 'max_width', array('max_width' => $this->getOption('max_width'), 'width' => (int) $width));
        }

        if ($this->hasOption('min_width') && $this->getOption('min_width') > (int) $width) {
            throw new sfValidatorError($this, 'min_width', array('min_width' => $this->getOption('min_width'), 'width' => (int) $width));
        }

        // check other options
        return parent::doClean($value);
    }
}
?>

How to use this code?

<?php

class PhotoForm extends sfForm
{
    public function configure()
    {

        //...

        $this->widgetSchema['photo'] = new sfWidgetFormInputFileEditable(array(
            'label' => 'User photo',
            'file_src' => '/uploads/photos/'.$this->getObject()->getPhoto(),
            'is_image' => true,
            'edit_mode' => !$this->isNew(),
            'template' => '<div>%file%<br />%input%<br />%delete% %delete_label%</div>',
        ));

        $this->validatorSchema['photo'] = new sfImageFileValidator(array(
                'required'        => true,
                'mime_types'    => array('image/jpeg', 'image/png', 'image/gif', 'image/pjpeg'),
                'max_size'        => '1048576',
                'min_height'    => '640',
                'min_width'        => '480',
                'path'            => sfConfig::get('sf_upload_dir').'/photos',
            ), array(
                'required'        => "Photo is required!",
                'min_height'    => "Custom message for height vaidation.",
                'min_width'        => "File is too thin (minimum is %min_width% pixels, %width% given)."
        ));

        $this->validatorSchema['photo_delete'] = new sfValidatorPass();

        //…

    }
}

?>

Plusy

- jedna z dwóch Polskich książek na temat programowania w Symfony;

- Symfony 1.4 – niektórzy odbiorą to za minus, biorąc pod uwagę premierę Symfony2 zaplanowaną na koniec marca 2011. Jednakże prawda jest taka, że większość nowych projektów oparta jest o sf 1.4 i firmy nie szybko przestawią się na nową wersję frameworka;

- dobre wprowadzenie dla początkujących programistów Symfony – autor niemal za rękę prowadzi poprzez konfigurację środowiska, tworzenie projektu/aplikacji/modułów i implementację poszczególnych funkcjonalności. Ponadto opisuje takie zagadnienia jak: generowanie admina, i18n, pracę z bazą danych, https;

- autor opisuje sposoby publikacji aplikacji na hostingu;

Minusy

- niedopuszczalne jest dla mnie stosowanie Polskich nazw dla zmiennych i metod funkcji – zupełnym nieporozumieniem jest dodawanie „s” dla liczby mnogiej lub też „_id” do Polskich nazw zmiennych:

// polskie nazwy metod
public function executeJaszczurka(sfWebRequest $request)
// liczba monga - piosenkas?
$this->Piosenkas = PiosenkaPeer::doSelect(new Criteria());
// pole w bazie danych - piosenka_id?
$this->Piosenka = PiosenkaPeer::retrieveByPk($request->getParameter('piosenka_id'));
// rezultat polskich nazw kolumn
$this->Zadanie->getOdpowiedz();

Co z konwencjami nazewnictwa i dobrymi praktykami?

- Propel – trudno bezpośrenio przyjąć to za minus, jednakże Symfony oficjalnie wspiera Doctrine, a Propel traktują jedynie jako dodatek. Symfony 2.0 ma w pełni wykorzystywać możliwości Doctrine 2.0 – nie ma jeszcze oficjalnych planów co do Propela; Doctrine

Podsumowanie

Książka jest ciekawa ale można ją polecić co najwyżej początkującym – zdecydowanie odradzam tę pozycję osobom, które miały już wcześniej przyjemność programowania w Symfony. Gdyby nie konwencje nazewnictwa stosowane w „Symfony w przykładach”, możnaby ją smiało rekomendować jako wstęp do sf1.4 – jednakże angielskojęzycznej dokumentacji Symfony napewno nie zastąpi.

Osoby, które chciałby poznać możliwości framework na bardziej zaawansowanych przykładach, odsyłam do lektury Jobeeta.

/**
 * @see Zend_Validate_Db_Abstract
 */
require_once 'Zend/Validate/Db/Abstract.php';

/**
 * Confirms a record is unique in a table.
 *
 * @uses       Zend_Validate_Db_Abstract
 */
class Zend_Validate_Db_Unique extends Zend_Validate_Db_Abstract
{
    /**
     * @var Zend_DB_Table_Row
     */
    protected $_row = null;

	public function __construct($table, $field, Zend_DB_Table_Row $row, Zend_Db_Adapter_Abstract $adapter = null)
    {
        parent::__construct($table, $field, null, $adapter);

        $this->_row   = $row;

        $this->setMessage("A record matching %value% already exists.", self::ERROR_RECORD_FOUND);
    }  

    public function isValid($value)
    {
        $valid = true;
        $this->_setValue($value);

		$result = $this->_query($value);

		if (!$result || $this->isUpdate()) {

			return true;
		}

		$this->_error(self::ERROR_RECORD_FOUND);

        return false;
    }

  protected function isUpdate()
  {
      if (!isset($this->_row[$this->_field]) || $this->_row[$this->_field] != $this->_value)
      {
        return false;
      }

    return true;
  }
}

Is important to note that as a one parameter i’m passing Zend_DB_Table_Row $row – to check if currently we are editing it. This compoment is inspired by sfValidatorDoctrineUnique from Symfony package.

For this implementation we also need something like Zend_Form_Db which will also store current database record. Draft:

class Zend_Form_Db extends Zend_Form
{

	/**
	 * Db row
	 *
	 * @var Zend_DB_Table_Row
	 */
	protected $_row = null;

	/**
     * Constructor
     *
     * @param mixed $options
     * @return void
     */
    public function __construct(Zend_DB_Table_Row $row, $options = null)
    {
        parent::__construct($options);

        $this->_row = $row;
    }
}

This solved my problem.

In my opinion the best way is not to use Zend_Db and replace it with Doctrine ORM. Then we can simply create Zend_Form_Doctrine and Zend_Validate_Doctrine_Unique.

Then in the documentation i found simple ssl filter example:

<?php

class sfSecureFilter extends sfFilter
{
  public function execute($filterChain)
  {
    $context = $this->getContext();
    $request = $context->getRequest();

    if (!$request->isSecure())
    {
      $secure_url = str_replace('http', 'https', $request->getUri());

      return $context->getController()->redirect($secure_url);
      // We don't continue the filter chain
    }
    else
    {
      // The request is already secure, so we can continue
      $filterChain->execute();
    }
  }
}

I really like the idea of describing the authentication and authorization rules in security.yml file (is_secure option) and filters. So i decided to add another option: „is_ssl” for module-action restrictio. It shoud works on the same rules as sfBasicSecurityFilter.

<?php

class MySecureFilter extends sfFilter
{
  public function execute($filterChain) {

    $context = $this->getContext();
    $request = $context->getRequest();

    $moduleName = $request->getParameter('module');
    $actionName = $request->getParameter('action');

    if ($context->getController()->actionExists($moduleName, $actionName)) {

	    $action = $context->getController()->getAction(
	    	$moduleName,
	    	$actionName
	    );

	    if ($action->getSecurityValue('is_ssl', false) && !$request->isSecure()) {

	    	$secure_url = str_replace('http', 'https', $request->getUri());

			return $context->getController()->redirect($secure_url);

	    } else if (!$action->getSecurityValue('is_ssl', false) && $request->isSecure()) {

	    	$not_secure_url = str_replace('https', 'http', $request->getUri());

			return $context->getController()->redirect($not_secure_url);
	    }
    }

    $filterChain->execute();
  }
}

This simple filter redirects all actions that has option ‘is_ssl’ = true to https requests and https requests (with is_ssl = false) to non-https.

To enable this filter for example for our frontend application we need to set this filter in filters.yml – apps/frontend/config/filters.yml:

rendering: ~
security:  ~

secure:
  class: MySecureFilter

cache:     ~
execution: ~

Enable ssl for module/action (default module) – apps/frontend/modules/default/config/security.yml:

# for the whole module
all:
  is_ssl: true

# just one action
login:
  is_ssl: true

My solutions (maybe there is some better way to do this):

all:
  doctrine:
    class: sfDoctrineDatabase   # or sfPropelDatabase
    param:
      dsn:      mysql:host=host_name;dbname=database_name
      username: default_user
      password: pass
      encoding: utf8
      attributes: { default_table_collate: utf8_unicode_ci, default_table_charset: utf8 }

[edit]
If we also want to set prefix for our tables we need to set „tblname_format” attribute. We can set similar option for indexes and sequences name format:

all:
  doctrine:
    class: sfDoctrineDatabase   # or sfPropelDatabase
    param:
      dsn:      mysql:host=host_name;dbname=database_name
      username: default_user
      password: pass
      encoding: utf8
      attributes:
        default_table_collate: utf8_unicode_ci,
        default_table_charset: utf8
        tblname_format: prefix_%s
        idxname_format: %s_idx
        seqname_format: %s_seq

And that’s really all.

Configuration and project setup

Information about how to setup new Symfony project and configure it to work well with ExtJS – you can find in this entry – i’m not gonna repeat all steps again. Notice that you should download latest ExtJS version: 3.2 and set up view.yml file to attach neccessary files. You should also load sample data – we need it for our example.

After setting up the environment we can start coding.

ExtJS components

This time i’m going to put all JavaScript code in separate files – it is really good practice for building bigger ExtJS applications than in this example. First i will create grid.js file and put there grid component class and other configuration – i will create my own custom component class: App.country.Grid which inherits from Ext.grid.GridPanel – it’s not really needed now but it will save us time next time. Commnets should help you understand the concept:

// Typical data Store automatically configured with a Ext.data.JsonReader.
var store = new Ext.data.JsonStore({
	// store configs
	url: 'default/list',  // url for retreiving data
    autoLoad: true,
    // reader configs
    totalProperty: 'total',
    successProperty: 'success',  // response status name
    idProperty: 'id',
    root: 'data',
    fields: ['id', 'name', 'description', 'population', 'created_at']
});

// Columns configuration
var columns =  [
    {header: "ID", width: 50, fixed: true, sortable: true, dataIndex: 'id'},
    {header: "Country", width: 50, sortable: true, dataIndex: 'name' },
    {header: "Description", width: 100, sortable: true, dataIndex: 'description' },
    {header: "Population", width: 50, sortable: true, dataIndex: 'population' },
    {header: "Created at", width: 150, fixed:true, sortable: true, dataIndex: 'created_at' }
];

Ext.ns('App', 'App.country');
// my custom grid component
App.country.Grid = Ext.extend(Ext.grid.GridPanel, {

    initComponent : function() {

        // typical viewConfig
        this.viewConfig = {
            forceFit: true,
            emptyText: 'No data found.'
        };

        App.country.Grid.superclass.initComponent.call(this);
    }
});

I think this code do not need additional explanations.

Next step is to create main app.js file – place where i’m going to put my components logic (components initialization) – nothing special so far – simple retrieving data and displaying it in grid. In this example i will place grid into simple window component – for better usability- it’s another good example of using ExtJS components. Code responsible for that:

// when document is ready
Ext.onReady(function() {

	Ext.QuickTips.init();

	// create my custom grid component
    var grid = new App.country.Grid({

        store: store,  // data store for grid
        columns : columns,  //columns configuration
        plugins: [filters],  // additional plugin - Grid Filter Plugin
        bbar: new Ext.PagingToolbar({  //bottom bar configuration
    		pageSize: 15,   // records per page
    		store: store,
    		displayInfo: true
    	})
    });

    // simple window for grid
    var win = new Ext.Window({
        title: 'Advanced data filtering with Grid Filter Plugin',
        height: 410,
        width: 800,
        layout: 'fit',
        items: grid  // just one item
    });

    win.show();  // display window with grid

});

On the server side

There is one more thing to get it to work – we need PHP code on the server side. We can use code from the latest entry or use the following:

  public function executeList(sfWebRequest $request) {

  	 # data retrieved from the request
	$limit = $request->getParameter('limit', 15);
	$page = ($request->getParameter('start', 0)/$limit)+1;
	$dir = $request->getParameter('dir', 'ASC');
	$column = strtolower($request->getParameter('sort', 'name'));

	 # create query object
	$query = Doctrine_Query::create()
		->from('Country c');

	 # conditions for sorting
	if (Doctrine::getTable('Country')->hasColumn($column)) {

		$query->orderBy(sprintf('c.%s %s', Doctrine::getTable('Country')->getFieldName($column), $dir));
	}

	# object responsible for paging
	$pager = new sfDoctrinePager('Country', $limit);

	$pager->setQuery($query);
	$pager->setPage($page);
	$pager->init();

	$result = array();

	 # format result array
	foreach($pager->getResults() as $country) {

		$result[] = $country->toArray();
	}

	# formatted data are returned to the grid
	return $this->renderText(json_encode(array(
		'success'	=> true,
		'total'		=> $pager->getNbResults(),
		'data'		=> $result
	)));
  }

Calling default action of our application we should achieved the following:

Grid Filter plugin

Next step is to apply Grid Filter plugin to our example.

I just only copied Filter plugin folder from Ext/examples/ux to Ext/ux for better code organisation. To add all neccessary JS and CSS files we need to edit view.yml file – final version should looks similar to this:

  stylesheets:
    - ../js/ext-3.2.0/resources/css/ext-all.css
    - ../js/ext-3.2.0/ux/gridfilters/css/GridFilters.css
    - ../js/ext-3.2.0/ux/gridfilters/css/RangeMenu.css

  javascripts:
    - ext-3.2.0/adapter/ext/ext-base-debug.js
    - ext-3.2.0/ext-all-debug.js
    - ext-3.2.0/ux/gridfilters/menu/RangeMenu.js
    - ext-3.2.0/ux/gridfilters/menu/ListMenu.js
    - ext-3.2.0/ux/gridfilters/GridFilters.js
    - ext-3.2.0/ux/gridfilters/filter/Filter.js
    - ext-3.2.0/ux/gridfilters/filter/StringFilter.js
    - ext-3.2.0/ux/gridfilters/filter/DateFilter.js
    - ext-3.2.0/ux/gridfilters/filter/ListFilter.js
    - ext-3.2.0/ux/gridfilters/filter/NumericFilter.js
    - ext-3.2.0/ux/gridfilters/filter/BooleanFilter.js
    - grid.js
    - app.js

Now we can configure filter component:

var filters = new Ext.ux.grid.GridFilters({
    local: false,   // enable remote filtering
    filters: [{
        type: 'numeric',  // filter type
        dataIndex: 'id'    // column name
    }, {
        type: 'string',
        dataIndex: 'name'
    }, {
        type: 'string',
        dataIndex: 'description'
    }, {
    	type: 'numeric',
        dataIndex: 'population'
    }, {
        type: 'date',
        dataIndex: 'created_at'
    }]
}); 

And enable it in grid:

    var grid = new App.country.Grid({

        store: store,  // data store for grid
        columns : columns,  //columns configuration
        plugins: [filters],  // additional plugin - Grid Filter Plugin
        bbar: new Ext.PagingToolbar({  //bottom bar configuration
    		pageSize: 15,   // records per page
    		store: store,
    		displayInfo: true
    	})
    });

So filter component could work properly we need to write additional PHP code responsible for filtering data. Using symfony and Doctrine Query Language it is really easy. The fallowing code of action.class.php presents complete code:

  public function executeList(sfWebRequest $request) {

  	 # data retrieved from the request
	$limit = $request->getParameter('limit', 15);
	$page = ($request->getParameter('start', 0)/$limit)+1;
	$dir = $request->getParameter('dir', 'ASC');
	$column = strtolower($request->getParameter('sort', 'name'));

	 # create query object
	$query = Doctrine_Query::create()
		->from('Country c');

	 # conditions for sorting
	if (Doctrine::getTable('Country')->hasColumn($column)) {

		$query->orderBy(sprintf('c.%s %s', Doctrine::getTable('Country')->getFieldName($column), $dir));
	}

	 # code resposible for filtering data
	foreach($request->getParameter('filter') as $filter) {

		 # comparison condition
		if (isset($filter['data']['comparison'])) {

			switch($filter['data']['comparison']) {

				case 'eq':

					$comparison = '=';
					break;

				case 'lt':

					$comparison = '<';
					break;

				case 'gt':

					$comparison = '>';
					break;
			}
		}

		 # switch 5 filter types
		switch($filter['data']['type']) {

			case 'boolean':

				$query->addWhere(sprintf('c.%s = ?', $filter['field']), $filter['data']['value']);

				break;

			case 'string':

				$query->addWhere(sprintf('c.%s LIKE ?', $filter['field']), '%'.$filter['data']['value'].'%');

				break;

			case 'numeric':

				$query->addWhere(sprintf('c.%s %s ?', $filter['field'], $comparison), $filter['data']['value']);

				break;

			case 'list':

				$query->whereIn(sprintf('c.%s', $filter['field']), explode(',', $filter['data']['value'])); 

				break;

			case 'date':

				$query->addWhere(sprintf('c.%s %s ?', $filter['field'], $comparison), date('Y-m-d', strtotime($filter['data']['value'])));

				break;

			default:

				break;
		}
	}

	# object responsible for paging
	$pager = new sfDoctrinePager('Country', $limit);

	$pager->setQuery($query);
	$pager->setPage($page);
	$pager->init();

	$result = array();

	 # format result array
	foreach($pager->getResults() as $country) {

		$result[] = $country->toArray();
	}

	# formatted data are returned to the grid
	return $this->renderText(json_encode(array(
		'success'	=> true,
		'total'		=> $pager->getNbResults(),
		'data'		=> $result
	)));
  }

}

Thats all. As a result we should get:

Enyoj!

As a result, i received sfWidgetFormJQueryMultiSelect.

<?php

/**
* sfWidgetFormJQueryMultiSelect represents a multi choice select widget.
*
* @package    symfony
* @subpackage widget
* @author     Kamil Adryjanek <kamil.adryjanek@gmail.com>

*/
class sfWidgetFormJQueryMultiSelect extends sfWidgetFormChoice
  {
    /**
    * Constructor.
    *
    * Available options:
    *
    *  * choices:          An array of possible choices (required)
    *  * renderer_class:   The class to use instead of the default ones
    *  * renderer_options: The options to pass to the renderer constructor
    *  * renderer:         A renderer widget (overrides the expanded and renderer_options options)
    *                      The choices option must be: new sfCallable($thisWidgetInstance, 'getChoices')
    * @param array $options     An array of options
    * @param array $attributes  An array of default HTML attributes
    *
    * @see sfWidgetFormChoiceBase
    */

    protected function configure($options = array(), $attributes = array())
    {
        $this->addOption('config', '{}');

        parent::configure($options, $attributes);

        $this->setOption('multiple', true);
        $this->setOption('expanded', true);
    }

    /**
    * @param  string $name        The element name
    * @param  string $value       The value selected in this widget
    * @param  array  $attributes  An array of HTML attributes to be merged with the default HTML attributes
    * @param  array  $errors      An array of errors for the field
    *
    * @return string An HTML tag string
    *
    * @see sfWidgetForm
    */
    public function render($name, $value = null, $attributes = array(), $errors = array())
    {
        return parent::render($name, $value, $attributes, $errors).
        sprintf(<<<EOF
            <script type="text/javascript">
                jQuery(document).ready(function() {
                    jQuery("#%s").multiselect(
                        %s
                    );
                });

            </script>
        EOF,
        $this->generateId($name),
        $this->getOption('config')
    );
  }
}

How to use it
Include into your application neccessary JavaScripts (jQuery 1.4+ and jQuery UI required) and stylesheets: (for example view.yml):

stylesheets:    [main.css, ui-lightness/jquery-ui-1.7.2.custom.css, jquery.multiselect.css]

javascripts:    [jquery.js, jquery-ui.js, jquery.multiselect.js]

Then we need to create simple form and set our widgets:

<?php

class SimpleForm extends sfForm {

    public function configure() {

        $userChoices = array('John', 'Michael', 'Tom', 'Peter');

        $this->setWidgets(array(
            'users'	=> new sfWidgetFormJQueryMultiSelect(array(
                'choices'	=> $userChoices
            ));
        ));

        $this->setValidators(array(
            'users'	=> new sfValidatorChoice(array(
                'choices'	=> array_keys($userChoices)
            ))
    ));
  }
}

How does it work (look)
Form should now look similar to that:

Widget should work with Symfony 1.2.X – 1.4.X.

More information about jquery.multiselect plugin can be found on this page.

In the near future I would like to create Symfony widget and put there some of my custom widgets (for example sfWidgetFormJQueryDateTime).

Enjoy

function __(string) {

	 if (typeof(i18n)!='undefined' && i18n[string]) {

		return i18n[string];
	}

	return string;
}

Then i attached another JavaScript file with translations object (before including __() function), for example we can call this file „pl_PL.js” and put there code:

var i18n = {
	'Country.'							: 'Kraj',
	'Description'						: 'Opis',
	'Population'						: 'Populacja',
	'Created at'						: 'Data utworzenia',
	'Symfony 1.2 and Ext.js example'	: 'Przykład wykorzystania Symfony 1.2 i Ext.js '
}

In our ExtJS components (or any other JavaScript code) we just simple call (example code from latest entry):

	//columns structure
	var columns = [
		{id:'name',header: __('Country'), width: 160, sortable: true, dataIndex: 'name'},
		{header: __('Description'), width: 160, sortable: false, dataIndex: 'description'},
		{header: __('Population'), width: 160, sortable: true, dataIndex: 'population'},
		{header: __('Created at'), width: 100, sortable: true, dataIndex: 'created_at'}
	];

	// gridPanel object
	var grid = new Ext.grid.GridPanel({
		title: __('Symfony 1.2 and Ext.js example'),
		loadMask: true,   // mask panel when data is loading
		store: store,
		columns: columns,
		autoExpandColumn: 'name',
		height: 400,
		width: 600,
		renderTo: 'grid-example'  // DOM element
	});

});

For me it’s simple, powerfull and really usefull.