Als erstes muss man die Filter für das View aktivieren. Dies kann man zum Beispiel über die Bootstrap.php tun.

protected function _initViewFilter()
{
	$view = $this->getResource('view');
	$view->addFilterPath('Suka/View/Filter', 'Suka_View_Filter_')
	$view->addFilter('Translate');
}

Entsprechend habe ich in meiner Library den Pfad hinzugefügt und eine Datei Translate.php dort deponiert. Und das war es auch schon. Der Rest funktioniert ganz automatisch. Im View muss nun der String, der übersetzt werden soll etwas verpackt werden und schon passiert das gleiche wie es beim normalen Translate ViewHelper passiert.

// Mit Parameter
{{Foo|Bar,FooBar,BarFoo}}

// Ohne Parameter
{{FooBar}}

Natürlich will ich den Filter noch zur Verfügung stellen:

<?php

/**
 * Übersetzer
 *
 * Der Übersetzer sucht aus dem View alle kurzgefassten Übersetzungsstring
 * und führt die Übersetzung durch. Nach dem Schema {{STRING}} wird die
 * Übersetzung gefunden und durchgeführt.
 *
 * @see			Zend_Filter_Interface
 * @uses		Zend_Filter_Interface
 * @category    Suka
 * @package     Suka_View
 * @subpackage	Filter
 * @author      Denis Zunke <denis.zunke@zorta.de>
 * @version     0.1
 * @copyright   2010 zorta.de
 * @link        http://www.zorta.de/SukaSys
 * @license 	http://opensource.org/licenses/gpl-license.php GNU Public License v3
 */

class Suka_View_Filter_Translate implements Zend_Filter_Interface
{

	/**
	 * @see Zend_Filter_Interface::filter()
	 */
	public function filter($string)
	{
		if (Zend_Registry::isRegistered('Zend_Translate')) {
			$translate 	= array();
			$translateObj	= Zend_Registry::get('Zend_Translate')->getAdapter();
			preg_match_all('|{{(.*)(\|.*)?}}|U', $string, $translate, PREG_SET_ORDER);
			foreach ($translate as $transArr) {
				$finalString = '';

				if (!empty($transArr[2])) {
					// Übersetzung mit Parametern
					$paramsString = str_replace('|','',$transArr[2]);
            	   	$params = explode(',',$paramsString);
            	   	$finalString = vsprintf($translateObj->translate($transArr[1]),$params);
				} else {
					// Übersetzung ohne Parameter
					$finalString = $translateObj->translate($transArr[1]);
				}
				$string = str_replace($transArr[0], $finalString, $string);
			}
		}
		return $string;
	}
}

Nun beginnen wir.

Ich will im View einen String ausgeben. Natürlich verwende ich dafür den entsprechenden ViewHelper. Wenn man dies jedoch einbaut, dann wird man feststellen, dass es keine Übersetzung gibt, sondern der String an sich ausgegeben wird.

<?php echo $this->translate('testMessage'); ?>

Um nun der Applikation die Mehrsprachigkeit hinzuzufügen braucht es einige erst einmal der Resource, die sich am Ende dieses Artikels findet. Ich gehe davon aus, dass hier ein Basiswissen Resourcen besteht und man weiß, wie man sie einbindet. Um die Resource zu aktivieren und zu konfigurieren braucht es in der Konfigurationsdatei der Applikation, bei mir die application.php, einiger Variablen.

       'locale' => array(
            'default' => 'en_US',
        	'fore'	  => false
        ),
       'translate' => array (
        	'file'		=> 'translation.xml',
        	'adapter'	=> 'tmx',
        	'moduldir'	=> 'modules',
        	'configdir'	=> 'configs',
        	'scan'		=> true,
        	'files'		=> array (
        		APPLICATION_PATH . '/configs/Validate.tmx'
        	)
        )

Eine kurze Erläuterung zur Konfiguration.

file
Der Standardname für Übersetzungsdateien. Diese muss auch existieren, da sie die Basis für die weitere Arbeit bildet.

adapter
Der eingesetzte Adapter für Translations

moduldir
Sollte man die ‘scan’-Option aktivieren wird in diesem Verzeichnis nach Modulen gesucht, die ebenso Sprachdateien bieten

configdir
Das Standardverzeichnis für Konfigurationsdateien, hierin werden die Sprachdateien gesucht. Sowohl in der Applikation als auch in den Modulen

scan
Aktiviert durchsucht es das Modulverzeichnis nach weiteren Übersetzungen

files
Wenn man Dateien einbringen möchte, die nicht dem Standard entsprechen kann man hier eine beliebige Anzahl definieren

Die Konfigurationsmöglichkeiten reichen für die Basis der Translation auf jedenfall aus, werden im Laufe der Zeit aber sicher mehr werden, wie am Anfang genannt.

