Then I have started on the solr extension project for TYPO3 I work on with Ingo Renner and dkd, where my current task is to set up a BE Module for the extension with extbase and fluid. A Good kick start for me at those topics and Typo3 4.3 .

Last I am trying to improve my actionscript 3 skills at the moment in the project of the German ISP I am contracted for until march 2010. Basically this is an alarm clock witch comes in two layouts, analog and digital, and can be configured via jSon. For this task I am currently testing the new Flash Builder 4 Beta from Adobe, witch is quite nice and a definite buy at its release next year. The Adobe guys finally build a nice developer tool for Flash, witch is way better then the current Flexbuilder, and the IDE provided by powerflasher. I will share parts of this later this week in a public version of the code.

So after asking uncle google for several hours, and some more trail an error, I stumbled across this little line:

  $GLOBALS['TSFE']->indexedDocTitle = "Here the title to display";

Honestly, this is not mentioned in the documentation of the indexed search or in any other documentation I have found. Searching for “indexed_search page title” does not return everything near this, nor did “index_search result title” do the magic.

The developer I am, really frustrated, I took a look in the source of the indexed search engine and found the magic line. Asking uncle google about “indexedDocTitle” and how it has to be used returned the solution.

So guys and girls to save you some time, and nerves here ist a little extension for you that is configured via typoscript:

T3X_sl_indexedsearch_result_title-1_0_0-z-200911192123

Typoscript for your page is quite easy:

 plugin.tx_slindexedsearchresulttitle_pi1{
	indexedSearchResultTitle = COA
	indexedSearchResultTitle{
			5 = TEXT
			5.value = Hello 

			10 = TEXT
			10.value = World

			wrap = Test Title: |
	 }
  }

  page.999 < plugin.tx_slindexedsearchresulttitle_pi1

After those lines the extension is included in every page, and depending on what you have configured in TypoScript ( in this case “Test Title: Hello World” ) will be shown in the results of the indexed search.

I hope this saves you some time. By the time I have found some time to write a little manual for the extension, I promise I will upload this to the TER, but until then you will find it here. Just because me myself I hate extensions that come without any manual if there is something to configure.

1. T3X_sl_zendframework-1_9_5-z-200911181108
2. T3X_slmvchelper-1_0_0-z-200911180116

In one of my previous posts I showed you how to implement the Zend_AutoLoader in your normal PHP project to save your self some time and to make you stop carrying about if a class is loaded all ready or has to be required. Wouldn´t it be nice if one has Autoloading inside Typo3 too ? Well this can be done quite easy. First of all you will have to install the sl_zendframework Extension into your typo3.

This will provide two things to you.

First of all you will be able to use all the nice things the Zendframework delivers at the version 1.9.5 (except zend_locale, zend_gData, and zend_codegenerator those where removed because of size issues). The second advantage you will get is worth even more, you will have lazy loading via autoload.

By default this extension provides the autoloading for all Zend related classes you might need in your extension. The only requirement is that it is installed and loaded before your own extension. You are able to check that in the localconf.php by the order of $TYPO3_CONF_VARS['EXT']['extList']. The sl_zendframework extension has to stand at a position in that list that is before the position of your plugin.

The sl_zendframework will also provide you with the variable $autoloader inside the ext_localconf.php file of your extension witch is a singleton instance of Zend_Loader_Autoloader. This will be the base to get your extension to autoload what is inside,… or even if other extensions use this too, what is inside them too.

The way to achieve this is quite simple:

/**
 * this is the path to typo3conf/ext,
 * or if the extension is installed global typo3/ext
 */
$s_include_path = str_replace('yourExtensionKey/',
                    '',
                    t3lib_extMgm::extPath('yourExtensionKey'));

/**
 * now we add the path to the extensions
 * parent folder to the includepath list
 */
set_include_path(get_include_path() .
                          PATH_SEPARATOR .
                          $s_include_path);

/**
 * now we register the name of the extension as
 * a namespace for the autoloader
 */
$autoloader->registerNamespace ( 'yourExtensionKey' );

After you added those lines to your ext_localconf.php you can almost forget about include and require statements, as long as the class you want to
instanciate is inside your extension folder and prefixed with name of your extension, witch you just registered as a namespace to the autoloader.

