$resultSet = $this->getDbTable()->fetchAll(
$this->getDbTable()
->select()
->where("category_id = ?", intval($cat))
);


Fügt man jetzt einfach einen ->join() ein bringt er einen Fehler. Einen Blick auf die Zend-Library (select.php) zeigt uns hierbei mehr. Standardgemäß ruft er eine Funktion “setIntegrityCheck()” auf, welche eine Flag auf true gesetzt hat und das Joinen von 2 oder n Tabellen verhindert. Dieses müssen wir beim Query als false-Flag mit übergeben. Zudem ist es jetzt notwendig die “from”-Zuweisung zu deklarieren.

Nachher:

$query = $this->getDbTable()
->select()
->from('premium')
->setIntegrityCheck(false)
->join('premium_translation', 'premium_translation.id = premium.id')
->where("premium.category_id = ?", intval($cat))
$resultSet = $this->getDbTable()->fetchAll($query);

• letzte Version des APC runterladen
• In den entpackten Ordnerpfad gehen (Users/USERNAME/Downloads/APC-xx
• /usr/local/zend/bin/phpize im Terminal ausführen
• ACOSX_DEPLOYMENT_TARGET=10.6 CFLAGS=”-arch i386 -g -Os -pipe -no-cpp-precomp” CCFLAGS=”-arch i386 -g -Os -pipe” CXXFLAGS=”-arch i386 -g -Os -pipe” LDFLAGS=”-arch i386 -bind_at_load” ./configure –with-php-config=/usr/local/zend/bin/php-config
• make
• sudo make install
• Mit dem VI-Editor in die PHP.INI folgendes erzänzen:
  $ sudo vi /usr/local/zend/etc/php.ini

  [APC]
  extension=apc.so
  apc.enabled = 1
  apc.optimization = 0
  apc.shm_segments = 1
  apc.shm_size = 128M
  apc.ttl = 7200
  apc.user_ttl = 7200
  apc.num_files_hint = 1024
  apc.mmap_file_mask = /tmp/apc.XXXXXX
  apc.enable_cli = 1
  apc.cache_by_default = 1
  apc.max_file_size = 10M
  apc.stat = 1
  apc.include_once_override = 1

• Apache Neustarten
  $ sudo /usr/local/zend/bin/zendctl.sh restart-apache

Cannot rename file myproject/.svn/tmp/entries’ to myproject/.svn/entries’

Mein erster Schritt war natürlich nach den Schreibrechten im Pfad zu schauen. Beim genaueren betrachten hat der SVN-Projectpfad “entries” nur Leserechte. SUDO chmod 777 Aufruf brachte hierbei auch keinen Erfolg, sondern brachte einen Fehler “permission denied”.

Lösung: OSX nutzt eine spezielle UCHG-Flag als READ-ONLY-FLAG, die FLAG muss mit “chflags -R nouchg *” zurückggestellt werden.

Entsprechend gibt es leider sogut wie garkeine oder viele veraltete Dokumentationen in Deutsch über das Entwickeln mit einer IDE + Liferay, was mich dazu gewogen hat dieses Tutorial zu schreiben.

In den Kapiteln des Tutorials werdet Ihr von der Installation, über das Templating bis hin zur Weiterentwicklung von Portlets begleitet.

Kapitel 1 – Installation

In diesem ersten Kapitel des Tutorials werde ich euch erklären, wie man sich die passende IDE mit dem Portalpack (build JSR168) für das JAVA-CMS “Liferay” einrichtet. Alternativ sollte das Portlet in der Lage sein auf einer anderen JSR168 konformen Portlet-Container zu laufen. Für die Einrichtung werden folgende “Tools” benötigt, um diesem Tutorial zu folgen:

• aktuellste JAVA SDK
• Netbeans 6.3 Beta
• Netbeans Plugin Portalpack 3.0.2
• Liferay-Tomcat bundle

Schritt 1
Installtion des aktuellen JAVA SDK, welches ihr auf SUN.COM findet.

Schritt 2
Nun folgt die IDE (Netbeans), welche Ihr runterladen und installieren müsst

Schritt 3
Für die Entwicklung von Portlets und das Templating vom Liferay wird noch das Plugin “PortalPack 3.0.2″ benötigt, dieses ladet Ihr entweder auf portalpack.netbeans.org/ (falls es mal nicht OFF sein sollte) oder contrib.netbeans.org runter und entpackt dies. Im Anschluss startet Ihr Netbeans und fügt das Plugin hinzu. Dies geschieht unter: TOOLS -> PLUGIN -> DOWNLOAD -> ADD PLUGIN und fügt alle in der ZIP enthaltenen Plugins ein und installiert es.

Schritt 4
Unter Liferay.com ladet Ihr die aktuelle Version des CMS mit dem Tomcat bundle runter. Dieses entpackt Ihr in ein von euch gewähltes Verzeichnis. Alternativ könnt Ihr zum Beispiel auch Glassfish als Application Server verwenden, hierbei dann das Glassfish bundle runterladen.

Im nächsten Kapitel wollen wir uns dem hinzufügen eines “Liferay Portal Servers” im Netbeans widmen.

Kapitel 2 – Implementierung eines Liferay-Portal-Server

Im ersten Kapitel haben wir uns der Installation der IDE mit Liferay gewidmet, nun wollen wir uns um die Einrichtung des Portal Servers richten.

Unter Services im Netbeans findet Ihr eine Auflistung von Web-Services, Trackers und auch den Servern. Mit einem rechtsklick auf “Server” fügt Ihr einen neuen Server hinzu.

Als Serverart wählen wir uns durch das Plugin integrierte “Liferay Portal Server 5.x” aus und klicken zum nächsten Schritt.

Da ich in diesem Tutorial auf einen Tomcat setze, wählen wir diesen als Servertyp und geben den Catalina-Pfad des Tomcats ein, der rest wird automatisch ergänzt.

Im dritten Schritt kann alles standardgemäß belassen werden und klicken auf “finish”.

Wenn alles geklappt hat können wir beim Aufklappen der Server nun unseren Liferay Portal Server finden und diesen starten. Im nächsten Kapitel werden wir unser erstes kleines Portlet erstellen.

Kapitel 3 – “Hello World” Portlet

Kommen wir nun zum 3. Kapitel, wo wir uns mit dem Portlet von Liferay beschäftigen werden. Ein Portlet ist eine Web-Application welche authentifizierten und personalisierten Zugriff auf integrierte Inhalte von unterschiedlichen Quellen (Aggregation) bietet. Erstellte und bereits vorhandene Portlets geben also den Inhalt für das Portal ansich wieder.

Damit wir unser erstes “Hello World” Portlet erstellen können, müssen wir zunächst ein neues “Projekt” anlegen. Dies geschieht in der Menüleiste unter “File -> New Project”

Als erstes werden wir von einer Auswahl von “Arten” von Projekten begrüßt. Da es sich bei uns um ein Web-Projekt handelt, wählen wir diese auch aus

Im nächsten Schritt müssen wir den Projektnamen definieren und wählen einen Speicherort.

Jetzt wählen wir einfach den “Liveray Portal Server 5.x” aus und gehen zum 4. und letzten Schritt. Die wahl des Frameworks läuft hierbei recht bescheiden aus. “Portlet Service” sollte hierbei fürs erste reichen. Dies angeklickt bietet dieses Framework für uns die notwendige konfiguration. Mit Klick auf “Create Portlet” erstellen wir ein neues Portlet und definieren dieses wie im unteren Screenshot-Beispiel.

Jetzt können wir unser erstes Portlet erstellen und schauen uns links im Projects-Menüfeld unser Portlet an. Die Struktur ist folgendermaßen Aufgebaut:

In der WEB-INF findet ihr nun die nötigen JSP`s um dem Portlet Inhalt zu verschaffen, sowie die XML´s welche unter anderem für die Registrierung einer neuen Application in Liferay dient. Die “xxx.view.jsp” könnt Ihr nun bearbeiten und euer “Hello world” ausgeben lassen. Zum Abschluss muss dieses Projekt nun mit “Run” oder alternativ “Build” und “Deploy” der neue Zustand erstellt werden. Um diese Application nun unserem Portal hinzuzufügen, loggen wir uns im Frontend ein und gehen in den Docks (User-Menüauswahl) auf “Add Application”. Jetzt finden wir eine große Auswahl bereits vorhandener Portlets und auch unserers ist unter “User-Portlets” zu finden.

Dies schieben wir nun per Drag&Drop in unser Layout, fertig.

Folgendes Szenario: Wir haben eine tabellarische Listenansicht, welche uns die Werte aus der Datenbank wiedergibt. Wenn dies z.B. eine Sortierungsspalte beinhaltet, macht es sich ganz gut diesen direkt per klick in der Zelle zu ändern statt erst über das Editiermenü zum Formular zu gelangen. Ziel ist es also, in eine Zelle via Mausklick zu klicken wo sich ein Inputfeld öffnet, wir den Wert manipulieren können und dieser gespeichert wird.

Wir erstellen uns also ein neues AJAX Modul, welche normal mit einem Action-Controller und einem Indextemplate aufgespalten ist.
Hintergrund ist das hierbei die Werte übergeben und gespeichert werden.

actions/actions.class.php

class ajaxActions extends sfActions
{
 /**
  * Executes index action
  *
  * @param sfRequest $request A request object
  */
  public function executeIndex(sfWebRequest $request)
  {
    $object = Doctrine::getTable($request->getParameter('type'))->findOneById($request->getParameter('id'));
    $object->setSort($request->getParameter('value'));
    $object->save();
    return $this->renderText('');
  }
}

templates/indexSuccess.php

Wir haben ein 2. Modul, in diesem Fall eine Artikelansicht, welche eine Sortierungsspalte für die korrekte Reinfolge in der Darstellung beinhaltet. Wir verbergen hierbei das Input-Feld und zeigen mittels SPAN-TAG nur den Wert an. Mit Javascript soll hierbei bei klick der SPAN-TAG versteckt und das Inputfeld sichtbar werden.

article/indexSuccess.php

<input type="hidden" value="<?php echo $cont['id'] ?>" />
                  <input type="hidden" value="<?php echo $cont['type'] ?>" />
                  <span><?php echo $cont['sort'];?></span>

jQuery Script
Das ist sozusagen der Übermittler, der den Hintergrundprozess steuert und die PHP-Funktionen zum speichern aufruft. Wie im Code gut zu lesen ist werden die manipulierten Werte an das AJAX-Modul übergeben und gespeichert.

.siblings() erlauben das suchen von Elementen in der DOM-Struktur des jQuery-Objektes und konstruiert ggf. ein neues Objekt.
Mit $.post(‘‘, data, function() übergeben wir die manipulierten Daten an das AJAX-Modul, wo diese dann PHP-seitig verarbeitet werden.

function doUpdate (myThis) {

    myThis.siblings('span').html(myThis.val()).show();

    var data      = {};
    data['id']    = myThis.siblings('input').val();
    data['type']  = myThis.siblings('input').next().val();
    data['value'] = myThis.val();

    $.post('<?php echo url_for('ajax/index'); ?>', data, function(){

    });

    $('table td.contentSort span').each(function(){
      if($(this).siblings('input').val() == myThis.siblings('input').val() && $(this).siblings('input').next().val() == myThis.siblings('input').next().val() )
      {
        var value = myThis.val();
        $(this).text(value);
      }
    });

    myThis.remove();

  };

$('table td.contentSort span').click(function () {
  $(document.createElement('input'))
              .attr('value', $(this).text())
              .attr('type', 'text')
              .prependTo($(this).parent())
              .keydown(function(e){
                if(e.keyCode == 13){
                  doUpdate($(this));
                }
              })
              .blur(function(){
                doUpdate($(this));
              })
              .focus();

  $(this).hide();

});

</script>

Symfony beinhaltet eine nette Funktion (sfForm::embedForm) , welche Unterformulare in ein anderes Formular einbindet. So können z.B. in der Menüform -> Submenüforms eingebettet werden, wenn sie in Relation zueinander steht.

Die Datenbank sieht in diesem Beispiel vor, das ein Submenü eine Menu_id mit Relation zur Tabelle Menu besitzt. Der erste Schritt ist hierbei in der Library die MenuForm aufzurufen, um dem Menü mitzuteilen das hierbei noch eine weitere Form eingebunden wird:

Pfad: lib/doctrine/forms/Menu.class.php

class MenuForm extends BaseMenuForm
{
  public function configure(){
    unset(
       $this['created_at'],
       $this['updated_at]
    );
  parent::configure();

  $submenu_form = new SubmenuForm();
  $this->embedForm('submenu', $submenu_form);
  $this->WidgetSchema['submenu]->setLabel('New Submenu');

  }
}

In der Methode configure() instanziieren wir uns ein neues Objekt SubmenuForm(). Mit embedForm weisen wir diesem Objekt zu, das es in die Menuform mit eingebettet werden soll. Wer noch ein Label beifügen will, kann dies mit setLabel(‘New Submenu’) setzen.
Nun rufen wir die SubmenuForm.class im selben Ordner auf und unsetten die Menu_Id, damit wir keine Dropdownauswahl haben, sondern die generierte Menu-id automatisch hinzufügt.

Pfad: lib/doctrine/forms/Submenu.class.php

unset($this['menu_id']);

Nun haben wir ein neues Unterformatular im Formular erzeugt. Für den Bearbeitungsprozess muss noch eine Abfrage des Objektes erfolgen:

Pfad: lib/doctrine/forms/Submenu.class.php

 if (!$this->isNew()){
      foreach ($this->getObject()->getSubmenu() as $submenu){
        $submenu_form = new SubmenuForm($submenu);
        $this->embedForm('seo'.$submenu->getId(),$submenu_form);
        $this->widgetSchema['submenu'.$submenu->getId()]
                ->setLabel('Submenu:'.$submenu->getId());
      }
    }

Der letzte Punkt prüft ob es sich um ein neues Objekt handelt oder eines, was bearbeitet werden soll. Im letzteren Fall wird dem Objekt die ID übergeben und die Felder mit den zu bearbeitenden Daten vorausgefüllt.

PHP gehört mit zu den beliebtesten Websprachen und bietet für jegliche Art von Projekten einen professionellen Standard. Die wichtigsten Grundelemente für eine optimale Voraussetzung ein PHP-Projekt umzusetzen, habe ich hierbei einmal aufgelistet:

Datenbankverwaltung

• PHPMyAdmin
  PHPmyadmin bietet gutes Handling in der Verwaltung und Erweiterung der Datenbanken mit MySQL.Nachteil: Da es bei Imports/Exports meist ausschließlich zu Fehlern kommt (sei es das einspielen eines großen SQL-Dumps oder ausgelöst durch Kommentare in den SQL-Anweisungen), empfehle ich dafür weiterhin die altbewährte Shell-Konsole aufzurufen!

  Dump erstellen:

  mysqldump --host=127.0.0.1 --u user -p --port=3306 --database mydb  > mydump.sql

  Dump einspielen:

  mysql --host=127.0.0.1 -u user -p --port=3306 mydb mydump< .sql

• HeidiSQL for Win
  Ein vernünftiger MySQL-Client, welches ebenfalls frei zur Verfügung steht. Hierbei ist ähnlich wie bei PHPmyadmin das Problem mit den Imports / Exports.
  
• Sequel Pro for Mac OS X
  Schönes Tool mit nützlichen Funktionen wie das Suchen von bestimmten Tags in einzelnen Feldern.

Debugging

• PHP-Debug
  Prüft die Performance von bestimmten Code-Blöcken und bietet im Gegenteil zu print_r(); oder var_dump(); eine optisch gute und übersichtliche Ausgabe
• PHP Dyn
  Bietet ebenfalls eine schöne Ausgabe von Code-Blöcken mit Rückgabewerten deiner Funktionen

Web-Server

• XAMPP
  Ein Bundle von allen notwendigen Programmen, welche für die Einrichtung und Wartung eines Webservers notwendig sind. Es erfreut sich an einer großen Community und hat sich als festen Anker etabliert. Enthalten sind neben den vielen PHP-Modulen u.a. auch Apache2, PHP, PHPmyAdmin und OpenSSL.
  
• Zend Community Server
  Neben dem bekannten XAMPP gibt es noch den Zend Community Server, welche viele nützliche Dinge mitliefert. So kann z.B. in der integrierten, webbasierten Administrationsverwaltung Module und Extensions leicht angepasst werden und liefert eigene Komponenten wie Optimizer, Debugger, DataCache mit.

IDE´s und Editoren

• Netbeans
  Die IDE Netbeans gehört mitlerweile zu den besten Entwicklungsumgebungen, die u.a. auch Programmiersprachen wie C, C++ und vorallem Java abdeckt. Das gute Handling mit Erweiterungen (Bibliotheken, Module, Plugins etc.), Debugging Prozesse, GUI-Builder, UML-Modelling etc. lässt diese IDE zu einem unverzichtbaren Tool werden. Zudem ist in der PHP-Version bereits das Framework Symfony inbegriffen, was nochmal einiges an Arbeit abnehmen dürfte. Zudem ist ein Subversion bereits inbegriffen womit keine größere Konfiguration hierbei nötig wären.
• Eclipse
  Ebenfalls ein sehr bekanntes und weit verbreitete IDE zum Entwickeln mit Support verschiedenster Programmoersprachen. Subversion muss allerdings als Extension wie z.B. Subclips eingebunden werden.
  
• Notepad++
  Ein normaler, windowsbasierter “Texteditor” welche Syntax hervorhebt, Multi-Ansicht & Autovervollständigung gibt und sehr Ressourcensparsam ist. Unterstützt wichtige Programmiersprachen wie Java, C++, XML, HTML, SQL und natürlich auch PHP.

Qualitätssicherung

• Unit Tests
  Für eine gute Skalierbarkeit und Stabilität bietet PHP Unit Tests das optimale Werkzeug. Hier lassen sich Testszenarien simmulieren und durchspielen, um schneller Fehler entdecken und beheben zu können.
• SimpleTest
  Ebenfalls ein gutes Tool um Testfälle nachzuspielen. Dieses “Webtest-Framework” supportet u.a. SSL, Frames, Proxys und Basis-Authentifikationen. Ein Tutorial dazu findet Ihr hier

Versionskontrollen

• Phing
  Ist ein beliebtes Tool, welche für eine bessere Organisation und Pflege Ihrer Version des PHP-Projektes bietet.
  
• xinc
  xinc ist eine kontinuierliche Integration Server-Version-Control-System in PHP 5 geschrieben. Es arbeitet gut mit anderen Systemen wie Subversion und Phing zusammen.

In-Browser Tools

• PHPLang Editor
  Übersetzt Sprachdateien und Variablen in Deinem PHP-Code.
  Ein Flash-Tutorial dafür findet Ihr hier
• FireBug
  Diese Mozilla Firefox Extension ermöglicht LIVE-Monitoring und Fehlersuche von Webseiten. Ausgelegt wurde diese speziell für HTML, CSS und JavaScript DOM-Struktur, womit auch u.a. Anfragen und Serverantworten mit genauem Zeitpunkt dokumentiert werden. Ein Muss für jeden Entwickler um die Qualität und die Performance zu sichern.

• Web-Developer
  Ebenfalls eine Mozilla Firefox Extension stellt diese eine Symbolleiste und ein Menü mit zahlreichen nützlichen Werkzeugen für Web-Entwickler bereit.

Sources and Ressources

• PHP-Toolbox
  Eine gute Sammlung von englischsprachigen Tutorials, Info, Tipps etc.

• In-Browser Toolsammlung
  Nützliche In-Browser Tools für PHP

Doctrine ist ein Framework zur objektrelationalen Abbildung (ORM), welches eine Schnittstelle zwischen der relationalen Datenbank und der objektorientierten Programmierung darstellt. Mit nur wenigen Anweisungen in einer Konfigurationsdatei und dem Aufruf via Shell lassen sich Models und Datenbankstrukturen automatisch erzeugen. In Symfony ist Doctrine bereits nativ inbegriffen, bei Zend (erst ab Vers. 2.0) oder CakePHP muss dies erst implementiert und konfiguriert werden.

Doctrine nutzt YAML-Files für die Modelierung des Datenbankschemas und der Models. Entwickler werden schnell Spaß daran finden YAML-Files zu erstellen, da es eine enorme Arbeit abnimmt und recht einfach und übersichtlich neue Anweisungen hinzugefügt werden können.

Ein Beispiel für den Aufbau einer YAML-File

Erklärung:
YAML ermittelt anhand der Spaces zu welcher Verschachtelung ein Eintrag gehört. Dabei wird je Level immer um 2 Spaces eingerückt.
An diesem Beispiel will ich ein neues Menü-Model generiert haben, welches aus den Feldern “id, name, link, position und sort” besteht.

“Menu” ist der erste Punkt, quasi der Tabellenname bzw. das Model, was generiert werden soll. Mit der Anweisung “Timestamable” setze ich automatisch je 2 Datumsfelder in jede Tabelle, die für neue Einträge (CREATE) und Updates von bestehenden Daten (UPDATE) einen Timestamp setzen. I18n ist ein von Doctrine unterstützter Translater, welcher automatisch eine Kopie der Tabelle erstellt und mit der Zuweisung von allen oder bestimmten Feldern arbeitet und übersetzt. In diesem Fall wollen wir den Namen mit der Zuordnung eines language_codes übersetzt haben.
Anschließend verweisen wir die Felder mit dem Befehl “columns”, welche angelegt werden sollen. Nun werden nach und nach alle Felder angelegt mit den entsprechenden individuellen Attributen.

Der nächste Schritt ist unsere Shell-Konsole, hierbei generieren wir unser Datenbankschema und Model aus der YAML-Datei. Die Shell-Konsole aufgerufen und im Hauptverzeichnis gelandet, wird folgender Befehl ausgeführt:
php symfony doctrine:build –all –and-load

Jetzt wird zuerst die Datenbank mit den entsprechenden Fixtures (Default-Daten) erstellt, sowie die Modelklassen und Forms generiert. Fazit: Doctrine nimmt hierbei viel Arbeit ab und generiert anhand der konfigurierten YAML-Datei die Model´s und Tabellen automatisch. Falsche Einrückungen und Relationen bei der Generierung werden sofort angezeigt und können rudimentär anhand der Fehlerausgabe behoben werden.

Zu den komplexesten Aufgaben eines Entwicklers gehört die Erstellung eines Formulares, welche neue Daten erstellen, bearbeiten, löschen, auflisten und validieren soll.
Symfony bietet hierbei eine Schnittstelle, womit die Formulare mittels Doctrine automatisch generiert werden können.
Vereinzelte konfigurationen wie Klassenzuweisung, neue Labelsetzung können dann einfach im nachhinein zugewiesen werden.

An diesem Beispiel erstelle ich ein neues Modul in der Admin-App und lasse dann mittels Doctrine die Formulare erstellen.
Wichtig ist das schon ein Model existieren muss, ich nutze hierbei das schon von mir generierte Menü-Model.

Die Shell-Konsole geöffnet und im Hauptverzeichnis gelandet, können wir uns die Symfony-Befehle mit “php symfony” anzeigen lassen.
Für unser neues Modul “donlarson” geben wir also folgenden Befehl ein:

php symfony generate:module admin donlarson

Erklärung: generate:modul generiert das Grundmuster eines Moduls mit seinem Controller und View. Im Anschluss erfolgt die Zuweisung der App (admin) und des Modules (donlarson).

Jetzt lassen wir uns gleich die Formulare generieren, dies geht mit folgendem Befehl:

php symfony doctrine:generate-modul –with-show –non-verbose-templates admin donlarson Menu

Erklärung:
Wir sagen mit generate-modul das er die Modelklassen darauf ausrichten soll, whit-show für die Einzelansicht.
Zum Schluss wird wieder angegeben in welcher App (admin) , Modul (donlarson) und welche Modelstruktur (Menu) dies ausgerichtet werden soll.

Wenn wir uns jetzt die Modulstruktur genauer anschauen, stellen wir fest das wir ein neues Modul in der Admin-App erstellt bekommen haben. Dies aufgeklappt sehen wir unser View- und Controllermuster.

Was wurde im Modul generiert?:

action.class.php (Verarbeitungsprozess)

• Action-Zuweisungen für die Formularbearbeitung
• Action-Zuweisung für die Auflistung und Detailansicht der Daten

templates/***Success.php (Output vom Verarbeitungsprozess)

• automatische Auflistung mittels Tabellen der Daten
• Referenzierungen auf Detailansicht
• Referenzierungen auf Neue Daten erstellen, bearbeiten, löschen

Damit wir die Spezifikationen im Detail bearbeiten können, rufen wir in unserer Baumstruktur die LIB->form->doctrine->Menu.class.php auf.
Nun können beliebige Parameter / Ansichten abgeändert werden, anbei ein paar Beispiele:

class MenuForm extends BaseMenuForm
{
  public function configure()
  {
    parent::configure();

    #Radiobuttons statt Dropdownlist anzeigen lassen

    $this->widgetSchema['position'] = new sfWidgetFormChoice(array(
      'choices' => array('top' => 'top', 'bottom' => 'bottom'),
      'multiple' => true,
      'expanded' => false
     ));

    # Andere Schreibweise
    $this->widgetSchema['position']->setOption('multiple', true);

    #Neue Labelzuweisung für LINK
    $this->widgetSchema['link']->setLabel('neuer Labelname');

    # Fügt ein neues Feld hinzu
    $this->widgetSchema['donlarson'] = new sfWidgetFormI18nDateTime(array('culture' => 'fr_CH'));

  }
}