Nun muss man natürlich die Übersetzungsdateien selber noch definieren. Die beiden im Beispiel genannten will ich stark gekürzt zeigen, damit man weiß wie eine TMX Datei aufgebaut ist. Zuerst die translations.xml.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE tmx SYSTEM "tmx14.dtd">
<tmx version="1.4">
   <header creationtoolversion="0.1" datatype="winres" segtype="sentence"
           adminlang="en-us" srclang="de" o-tmf="abc"
           creationtool="SukaSys" >
   </header>
   <body>
       <tu tuid='testMessage'>
           <tuv xml:lang="de"><seg>Testnachricht</seg></tuv>
           <tuv xml:lang="en"><seg>testMessageTrans</seg></tuv>
       </tu>
   </body>
</tmx>

Und die validate.xml.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE tmx SYSTEM "tmx14.dtd">
<tmx version="1.4">
   <header creationtoolversion="0.1" datatype="winres" segtype="sentence"
           adminlang="en-us" srclang="de" o-tmf="abc"
           creationtool="SukaSys" >
   </header>
   <body>
       <tu tuid='isEmpty'>
           <tuv xml:lang="de"><seg>Der String darf nicht leer sein!</seg></tuv>
           <tuv xml:lang="en"><seg>The String should not be empty!</seg></tuv>
       </tu>
   </body>
</tmx>

Wenn man nunmehr alle diese Dateien angelegt hat, dann hat sollte die Übersetzung angezeigt werden. Die validate.xml stellt hierbei die Fehlermeldungen für Zend_Form. Wie schon gesagt ist dieses System noch nicht ganz ausgereift, aber doch um einiges weiter wie alte Beispiele in diesem Blog. Über Weiterentwicklungen halte ich euch auf dem Laufenden. Es ist jedoch zu betonen, dass es viele Anwendungsfälle gibt und sich so natürlich meine Vorgehensweise nicht für jedes Projekt eignet. Bei Fragen seid ihr aber gerne eingeladen einen Kommentar zu hinterlassen oder auch Anfragen nach Funktionalitäten für diese Resource zu stellen. Ich werde sehen wie ich helfen kann.

<?php

/**
 * Trnaslate Resource
 *
 * Läd alle verfügbaren Übersetzungsdateien und führt sie zusammen
 *
 * @category    Suka
 * @package     Suka_Application
 * @subpackage	Resource
 * @author      Denis Zunke <denis.zunke@zorta.de>;
 * @version     0.1
 * @copyright   2010 zorta.de
 * @link        http://www.zorta.de/SukaSys
 * @license 	http://opensource.org/licenses/gpl-license.php GNU Public License v3
 */

class Suka_Application_Resource_Translate extends Zend_Application_Resource_ResourceAbstract {

	/**
	 * @see Zend_Translate
	 * @var Zend_Translate
	 */
	protected $_translation;

	/**
	 * Initialisiert die Resource, führt sie aus und gibt sie zurück
	 *
	 * @see Zend_Application_Resource_Resource::init()
	 * @return Zend_Translation
	 */
	public function init()
	{
		$options = $this->getOptions();

		// Das Basisobjekt erstellen, das aus der MainConfig geschlossen wird
		$this->_translation = new Zend_Translate(array(
			'adapter' => $options['adapter'],
			'content' => APPLICATION_PATH . DIRECTORY_SEPARATOR . $options['configdir'] . DIRECTORY_SEPARATOR . $options['file'],
			'disableNotices' => true
		));

		if (isset($options['scan']) AND $options['scan'] === true) {
			// Wenn der Scan aktiviert ist, dann durchsuche nunmehr die Modulverzeichnisse und füge die Files an
			$this->_scanPaths();
		}

		if (isset($options['files']) AND count($options['files']) > 0) {
			// Einlesen fest vorgegebener Dateien
			$this->_readFiles();
		}

		Zend_Registry::set('Zend_Translate',$this->_translation);
		return $this->_translation;
	}

	/**
	 * Durchsucht die Modulverzeichnisse nach weiteren Sprachdateien
	 * und fügt diese dem Hauptobjekt an
	 */
	protected function _scanPaths()
	{
		$options 		= $this->getOptions();
		$scanDir		= APPLICATION_PATH . DIRECTORY_SEPARATOR . $options['moduldir'];

		if (is_dir($scanDir)) {
			$dir = dir($scanDir);
			while (false !== ($entry = $dir->read())) {
				$modDir = $scanDir . DIRECTORY_SEPARATOR . $entry . DIRECTORY_SEPARATOR . $options['configdir'];
		   		if ($entry != '.' AND $entry != '..' AND is_dir($modDir)
		   			AND file_exists($modDir . DIRECTORY_SEPARATOR . $options['file'])
	   			) {
		   			$this->_translation->getAdapter()->addTranslation($modDir . DIRECTORY_SEPARATOR . $options['file']);
		   		}
			}
		}
	}