Let me show you some examples:

 // file inside  a folder with the name "yourExtensionKey"
 // carrying the name yourClassName.php
 $instance_1 = new yourExtensionKey_yourClassName();

 // file inside  a folder with the name "subFolderName"
 // inside the folder "yourExtensionKey"
 // carrying the name yourClassName.php
 $instance_2 = new yourExtensionKey_subFolderName_yourClassName();

No more require_once needed because the zend_autoloader will do the job for you. Now that I have showed you how to get the autoloader up and running for your extension, let me introduce you to the second extension “slmvchelper”. This extension can be called the result of working with typo3 for several years now (in 2010 it be my 7th anniversary of working with typo3). As I mentioned before I am a little bit lazy when it come to writing code, so I try to save myself as many lines as possible, and try to keep it as simple as possible if someone else or even me myself has to edit a extension I have done. This is way I came up with the idea of the two classes this extension contains (as well as a example pi1) by the start of 2009.

The first one helps you with the template parsing and all the methods one has to use during the development of a extension to get his template parsed and displayed. It is called “slmvchelper_view_templateParser”, and yes if you install the extension on your system it will register it self to the autoloader so that you can use it by this simple line of php:

  $this->view = new slmvchelper_view_templateParser($this);

After that you will have an instance of the Templateparser witch provides you with some simple methods to make your live easier while developing extensions.
But step by step.

Next thing you will have to do is this:

  $this->view->setTemplate($this->conf['template.']['path']);
  $this->view->setSubPart($this->conf['template.']['mainSubPart']);

The “setTemplate” method excepts a string witch leads it to the template file you want to use. In this case this would be provided in plugin.tx_slmvchelper_pi1.template.path and is something like “EXT:slmvchelper/static/html/template.html”. After the call the template
will be loaded. Next thing to do is to set the main Subpart of the template you want to work with. Same here, it is provided in plugin.tx_slmvchelper_pi1.template.mainSubPart and is something like ‘TEMPLATE_MAIN’. The setSubPart method exepts two parameters, the first one is mandatory because it is the subpart you want to declare, the second one is optional because it is the parent subpart of the subpart to declare. So if you want to work on a subpart within another one you would do something like this:

  $this->view->setSubPart('SUBPART_TEST', $this->conf['template.']['mainSubPart']);

Witch would mean you are declaring the subpart named “SUBPART_TEST” inside “TEMPLATE_MAIN”. After you have done this you might want to set some markers and parse the whole stuff and return it. This is also quite easy:

  $marker = array(
		'NORMAL_MARKER' => 'Hallo Welt'
  );

  $subparts = array(
		'SUBPART_TEST' => $this->view->parse($marker, array(),
                                                'SUBPART_TEST')
  );
  $content = $this->view->parse($marker, $subparts,
                                           $this->conf['template.']['mainSubPart']);

By now you might have recognized that those three “#” are missing at the marker name as well as at the subparts name, this is they are no longer required inside your php code, they will be set automatically by the template parser inside the method parse(). I think the first and the second Parameter should be quite obvious, and the third should be no that hard to guess. Right, the third param of the parse method is the name of the subpart you want to use for parsing the values. So for the subpart ‘SUBPART_TEST’ this would be ‘SUBPART_TEST’ and for the template it self this would be $this->conf['template.']['mainSubPart'] or TEMPLATE_MAIN. This is it, to my mind the easiest way to get your template parsed and displayed.

But wait there is more:
The templateparser also provides you with some markers that are there by default. You can access everyting inside your locallang file by simply adding the marker ###LL_yourLocalLangKey### to the template, it will be parsed automatically and add the value of “yourLocalLangKey” to your template, and you do have also every public member variable of $this->cObj->data available by simply adding ###COBJDATA_nameOfTheMember###. So for instance ###COBJDATA_uid### will display the uid of the tt_content element witch is stored inside $this->cObj->data->uid.

The second class of the “slmvchelper” extension is called “slmvchelper_model_base”, witch will provide to you a light version of extBase witch comes with typo3 4.3 this winter. The “slmvchelper_model_base” class gives you the opportunity to simply read and write data to your database. All that is required is for you to set up a model witch has all the fields of your database table as member variables as well as you have to set the table name to work with inside the constructor of the model.