	/**
	 * Liest bestimmte Dateien ein, die in den Optionen festgelegt sind
	 */
	protected function _readFiles()
	{
		$options = $this->getOptions();

		foreach ($options['files'] as $file) {
			if (file_exists($file)) {
				$this->_translation->getAdapter()->addTranslation($file);
			}
		}
	}

}

Das Video wird euch die Komponenten Zend_Translate und Zend_Locale näher bringen. Über Plugins und View Helper kann man diese verwenden. IN dem Video wird gezeigt, wie man sprach-freundliche  Routen erstellt, wie man einen Sprach-Wechsler erstellt und wie man .csv Sprach-Dateien ausliest und einbindet.

Zum Webcast

Wenn man am Ende alles richtig eingebaut hat anhang der Beispieldaten, dann sind die Sprachen Deutsch und Englisch verfügbar über die folgenden Adressen:

http://en.domain.tld -> Englisch
http://de.domain.tld -> Deutsch
http://fr.domain.tld -> Deutsch, da dies als Standard gesetzt wird in der Bootstrap

Zuerst einma benötigt man Translate Dateien. Ich habe dafür eine Verzeichnisstruktur angelegt, in der sich ein Ordner für jede Sprache findet. In meinem Fall sind dies “de” und “en”. In diesen liegen dann die verschiedenen PHP Dateien mit Arrays. Hier kurz Beispielhaft für Deutsch und Englisch jeweils die string.php

return array(

'WELCOME' => 'Willkommen zum Test'

);

return array(

'WELCOME' => 'Welcome to the Test'

);

Über die application.ini setzt man die nötigen Routen, Locale und Translate Einstellungen. Bitte die angegebene Domain im Router auch in die richtige ändern.

resources.router.routes.language.type = "Zend_Controller_Router_Route_Hostname"
resources.router.routes.language.route = ":lang.domain.tld"
resources.router.routes.language.defaults.controller = "index"
resources.router.routes.language.defaults.action = "index"
resources.router.routes.language.defaults.lang = "de"
resources.router.routes.language.chains.index.type = "Zend_Controller_Router_Route"
resources.router.routes.language.chains.index.route = ":controller/:action/*"
resources.router.routes.language.chains.index.defaults.module = "default"
resources.router.routes.language.chains.index.defaults.controller = "index"
resources.router.routes.language.chains.index.defaults.controller = "index"
resources.router.routes.language.chains.base.type = "Zend_Controller_Router_Route"
resources.router.routes.language.chains.base.route = "/*"
resources.router.routes.language.chains.base.defaults.module = "default"
resources.router.routes.language.chains.base.defaults.controller = "index"
resources.router.routes.language.chains.base.defaults.controller = "index"

resources.translate.adapter = "array"
resources.translate.data = APPLICATION_PATH "/languages"
resources.translate.locale = "en"
resources.translate.options.disableNotices = true
resources.translate.options.scan = "directory"

Und zuletzt die Bootstrap Klasse

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{

protected function _initRequest()
{
// Nötige Abhängigkeiten auflösen
$this->bootstrap('FrontController');
$this->bootstrap('router');

// Den Frontcontroller holen
$front = $this->getResource('FrontController');

// Ein Request Objekt in den Frontcontroller setzen
$request = new Zend_Controller_Request_Http();
$request->setBaseUrl('/');
$front->setRequest($request);

// Den Request in die Registry des Bootstrap Objekt setzen
return $request;
}

protected function _initLang()
{
// Die nötigen Abhhängigkeiten aufbauen
$this->bootstrap('FrontController');
$this->bootstrap('router');
$this->bootstrap('translate');

// Den Frontcontroller mit dem Request Objekt holen und den Router ausführen
$front = Zend_Controller_Front::getInstance();
$request = $front->getRequest();
$router = $front->getRouter();
$router->route($request);

// Das Translate Objekt holen
$lang = $this->getResource('translate');

// Prüfen, ob die ausgewählte Sprache zur verfügung steht, wenn nicht, dann Standard setzen.
if (!$lang->isAvailable($front->getRequest()->getParam('lang','de'))) {
$front->getRequest()->setParam('lang','de');
}

// Die ausgewählte Sprache in das Translate setzen
$lang->setLocale($front->getRequest()->getParam('lang'));

return;
}

}

Zum Test kann man sich einen String ausgeben lassen in der View

<?=$this->translate('WELCOME')?>

Das ganze ist natürlich noch um einige Features erweiterbar, aber mit diesen Schritten hat man eine gute Basis um weiter zu kommen. Interessant sind für den Einbau wohl noch Zend_Cache, entsprechende andere Router oder das speichern der Standardsprache in der Konfiguration für schnelle Änderungen.