Your model should be looking something like this:

  class yourExtensionKey_model_databaseTableName extends
  slmvchelper_model_base{
	protected $uid;
	protected $pid;
	protected $text;

	public function __construct()
	{
		$this->setTable('tx_yourExtensionKey');
	}

	public function setUid($uid)
	{
		$this->uid = $uid;
	}

	public function getUid()
	{
		return $this->uid;
	}

	public function setPid($pid)
	{
		$this->pid = $pid;
	}

	public function getPid()
	{
		return $this->pid;
	}

	public function setText($text)
	{
		$this->text = $text;
	}

	public function getText()
	{
		return $this->text;
	}
}

Remember we got autoloading so now we can go on in the pi1 for instance with:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setText('Hallo Welt');
  $o_newRecord->save();

What just happened is that we inserted a new Record into the database. That simple. After the save() $o_newDummyRecord provides you with $o_newDummyRecord->getUid() witch will return the uid of the record we just inserted.

If you want to read a simple record from the Database the code would look like this:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setUid(1);
  $o_newRecord->getThis();

If you want all records that contain the string “Hello” ordered by sorting this would be your code:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setText('Hello');
  $result = $o_newRecord->getAll('sorting');

In this case $result would contain an array of yourExtensionKey_model_databaseTableName objects filled with the data of each record.
Even getting querys build like (hidden = 0 AND Deleted = 0 AND (starttime = 0 OR starttime < time()) AND ((endtime = 0 OR endtime < time()))
is possible.

Just like this:

  $o_newRecord = new yourExtensionKey_model_databaseTableName();
  $o_newRecord->setText('Hello');
  $o_newRecord->setHidden(0);
  $o_newRecord->setDeleted(0);
  $o_newRecord->setStarttime('=_0_>=_'.time());
  $o_newRecord->setEndtime('=_0_<=_'.time());
  $result = $o_newDummyRecord->getAll('sorting');

In this case your model should contain the member variables deleted, hidden, starttime and endtime as well as their getters and setters.

All of this you can see in action if you install the sl_zendframework and the slmvchelper extension to your typo3 and put the pi1 of slmvchelper in one of your pages. It will show you a simple example, and if you look inside the pi1 file you can see a little summary of this tutorial working.

I hoped you enjoyed my tutorial and feedback would be appreciated.

But back to the topic of this post,.. I came across the new Autoloader Class provided with the Zend Framework, studied some of the documentation. And Failed,.. perhaps I over-read something but where does the documentation mention that your class has to be prefixed with the name of the namespace one registers ?

But one by one, if you like to use the autoloader either with your extension to the CM-System of your choice (in my case this would be Typo3 at 90% of the projects I work on), or within some php-code you write for a customer, you will have to start wit something like this:

  set_include_path ( '.' . PATH_SEPARATOR . 'path/to/Zend_Framework/' );

  require_once 'Zend/Loader/Autoloader.php';
  $autoloader = Zend_Loader_Autoloader::getInstance ();
  $autoloader->setFallbackAutoloader ( true );
  $autoloader->registerNamespace ( 'nameOfYourNameSpace' );

This was how far I got with the documentation. Because I know some other languages like JAVA, I knew that I would have to create a nice little sub folder called “nameOfYourNameSpace” in the directory for a SOAP – Client I lately wrote for a customer of mine. I went on creating the class file I needed:

  class myClass
  {
     public function __construct()
     {
        // here the code Starts
     }
  }

Like I said I am used to the conventions of other languages when it comes to namspaces, so I called the file myClass.php. Now in my imprudence I thought something like this would work right from the Start, as well as I am getting rid of those require_once statements:

  $o_myObject = new nameOfYourNameSpace_myClass();

Hhmmm,… nope it doesen`t,… turns out that the class within the file has to be prefixed by the name of the namespace it self. So I had to change the php class to this:

  class nameOfYourNameSpace_myClass
  {
     public function __construct()
     {
        // here the code Starts
     }
  }

After that, the first code segment worked fine for me, and I had a nice little autoloader to load my models. Is it just me, or would you too have expected that it should be enough to create the folder structure registered in the first snippet and call the class just like the file name ?

Perhaps this was a little help for you getting to know the Zend_Loader_Autoloader.
Drop me some thoughts if you like.