tschortsch's blog

Developing the web, logging the web, loving the web!

[juerghunziker]

What I have learned from using CSS3 Animations

First of all: CSS3 Animations are awesome!

I started using them to implement an idle animation on my portfolio page http://juerghunziker.ch.

My target was to make the Twitter bird on my page fly! I know, regarding the brand guidelines from Twitter I'm not allowed to do that. But hey, I did it anyway because... it just looks soo awesome! We're still friends Twitter? Right?

So where should I start? I used this tutorial to create the main flying animation (Thanks a lot!). The first thing I struggled to get the animation to work in my Chrome browser were the missing vendor prefixes in the animation part of the CSS. So I added them and my bird already flatted his wings. What I didn't know at this point: This was just the beginning of an upcoming vendor battle.

Vendor Prefixes

The first thing you have to do if you want to support the variety of the most common browsers out there is to implement CSS properties for all vendors. It looks like that Webkit is the last browser engine which doesn't support the unprefixed version of the animation properties. So we just have to add them to get it to work on all current browsers:

.twitter-bird-fly { -webkit-animation: fly 0.2s steps(3) 28; animation: fly 0.2s steps(3) 28; } @-webkit-keyframes fly { 0% { background-position: 0 0; } 100% { background-position: -90px 0; } } @keyframes fly { 0% { background-position: 0 0; } 100% { background-position: -90px 0; } }

Selecting CSS Rules

With the above piece of code and a second animation which moves my Twitter bird <div>-element to a chosen target position I already have done the biggest part of the work. That's what I thought...

Y U No stop moving 'target position'?

My target position is always at another coordinate of the page depending on the size and the shape of the browser window. So what I had to do is selecting the CSS keyframe rule and replace the 100%-subrule with the actual target position.

The cool part about this: You can access and change all CSS rules through a nice litte JavaScript API. So I have written a JavaScript function to select a CSS keyframe rule by name:

function getKeyframeRule(ruleName) { var ss = document.styleSheets, rule, i, x; for (i = 0; i < ss.length; ++i) { if(ss[i].cssRules) { // loop through all the rules (from bottom to top -> the most bottom matching rule is the applied rule)            for (x = ss[i].cssRules.length - 1; x >= 0; --x) {                rule = ss[i].cssRules[x]; if(rule.type === window.CSSRule.KEYFRAMES_RULE && rule.name === ruleName) { return rule; } } } } return null; }

But again there were some problems when using it in different browsers:

Hands off cross-origin stylesheets!

The first thing I had to learn the hard way was that Firefox doesn't allow you to access the cssRules-property of cross-origin stylesheets (expect CORS headers are set on remote machine). So we have to look for the keyframe in our local stylesheet only.

if(ss[i].href === styleSheetUrl && ss[i].cssRules)

Vendor Prefixes again...

Then there was another problem with the KEYFRAMES_RULE constant which isn't available in Webkit borwsers without its vendor prefix. What we have to do is obvious: Also check for WEBKIT_KEYFRAMES_RULE.

if((rule.type === window.CSSRule.KEYFRAMES_RULE || rule.type === window.CSSRule.WEBKIT_KEYFRAMES_RULE) && rule.name === ruleName)

The result

function getKeyframeRule(ruleName, styleSheetUrl) { var ss = document.styleSheets, rule, i, x; for (i = 0; i < ss.length; ++i) { if(ss[i].href === styleSheetUrl && ss[i].cssRules) { // loop through all the rules (from bottom to top -> the most bottom matching rule is the applied rule) for (x = ss[i].cssRules.length - 1; x >= 0; --x) { rule = ss[i].cssRules[x]; if((rule.type === window.CSSRule.KEYFRAMES_RULE || rule.type === window.CSSRule.WEBKIT_KEYFRAMES_RULE) && rule.name === ruleName) { return rule; } } } } return null; }

Et voilà: A function which works in all common browsers!

Chhhh..chh.. We're going deeper. Over.

Now that we have selected the keyframe rule we want to change the 100%-subrule. Again I wrote a litte JavaScript function which does exactly this:

function adjustBirdMoveAnimation(birdMoveRule) { birdMoveRule.deleteRule("100%"); birdMoveRule.insertRule("100% { -webkit-transform: scaleX(-1); transform: scaleX(-1); top: " + calculateDistanceY() + "px; left: " + calculateDistanceX() + "px; }"); }

This is what works in most of the browsers. But we want to get it to work in all browsers! So I had to do some modifications.

Internet Explorer respects standard specifications?!

I was really surprised when Internet Explorer told me that "100%" is not a valid parameter for the deleteRule()-function. A short look at the specifications at the Mozilla Developer Network confirmed what IE said: The method does only accept numbers between 0 (for 0%) and 1 (for 100%) as parameter.

So in our example we have to call the deleteRule()-function with the parameter 1 in IE to delete our 100%-rule. All other browser are also accepting a percentage value as string. (Some of them even only accept this parameter type!)

So we have to distinguish the implementation for IE browsers from all other browsers. To find out if your site is viewed with an IE browser just grab a random browser recognition function/library from the internet. I personally used the one from this StackOverflow answer: http://stackoverflow.com/a/16657946

// In IE the deleteRule function only accepts numbers from 0 to 1 if(myLib.isIE()) { birdMoveRule.deleteRule(1); } else { birdMoveRule.deleteRule("100%"); }

But all the cool kids have it (even Internet Explorer!)

It seems that Firefox again didn't want to make friends with the other browsers and implemented an appendRule()-function instead of the insertRule()-function. So what we have to do is checking if an appendRule()-function is available and using this instead of the insertRule()-function.

// Check if appendRule function is available (for Mozilla browsers) (see: https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule) if($.isFunction(birdMoveRule.appendRule)) { birdMoveRule.appendRule(newAnimationEndRule); } else { birdMoveRule.insertRule(newAnimationEndRule); }

The result

function adjustBirdMoveAnimation(birdMoveRule) { var newAnimationEndRule; // In IE the deleteRule function only accepts numbers from 0 to 1 if(myLib.isIE()) { birdMoveRule.deleteRule(1); } else { birdMoveRule.deleteRule("100%"); } newAnimationEndRule = "100% { -webkit-transform: scaleX(-1); transform: scaleX(-1); top: " + calculateDistanceY() + "px; left: " + calculateDistanceX() + "px; }"; // Check if appendRule function is available (for Mozilla browsers) (see: https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule) if($.isFunction(birdMoveRule.appendRule)) { birdMoveRule.appendRule(newAnimationEndRule); } else { birdMoveRule.insertRule(newAnimationEndRule); } }

Most people listen to music, I listen to events

Thanks to the mentioned Animation JavaScript API it is possible to do something after an animation has ended. And surely I had to find a use for this as soon as I heard of it. So I wanted to show a Follow me! speech bubble after the bird has landed.

// show followme tooltip after bird move animation is done $('#twitter-bird-box').one('animationend', showFollowMeTooltip );

And a new JavaScript snippet was born... which worked in almost no browser :( You can imagine why...

Vendor prefixes! (For the last time now)

We also have to listen to the prefixed versions of the animationend event like this:

// show followme tooltip after bird move animation is done $('#twitter-bird-box').one('webkitAnimationEnd oanimationend MSAnimationEnd animationend', showFollowMeTooltip );

Almost there!

Okay, I now have a bird animation that works in all commonly used browsers. But there was one problem left: Once the animation has finished it never played again until I reloaded the page. 

Restart animation

In my example removing the animation class and readding it worked pretty well. The fact that I always readd the animation class after a certain timeout makes it an easy solution... except you want it to make it work in IE. To accomplish this I had to hide all elements which have an animation with display: none; and reshow it.

// stop animation -> remove animation classes and hide elements $('#twitter-bird-box').removeClass('twitter-bird-move'); $('#twitter-bird').removeClass('twitter-bird-fly'); $('#twitter-bird').hide(); $('#twitter-bird-box').hide();

// start animation -> add animation classes and show elements $('#twitter-bird-box').show(); $('#twitter-bird').show(); $('#twitter-bird').addClass('twitter-bird-fly'); $('#twitter-bird-box').addClass('twitter-bird-move');

There are other (probably more performant) solutions to restart CSS3 animations described at css-tricks.com. You probably want to look into these too.

Habemus papam!

We finally have a flying Twitter bird which works in Chrome, Firefox, Safari, Opera, IE10+ and all the mobile browsers. The benefit that my page is hosted on GitHub is that you have the chance to look into the whole JavaScript and CSS sources of it: https://github.com/tschortsch/tschortsch.github.io

Now head over to http://juerghunziker.ch and go find my animation! Or just wait for it ;)

[juerghunziker]

I'm now officially a Pokemon Master!

My efforts to catch all the 151 hidden Pokemons in the Google Maps Pokemon Challenge weren't for nothing. Yesterday I recieved a letter from Google with a Thank You-note and a stack of really cool Pokemon Master-business cards!

Thank you very much Google! You really made my day.

[juerghunziker]

Unit Testing einer TYPO3 Extbase Extension (Teil 3: Controller)

< 2. Teil: Validatoren und Repositories

Ganz nach dem Motto lieber spät als nie, hier Teil 3 der Serie Extbase Unit Testing. Darin werde ich auf das Unit Testing von Extbase Controllern eingehen.

Der Verständlichkeit halber habe ich für diesen Teil eine kleine dummy Extension erstellt. Diese Extension (jh_theanswer) besteht aus einem einzelnen AnswerController mit einer Action, der showAction.

Durch den Aufruf der showAction berechnet die Extension aufgrund eines Wertes aus einem Domainobjekt und einem magischen Wert aus dem Konstanten-File (settings.magicNumber) die Antwort nach dem Leben, dem Universum und dem ganzen Rest. Dieser Wert wird schlussendlich dem Template via assign()-Methode zur Verfügung gestellt.

Die Extension könnt ihr euch im Detail auf GitHub ansehen: https://github.com/tschortsch/jh_theanswer

Controller initialisieren

Bevor wir die Testmethode ausführen können müssen alle Objekte, welche von Extbase verwendet werden initialisiert werden. Dies ist bei einem Controller-Test etwas komplexer. Als erstes müssen wir den Controller selbst erstellen:

class Tx_Jh_theanswer_Controller_AnswerControllerTest extends Tx_Extbase_Tests_Unit_BaseTestCase { [...] /** * Fixture * @var Tx_JhTheanswer_Controller_AnswerController */ protected $controller = NULL; public function setUp() { // create controller $this->controller = $this->objectManager->get('Tx_JhTheanswer_Controller_AnswerController'); $this->prepareController(); } }

Danach werden alle Abhängigkeiten innerhalb des Controllers initialisiert:

class Tx_Jh_theanswer_Controller_AnswerControllerTest extends Tx_Extbase_Tests_Unit_BaseTestCase { [...] /** * @var Tx_Extbase_MVC_Request */ protected $request = NULL; /** * @var array */ protected $settings = NULL; /** * @var Tx_Fluid_View_TemplateView */ protected $view = NULL; /** * @var Tx_JhTheanswer_Domain_Repository_AnswerRepository */ protected $answerRepository = NULL; protected function prepareController() { $this->request = $this->getMock('Tx_Extbase_MVC_Request'); $this->controller->setRequest($this->request); $this->view = $this->getMock('Tx_Fluid_View_TemplateView', array(), array(), '', FALSE); $this->controller->setView($this->view); $this->settings = array( 'magicNumber' => 10 ); $this->controller->setSettings($this->settings); $this->answerRepository = $this->getMock('Tx_JhTheanswer_Domain_Repository_AnswerRepository', array('findByUid')); $this->controller->injectAnswerRepository($this->answerRepository); } }

In der prepareController()-Methode werden zuerst Mock-Objekte eines Requests und einer View an den Controller gebunden. Zudem müssen alle im Controller verwendeten Settings aus dem $settings-Array von Hand abgebildet und ebenfalls an den Controller gebunden werden. Die dabei verwendeten Setter-Methoden (setRequest(), setView(), setSettings()) stehen standardmässig nicht in den Extbase-Controllern zur Verfügung und müssen deshalb manuell erstellt werden.

class Tx_JhTheanswer_Controller_AnswerController extends Tx_Extbase_MVC_Controller_ActionController { [...] /** * Sets the view * * This function is intended to be used for unit testing purposes only * * @param Tx_Fluid_View_TemplateView $view The new view * @return void */ public function setView(Tx_Fluid_View_TemplateView $view) { $this->view = $view; } /** * Sets the request * * This function is intended to be used for unit testing purposes only * * @param Tx_Extbase_MVC_Request $request The new request * @return void */ public function setRequest(Tx_Extbase_MVC_Request $request) { $this->request = $request; } /** * Sets the settings * * This function is intended to be used for unit testing purposes only * * @param array $settings The new settings * @return void */ public function setSettings(array $settings) { $this->settings = $settings; } }

Mit diesen Schritten sollte der Controller vollständig initialisiert sein und wir können den eigentlichen Test schreiben.

Test erstellen

In userem Test wollen wir die showAction des AnswerControllers testen:

class Tx_JhTheanswer_Controller_AnswerController extends Tx_Extbase_MVC_Controller_ActionController { [...] /** * action show * * @return void */ public function showAction() { $answerRecordUidFromSetup = $this->settings['theAnswerUid']; $answer = $this->answerRepository->findByUid($answerRecordUidFromSetup); $theAnswer = $this->calculateAnswer($answer->getValue()); $this->view->assign('theAnswer', $theAnswer); } /** * @param $value integer answer from domain object * @return integer the answer */ protected function calculateAnswer($value) { return $value + $this->settings['magicNumber']; } }

Die showAction liest ein in den Konstanten definiertes Answer-Domainobjekt aus der Datenbank und berechnet daraus mit der calculateAnswer()-Methode die gesuchte Antwort. Diese wird schlussendlich per assign()-Methode dem Template zur Verfügung gestellt.

In userem Test wollen wir nun den assign()-Aufruf überprüfen. Dadurch wird automatisch auch die calculateAnswer()-Methode getest da deren Rückgabewert im assign()-Aufruf zugewiesen wird.

class Tx_Jh_theanswer_Controller_AnswerControllerTest extends Tx_Extbase_Tests_Unit_BaseTestCase { [...] /** * @test * @author Jürg Hunziker <[email protected]> */ public function showActionAssignsAnswer() { $answer = $this->mockAnswerRepositoryFindByUid(); // the actual test $expectedAnswer = 42; // $answer->getValue() + $this->settings['magicNumber'] $this->view->expects($this->at(0))->method('assign')->with('theAnswer', $expectedAnswer); // call the controller action $this->controller->showAction(); // tear down locally defined variables unset($answer); unset($expectedAnswer); } /** * Returns dummy answer * * @return Tx_JhTheanswer_Domain_Model_Answer $answer * @author Jürg Hunziker <[email protected]> */ public function mockAnswerRepositoryFindByUid() { $answer = $this->objectManager->get('Tx_JhTheanswer_Domain_Model_Answer'); $answer->setValue(32); $this->answerRepository->expects($this->once())->method('findByUid')->will($this->returnValue($answer)); return $answer; } }

Als erstes müssen wir definieren was der findByUid()-Aufruf im answerRepository zurückgibt. Dies geschieht in der Methode mockAnswerRepositoryFindByUid(). Darin erstellen wir ein Answer-Domainobjekt und setzen dessen Value auf 32. Danach definieren wir, dass der erste Aufruf der findByUid()-Methode dieses Objekt zurückliefert. Das erstellte Answer-Objekt geben wir zudem als Rückgabewert zurück, da wir danach auf dessen Value die Berechnung durchführen.

Da wir wissen, dass die Methode calculateAnswer() im Controller lediglich den Answer-Value mit dem Wert der magicNumber-Konstante addiert können wir die $expectedAnswer auf 42 festlegen.

Nun folgt der eigentliche Test. Wir erwarten, dass beim ersten Aufruf (at(0)) der assign()-Methode der 'theAnswer'-Variable unsere $expectedAnswer zugewiesen wird:

$this->view->expects($this->at(0))->method('assign')->with('theAnswer', $expectedAnswer);

Danach rufen wir die Action auf:

$this->controller->showAction();

Schlussendlich räumen wir noch die lokal definierten Variablen ab:

unset($answer); unset($expectedAnswer);

Test aufrufen

Im Backend können wir unseren Test nun ausführen.

Geschafft!

Damit haben wir bereits unseren Controller getestet. Das Vorgehen kann für beliebige assign()-Aufrufe adaptiert werden.

Zu den anderen Teilen:

Teil 1: Einstieg

Teil 2: Validatoren und Repositories

Teil 3: Controller

[juerghunziker]

Google Maps: Pokemon Challenge

Google recently launched the Google Maps: Pokemon Challenge as an april fool.

http://google-latlong.blogspot.ch/2014/03/become-pokemon-master-with-google-maps.html

To start the challenge open the Google Maps app on your Android/iOS smartphone tap the search bar and “press start”.

Here is a list of places where you find some of them:

Cern (Pokemon Center)

Google Switzerland GmbH

Googleplex (Pokemon Center)

Paris

Central Park, New York

Statue of Liberty

Tour Eiffel

Arc de Trioumphe

Great Pyramids of Giza

Bermuda

Rio de Janero

Sydney (Pokemon Center)

Niagara Falls

Loch Ness

The White House

Empire State Building

Parco Nazionale del Vesuvio

Boston, Massachusetts

Old Faithful, WY, USA

Astana, Kazakhstan

Hong Kong

Tokyo (Pokemon Center)

Baltra Ecuador Galapagos

Golden Gate Bridge

Alcatraz

San Francisco

Ayers Rock

Mount Everest

London

Milano

Roma

JFK Airport

Disneyland Annaheim

Taj Mahal

Brussels Belgium

The Palm Jumeria Dubai

Mauna Kea, Hawaii

Harvard University

Area 51, Nevada

Alexandria, Egypt

Roswell, New Mexico

Here's a list with the places of all 150 pokemons: http://pokemonaprilfools.wikia.com/wiki/Sorted_by_Pokedex_No

There is a rumor that Mew exists as the 151th pokemon (see http://www.reddit.com/r/googlepokemon/comments/21vi97/mew_2985849/?sort=new). It appears at different places. Currently known places:

-2.98, -58.49

-11.42, -59.92

-0.2257, -65.8120

-1.41,-61.57

-15.241343,-58.125310

-2.165,-55.116

0.23899, -50.411

-4.670340, -64.347964

-3.030041, -64.821066

Mew is only visible if you have found all other 150 pokemons.

UPDATE: I finally found my Mew at one of the known positions! Mine was 0.23899, -50.411. So the 151th pokemon really wasn't an april fool... although the whole pokemon challenge was ;)

With Mew in my pokedex I think my challenge is over and I have to wait for the promised Pokemon Master business card.

[juerghunziker]

Extbase: Richtiges Caching in eigener Extension

Ich entwickle momentan eine grössere Extension mit Extbase 1.3 (für TYPO3 4.5). Die Extension verfügt über ein Backend-Modul zur Verwaltung der Daten und ein Frontend-Plugin. Durch die Komplexität war es für mich unumgänglich ein gutes Caching-Konzept zu entwickeln, um die Performance zu steigern.

Auf Non-Cacheable Actions verzichten

Als ersten Schritt sollte man sich sehr gut überlegen, welche Actions wirklich gecached werden müssen und welche nicht. Die sogenannten Non-Cacheable Actions werden in der Datei ext_localconf.php definiert. In meinem Fall habe ich gleich alle Actions aus dem Array entfernt und damit für jede Aktion den Cache aktiviert.

Ich empfehle diesen Schritt so früh als möglich durchzuführen. So befasst man sich bereits von Anfang an mit dem Caching seiner Extension.

Bei Backend-Aktionen automatisch den Cache löschen

Um nun nicht bei jeder Aktion im Backend manuell den Seiten-Cache löschen zu müssen, habe ich in der Extension eine kleine Utility-Funktion clearPageCache() zur Verfügung gestellt:

class Tx_MyExt_Utility_Helper { /** * Clears page cache of given pages * * @param array $pidArray * @return boolean */ public static function clearPageCache($pidArray) { Tx_Extbase_Utility_Cache::clearPageCache($pidArray); Tx_ExtbaseDam_Utility_Dam::flushCache(); return TRUE; } }

Darin lässt sich spezifisch der Cache löschen. In meinem Fall wird beim Aufruf dieser Funktion der Seiten-Cache aller PIDs gelöscht, die als Parameter übergeben werden und zusätzlich der Cache der extbase_dam Extension.

Diese Funktion rufe ich nun nach jeder Aktion auf, bei der Daten geschrieben bzw. verändert werden.

Tx_MyExt_Utility_Helper::clearPageCache($pidArray);

Zusätzlich habe ich einen tcamain-Hook implementiert, welcher jeweils nach nativen TYPO3 Backend-Aktionen ebenfalls den Seiten-Cache löscht.

class Tx_MyExt_Utility_DbOperationsHook { public static $myExtTableModified = FALSE; /** * Clears page cache if a db operation affected a MyExt table. * Use afterAllOperations hook so cache is only deleted once. * * @param array $pObj obj * @return void */ public function processDatamap_afterAllOperations($pObj) { if(self::$myExtTableModified) { $pageIds = $this->getPageIdsWithPlugin(); Tx_Extbase_Utility_Cache::clearPageCache($pageIds); } } /** * Sets flag if any db operation affects a MyExt table * * @param string $status mode of change * @param string $table the table which gets changed * @param string $uid uid of the record * @param array $fieldArray the updateArray * @param array $pObj obj * @return mixed $fieldArray */ public function processDatamap_afterDatabaseOperations($status, $table, $uid, &$fieldArray, $pObj) { if(!$this->isMyExtOperation($table)) { return $fieldArray; } self::$myExtTableModified = TRUE; return $fieldArray; } /** * Checks if affected table is one of the MyExt tables * * @param $table table on which db operation happened * @return boolean */ protected function isMyExtOperation($table) { $myExtTables = array( 'tx_myext_domain_model_mymodel', '...' ); return in_array($table, $myExtTables); } /** * Returns all ids of pages with included MyExt plugin * * @return array $pageIds */ protected function getPageIdsWithPlugin() { $listType = 'myext_plugin'; $select = 'tt_content.uid, tt_content.pid'; $from = 'tt_content'; $where = "CType = 'list' AND list_type = '" . $listType . "'"; $where .= ' AND tt_content.hidden = 0 AND tt_content.deleted = 0'; $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($select, $from, $where, '', '', ''); $pageIds = array(); if($res) { while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) { $pageIds[] = $row['pid']; } } return array_unique($pageIds); } }

Der Hook wird in der Datei ext_localconf.php registriert.

// Hooking for all database operations in backend $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'][] = 'EXT:' . $_EXTKEY . '/Classes/Utility/DbOperationsHook.php:Tx_MyExt_Utility_DbOperationsHook';

Damit sollte der Cache jeweils aktuell sein. Falls aber aus irgendeinem Grund trotzdem eine Seite mit einem alten Stand ausgeliefert wird, habe ich im Backend-Modul noch ein Icon hinzugefügt, mit welchem man den Cache manuell löschen kann.

/** * action beAjaxClearCache * * @return string */ public function beAjaxClearCacheAction() { $pidArray = array(); return json_encode(Tx_MyExt_Utility_Helper::clearPageCache($pidArray)); }

Den Aufruf im Backend-Template habe ich über Ajax gelöst. Darauf möchte ich in diesem Blogpost aber nicht genauer eingehen.

Probleme mit cHash

Durch das Entfernen der Actions aus dem Non-Cacheable Actions-Array wird allen Links im Frontend ein cHash-Parameter angehängt.

Sobald man auf der Seite aber einen Link ohne cHash-Parameter hat (Bsp. in einem HMENU) wird beim Aufruf dieser Seite der Cache lediglich über die gegebenen PageId in der Datenbank gesucht. Die restlichen Parameter werden komplett ignoriert.

Dies kann zu ungewolltem Verhalten führen, da man ev. über die Extension-Parameter steuern will, welcher Datensatz gerade angezeigt werden soll.

Eine detaillierte Erklärung zu diesem Problem findet man auf folgender Seite: http://typo3.org/documentation/article/the-mysteries-of-chash-1

Um dieses Problem zu umgehen muss man bei allen Frontend-Actions prüfen, ob ein cHash-Parameter vorhanden ist. Falls dies nicht der Fall ist soll der Cache komplett deaktiviert werden.

Dies lässt sich mit einer einfachen Zeile am Anfang jeder Frontend-Action implementieren.

public function detailAction() { // disable cache if no cHash parameter is available $GLOBALS['TSFE']->reqCHash(); ... }

Dies ist zwar nicht die schönste Lösung aber es werden zumindest keine falschen Seiten ausgeliefert.

Ich hoffe ich konnte euch damit etwas weiterhelfen. Ich selbst habe einige Stunden mit der Fehleranalyse verbracht, um herauszufinden, weshalb in der Extension falsch gecachte Seiten angezeigt werden.

[juerghunziker]

Unit Testing einer TYPO3 Extbase Extension (Teil 2: Validatoren und Repositories)

< 1. Teil: Einstieg | 3. Teil: Controller >

Nachdem im 1. Teil der Einstieg ins Unit Testing einer Extbase Extension beschrieben wurde, gehe ich in diesem Teil auf weitere Beispiele von Unit Tests ein. Konkret auf Unit Tests für eigene Validatoren und Repositories.

Validator-Klasse testen

Das wichtigste (und häufig auch einzige), was es bei eigenen Validatoren zu testen gibt, ist die öffentliche isValid()-Methode.

Hier ein Biespiel einer Validator Test-Klasse mit zwei Testcases:

class Tx_MyExt_Domain_Validator_OrderingValidatorTest extends Tx_Extbase_Tests_Unit_BaseTestCase { /** * Fixture * @var Tx_MyExt_Domain_Validator_OrderingValidator */ protected $validator; public function setUp() { $this->validator = $this->objectManager->get('Tx_MyExt_Domain_Validator_OrderingValidator'); } public function tearDown() { unset($this->validator); } /** * @test */ public function overlappingServicesAreNotValid() { $this->assertFalse($this->validator->isValid($this->getOverlappingServices())); } /** * @test */ public function servicesWithoutSelectedDaysAreNotValid() { $this->assertFalse($this->validator->isValid($this->getServicesWithoutSelectedDays())); } /** * Returns services object storage with overlapping selection * * @return Tx_Extbase_Persistence_ObjectStorage<Tx_MyExt_Domain_Model_Service> $services */ protected function getOverlappingServices() { $services = $this->objectManager->get('Tx_Extbase_Persistence_ObjectStorage'); $service1 = $this->objectManager->get('Tx_MyExt_Domain_Model_Service'); $service1->setMonday(TRUE); $services->attach($service1); $service2 = $this->objectManager->get('Tx_MyExt_Domain_Model_Service'); $service2->setMonday(TRUE); $services->attach($service2); return $services; } /** * Returns services object without selection * * @return Tx_Extbase_Persistence_ObjectStorage<Tx_MyExt_Domain_Model_Service> $services */ protected function getServicesWithoutSelectedDays() { $services = $this->objectManager->get('Tx_Extbase_Persistence_ObjectStorage'); $service1 = $this->objectManager->get('Tx_MyExt_Domain_Model_Service'); $services->attach($service1); $service2 = $this->objectManager->get('Tx_MyExt_Domain_Model_Service'); $services->attach($service2); return $services; } }

Die Testklasse hat sehr viele Ähnlichkeiten zur Domain-Model Testklasse, welche wir im 1. Teil erstellt haben. In der setUp()-Methode erstellen wir eine Instanz des zu testenden Validatoren als Fixture. Darauf wenden wir anschliessend alle Tests an.

Unser Validator überprüft Instanzen der aus dem ersten Teil bekannten Service-Domainklasse. Es ist beispielsweise nicht erlaubt, dass sich in verschiedenen Service-Instanzen die gewählten Tage überscheiden. Zudem muss mindestens 1 Tag in einem beliebigen Service ausgewählt sein.

Für den ersten Test overlappingServicesAreNotValid() erstellen wir deshalb in der Methode getOverlappingServices() ein ObjectStorage mit zwei Service-Instanzen, bei welchen jeweils der Montag aktiv ist. Diesen ObjectStorage übergeben wird der isValid()-Methode unsers Validators.

Mit der assertFalse()-Methode können wir anschliessend testen, ob der Validator erkennt, dass diese Kombination nicht erlaubt ist.

Der zweite Test servicesWithoutSelectedDaysAreNotValid() ist sehr ähnlich. Wir erstellen in der getServicesWithoutSelectedDays()-Methode ein ObjectStorage mit zwei Service-Instanzen. Beide haben keine aktivierten Tage. Auch hier muss der Validator erkennen, dass dies nicht erlaubt ist. Wir testen dies wiederum mit der assertFalse()-Bedingung.

Repository testen

Für das Testen von Repositories bringt die phpunit-Extension die Helper-Klasse Tx_Phpunit_Framework mit sich. Damit lassen sich auf einfache Weise Dummy-Datenbankeinträge erstellen und auch wieder löschen. Durch das Erstellen solcher Einträge wissen wir immer genau, welchen Stand die Datenbank hat und können so unser Respository testen.

class Tx_MyExt_Domain_Repository_DailyFeeRepositoryTest extends Tx_Extbase_Tests_Unit_BaseTestCase { /** * Fixture * @var Tx_MyExt_Domain_Repository_DailyFeeRepository */ protected $repository; /** * @var Tx_Phpunit_Framework */ protected $testingFramework; public function setUp() { $this->repository = $this->objectManager->get('Tx_MyExt_Domain_Repository_DailyFeeRepository'); $this->testingFramework = new Tx_Phpunit_Framework('tx_myext'); } public function tearDown() { $this->testingFramework->cleanUp(); unset($this->repository); unset($this->testingFramework); } /** * @test */ public function getMaximumIncomeReturnsHighestEntry() { $this->insertDailyFeeData(); $expectedMaximumIncome = 3000; $maximumIncome = $this->repository->getMaximumIncome(); $this->assertSame( $expectedMaximumIncome, $maximumIncome ); } /** * @test */ public function getDailyFeeByIncomeReturnsDailyFee() { $this->insertDailyFeeData(); $income = 2500; $expectedDailyFee = 20.50; $dailyFee = $this->repository->getDailyFeeByIncome($income); $this->assertSame( $expectedDailyFee, $dailyFee ); } /** * Adds dummy daily fee records */ protected function insertDailyFeeData() { $pid = 0; $this->testingFramework->createRecord( 'tx_myext_domain_model_dailyfee', array( 'pid' => $pid, 'min_income' => 1000, 'max_income' => 2000, 'fee' => 15.50 ) ); $this->testingFramework->createRecord( 'tx_myext_domain_model_dailyfee', array( 'pid' => $pid, 'min_income' => 2001, 'max_income' => 3000, 'fee' => 20.50 ) ); } }

In der setUp()-Methode erstellen wir nun neben unserem Repository auch eine Instanz des erwähnten Framework-Klasse Tx_Phpunit_Framework. Im Konstruktor übergeben wir den Tabellen-Präfix unserer Extension, welcher für die Datenbanktabellen verwendet wird. So wird sichergestellt, dass beim Ausführen der Tests nicht plötzlich Datensätze in andere Tabellen geschrieben werden.

$this->testingFramework = new Tx_Phpunit_Framework('tx_myext');

Die tearDown()-Methode muss ebenfalls um den Aufruf der cleanUp()-Methode erweitert werden. Dadurch werden die während des Tests erstellten Datenbankeinträge auch weider gelöscht.

$this->testingFramework->cleanUp(); unset($this->testingFramework);

Die mit dem Repository verbundene Tabelle speichert Tagestarife zu verschiedenen Einkommensbereichen. Das Repository besitzt dabei zwei zusätzliche Methoden.

Zum Einen lässt sich mit der getMaximumIncome()-Methode das höchste Einkommen selektieren, welches in der Datenbank abgelegt ist. Diese Funktionalität prüfen wir mit der getMaximumIncomeGetsHighestEntry() Test-Methode.

Zuerst erstellen wir in der insertDailyFeeData()-Methode unsere Dummy-Einträge.

/** * Adds dummy daily fee records */ protected function insertDailyFeeData() { $pid = 0; $this->testingFramework->createRecord( 'tx_myext_domain_model_dailyfee', array( 'pid' => $pid, 'min_income' => 1000, 'max_income' => 2000, 'fee' => 15.50 ) ); $this->testingFramework->createRecord( 'tx_myext_domain_model_dailyfee', array( 'pid' => $pid, 'min_income' => 2001, 'max_income' => 3000, 'fee' => 20.50 ) ); }

Darin werden zwei Records mit den nötigen Daten erstellt. Den Tabellennamen übergeben wir als ersten Parameter an die createRecord()-Methode. Die Daten können im zweiten Parameter als assoziatives Array übergeben werden. Wichtig dabei ist, dass für jeden Datensatz die PID 0 angegeben wird.

Da wir diese Einträge nun manuell erstellt haben, wissen wir auch dass das höchste Einkommen auf 3000 festgelegt ist und können dies in unserem Test prüfen.

/** * @test */ public function getMaximumIncomeReturnsHighestEntry() { $this->insertDailyFeeData(); $expectedMaximumIncome = 3000; $maximumIncome = $this->repository->getMaximumIncome(); $this->assertSame( $expectedMaximumIncome, $maximumIncome ); }

Die zweite zusätzliche Methode getDailyFeeByIncome() durchsucht die Tabelle nach dem zum Einkommen passenden Tagestarif. Wir erstellen erneut die Dummy-Einträge und kennen deshalb das zu erwartende Resultat. Für ein Einkommen von 2500 sollte dabei 20.50 zurückgegeben werden.

/** * @test */ public function getDailyFeeByIncomeReturnsDailyFee() { $this->insertDailyFeeData(); $income = 2500; $expectedDailyFee = 20.50; $dailyFee = $this->repository->getDailyFeeByIncome($income); $this->assertSame( $expectedDailyFee, $dailyFee ); }

Hinweis: Die oben beschriebene Methode zum Testen von Repositories führt zwar zu den gewünschten Ergebnissen, wird grundsätzlich aber nicht empfohlen. Das Problem dabei liegt daran, dass beim Ausführen der Tests jeweils Datensätze in die Datenbank geschrieben werden. Falls dabei ein Fehler auftritt und die cleanUp()-Methode nicht mehr ausgeführt wird, bleiben die erstellen Datensätze in der Datenbank bestehen.

Der richtige Ansatz wäre das Repository nicht mit der Datenbank zu verbinden sondern mit beispielsweise einem vorgefertigten JSON-File in welchem die Testdaten gespeichert sind. Leider ist dies bei Extbase-Repositories nicht direkt vorgesehen und müsste komplett selbst implementiert werden.

Das wars!

Nun haben wir bereits Tests für unsere Domain-Models, die Validatoren und Repositories erstellt! Im 3. und letzten Teil werde ich noch auf Unit Tests für Controller eingehen.

Zu den anderen Teilen:

Teil 1: Einstieg

Teil 2: Validatoren und Repositories

Teil 3: Controller

[juerghunziker]

Unit Testing einer TYPO3 Extbase Extension (Teil 1: Einstieg)

2. Teil: Validatoren und Repositories >

Hinweis: Diese Anleitung basiert auf Extbase Versionen ab 1.3.x

Leider findet man zum Thema Unit Testing von Extbase Extensions im Internet bislang nur sehr spärliche Informationen. Auch Anleitungen sind eher rar.

Ich habe mich deshalb etwas damit beschäftigt und möchte hier meine Erfahrungen niederschreiben.

PHPUnit installieren

Um die Tests überhaupt ausführen zu können muss die TYPO3 Extension phpunit installiert werden. Diese Extension liefert bereits alle nötigen Komponenten zum Ausführen von Unit Tests mit sich. Zusätzlich beinhaltet sie viele Hilfsklassen für die Erstellung von TYPO3-spezifischen Unit Tests.

Nach der Installation lassen sich über das neue Backend-Modul PHPUnit bereits bestehende Unit Tests ausführen.

Allgemeine Informationen zu Unit Tests

Extbase gibt die Struktur wie bzw. wo Unit Tests erstellt werden müssen genau vor. Zuerst muss im Root-Verzeichnis der Extension ein Ordner mit dem Namen Tests erstellt werden. Darin werden später alle Test-Klassen erstellt.

Idealerweise legt man die Test-Klassen in der gleichen Ordner-Struktur ab, wie dies im Classes-Verzeichnis der Fall ist. Dies hilft zur Übersicht über die verschiedenen Test-Klassen.

Die Struktur könnte dann folgendermassen aussehen:

Eine Testklasse (auch Test-Suite genannt) beinhaltet eine Sammlung von Tests. Die Datei dafür muss immer nach dem Muster *Test.php benannt werden.

Was wird getestet?

Grundsätzlich sollte es genügen das öffentliche Interface, sprich alle public Methoden, im Code zu testen. Dies kann zuerst etwas verwirrlich sein, da sich die eigentliche Businesslogik häufig in den protected oder private Methoden befindet.

Es ist aber so, dass die versteckten Methoden grundsätzlich immer von den öffentlichen Methoden aufgerufen werden und diese somit mit einem zugehörigen Unit Test ebenfalls getestet werden.

Domain-Klassen testen

Die meiner Meinung nach am einfachsten zu testenden Klassen in einer Extbase Extension sind die Domain-Klassen. Man kann sich dabei die Frage stellen, ob man diese überhaupt testen sollte, da sie häufig lediglich über getter- und setter-Methoden verfügen.

Ob man diese testen will, ist jedem selbst überlassen. Man sollte sie aber auf jeden Fall testen, sobald man die getter- bzw. setter-Methoden modifiziert. Dies kann beispielsweise der Fall sein, wenn man beim ersten Aufruf einer getter-Methode auf dem Attribut immer einen Defaultwert setzen will.

Etwas was man in Domain-Klassen sicherlich testen sollte, sind öffentliche (public) Methoden, welche beispielsweise ein Resultat basierend auf mehreren Attributen zurückgeben. Ein Beispiel dafür könnte eine toString()-Methode sein, welche ein Domänenobjekt als String ausgibt.

Hier ein Biespiel eines Domain-Klassen Tests:

class Tx_MyExt_Domain_Model_ServiceTest extends Tx_Extbase_Tests_Unit_BaseTestCase { /** * Fixture * @var Tx_MyExt_Domain_Model_Service */ protected $domain; public function setUp() { $this->domain = $this->objectManager->get('Tx_MyExt_Domain_Model_Service'); } public function tearDown() { unset($this->domain); } /** * @test */ public function getActiveDaysReturnActiveDays() { $this->domain->setMonday(TRUE); $this->domain->setTuesday(FALSE); $this->domain->setWednesday(TRUE); $this->domain->setThursday(FALSE); $this->domain->setFriday(FALSE); $this->assertSame( array( 'monday' => 'monday', 'wednesday' => 'wednesday' ), $this->domain->getActiveDays() ); } }

In diesem Beispiel wird das Domainmodel Service getestet. Dazu definiert man eine Klasse Tx_MyExt_Domain_Model_ServiceTest welche von Tx_Extbase_Tests_Unit_BaseTestCase erbt.

class Tx_MyExt_Domain_Model_ServiceTest extends Tx_Extbase_Tests_Unit_BaseTestCase {

Diese Vererbung muss immer erfolgen, da sie Extbase-spezifische Elemente in unserer Testklasse einbringt. Zum Einen wird dabei der Extbase ClassLoader erstellt um Abhängigkeiten aufzulösen. Zum Anderen erhalten wir eine Instanz des ObjectManagers, welchen wird zur Erstellung von Objekten innerhalb unserer Testklasse verwenden können.

Nun wird die Variable $domain bereitgestellt, welche später das eigentliche Objekt beinhaltet, welches wir testen wollen. Dieses Objekt stellt das sogenannte Fixture unserer Testklasse dar. Weitere Informationen zu Fixtures finden sich direkt in der PHPUnit Dokumentation.

/** * Fixture * @var Tx_MyExt_Domain_Model_Service */ protected $domain;

Das Erstellen genau dieses Objektes ist häufig der schwierigste Teil beim Schreiben eines Unit Tests. Das Objekt soll nämlich beim ausführen eines Tests genau so initialisiert sein, wie es auch im Betrieb der Extension der Fall ist. Wir werden diese Problematik beim Testen einer Controller-Klasse sehen. Für ein einzelnes Domänenobjekt stellt dies aber noch kein Problem dar, da es genügt dieses lediglich über den ObjectManager zu laden.

public function setUp() { $this->domain = $this->objectManager->get('Tx_MyExt_Domain_Model_Service'); }

Das Fixture-Objekt wird häufig in der setUp()-Methode vorbereitet und in der tearDown()-Methode wieder in den Originalzustand gebracht. Die setUp()-Methode wird vor jedem Test ausgeführt - die tearDown()-Methode nach jedem Test. So kann sichergestellt werden, dass jeder Test in der exakt gleichen Umgebung ausgeführt wird.

In der tearDown()-Methode wird im Falle eines Domänenobjekt-Testes lediglich unser Service-Objekt gelöscht.

public function tearDown() { unset($this->domain); }

Das wichtigste an unserer Test-Klasse folgt aber erst jetzt. Nun können nämlich Test-Funktionen und wenn nötig zusätzliche Helper-Funktionen implementiert werden.

/** * @test */ public function getActiveDaysReturnActiveDays() { $this->domain->setMonday(TRUE); $this->domain->setTuesday(FALSE); $this->domain->setWednesday(TRUE); $this->domain->setThursday(FALSE); $this->domain->setFriday(FALSE); $this->assertSame( array( 'monday' => 'monday', 'wednesday' => 'wednesday' ), $this->domain->getActiveDays() ); }

Damit der Test auch als solcher erkannt wird, muss man ihn mit der Annotation @test versehen. In diesem Beispiel wird die Methode getActiveDays() unserer Service-Klasse (Fixture) getestet.

Zum Verständnis: Die Service-Klasse hat Boolean-Attribute für jeden Wochentag, welche angeben wann dieser Service zur Verfügung steht. Die getActiveDays()-Methode liefert nun ein Array zurück mit den Namen aller aktivierten Tagen.

Dies prüfen wir indem wir zuerst unser Fixture in den gewünschten Zustand bringen, sprich die Tage so setzen wie wir es wollen. Danach können wir mit einem Assert prüfen, ob unsere Methode das gewünschte Resultat zurückliefert.

Geschafft!

Das wars auch schon. Wir haben unsere erste Testklasse erstellt und können diese im PHPUnit Backend-Modul ausführen.

Auf das Testen von Validatioren, Repositories und vor allem Controllern werde ich in den nächsten Teilen eingehen.

Zu den anderen Teilen:

Teil 1: Einstieg

Teil 2: Validatoren und Repositories

Teil 3: Controller

[juerghunziker]

TYPO3 Extbase: Sortierung von verschachtelten Datensätzen im Frontend

Häufig werden Domänenobjekten weitere Domänenobjekte als Property angehängt. Falls eines dieser Properties vom Typ ObjectStorage ist (also eine Sammlung von mehreren Objekten), werden diese Objekte beim Laden der Hauptklasse über dessen Respository automatisch aus der Datenbank gelesen und zur Verfügung gestellt.

In Fluid kann man über diesen ObjectStorage iterieren und die untergeordneten Objekte ausgeben. Ein Problem dabei stellt die Sortierung der einzelnen Objekte dar. Diese sind nämlich standardmässig nach deren UID geordnet.

Falls man sie nach einem anderen Attribut sortieren will, muss man dieses in der TCA-Definition der Hauptklasse festlegen (Nicht wie zu erwarten wäre im Repository des entsprechenden Domänenojektes).

Mit der foreign_sortby Option lässt sich das Attribut nach dem die Datensätze sortiert werden festlegen.

Im folgenden Beispiel können einem Ordering-Domainobjekt mehrere Service-Domainobjekte im Property services zugewiesen sein. Diese sollen über das Attribut sorting sortiert werden.

$TCA['tx_myext_domain_model_ordering'] = array(     ...     'columns' => array(         'services' => array(             'exclude' => 0,             'label' => 'LLL:EXT:myext/Resources/Private/Language/locallang_db.xml:tx_myext_domain_model_ordering.services',             'config' => array(                 'type' => 'inline',                 'foreign_table' => 'tx_myext_domain_model_service',                 'foreign_field' => 'ordering',                 'foreign_sortby' => 'sorting',                 'maxitems' => 9999,                 'appearance' => array(                     'collapseAll' => 0,                     'levelLinksPosition' => 'top',                     'showSynchronizationLink' => 1,                     'showPossibleLocalizationRecords' => 1,                     'showAllLocalizationLink' => 1                 ),             ),         ),     ),     ... );

[juerghunziker]

NetBeans: Branch-Namen neben Projekt anzeigen

Um den Namen des aktuellen Branches neben dem Projekt anzuzeigen muss man lediglich im Menü View den Punkt Show Versioning Labels aktivieren.

Quelle: http://netbeans.org/projects/versioncontrol/lists/git/archive/2012-06/message/39

[juerghunziker]

NetBeans: Versteckte (.) Files anzeigen

In NetBeans werden standardmässig versteckte (.)-Files (Bsp.: .gitignore) ausgeblendet. Um diese anzuzeigen muss folgendermassen vorgegangen werden:

Tools > Settings

Unter Miscellaneous > Files findet man das Ignored Files Pattern

Dieses sieht im Original folgendermassen aus: ^(CVS|SCCS|vssver.?\.scc|#.*#|%.*%|_svn)$|~$|^\.(?!htaccess$).*$

Mit dem letzten Eintrag "|^\.(?!htaccess$).*$" werden Dateien oder Ordner, welche mit einem . beginnen ausgeblendet.

Sobald dieser Eintrag entfernt wurde, werden im Projektbrowser auch Files und Ordner, welche mit . beginnen angezeigt.

Das neue Pattern sollte wie folgt aussehen: ^(CVS|SCCS|vssver.?\.scc|#.*#|%.*%|_svn)$|~$ 

Anleitung basiert auf NetBeans 7.2

Quelle: http://mrhaki.blogspot.ch/2008/06/display-hidden-dot-files-and.html

[juerghunziker]

NetBeans: UI Sprache anpassen

Eigentlich könnte man ja bei einem Programm wie NetBeans erwarten, dass man die Sprache über das Einstellungs-Menü anpassen kann. Leider ist dies nicht der Fall. Hier eine kurze Anleitung wie man vorgehen muss, um die Sprache der Oberfälche auf Englisch umzustellen:

Öffne folgendes File: C:\Program Files\NetBeans X.Y\etc\netbeans.conf

Darin muss man den Parameter netbeans_default_options="..." suchen

Zu dieser Konfiguration muss folgende Zeichenkette angehängt werden: " -J-Duser.language=en -J-Duser.region=US"

Die Zeile sollte nun in etwa so aussehen: netbeans_default_options="-J-client -J-Xss2m -J-Xms32m -J-XX:PermSize=32m -J-Dapple.laf.useScreenMenuBar=true -J-Dapple.awt.graphics.UseQuartz=true -J-Dsun.java2d.noddraw=true -J-Dsun.zip.disableMemoryMapping=true -J-Duser.language=en -J-Duser.region=US" 

Bein nächsten Start von NetBeans erscheint die Oberfläche in Englischer Sprache

Anleitung basiert auf NetBeans 7.2

Quelle: https://blogs.oracle.com/tao/entry/set_netbeans_user_interface_language

[juerghunziker]

[juerghunziker]

Wikipedia Artikel mit BibTeX-Eintrag zitieren

Wikipedia bietet ein ganz nettes Feature, um Artikel direkt im BibTeX-Format zitieren zu können.

Dazu öffnet ihr einen Artikel und wählt in der linken Spalte unterhalb von Werkzeuge den Eintrag Seite zitieren.

Wikipedia generiert nun automatisch einen BibTeX-Eintrag, welchen ihr als Quellenangaben in euren LaTeX Dokumenten verwenden könnt.

[juerghunziker]

Google Chrome: Tab-Vorschau in Windows 7 aktivieren

EDIT 27.06.2012:

Diese Feature wurde leider in der Version 20 des Chrome Browsers entfernt: http://code.google.com/p/chromium/issues/detail?id=8036#c119

Original Post:

Euch ist vielleicht auch schon aufgefallen, dass Google Chrome standardmässig keine Tab-Vorschau in der Taskliste von Windows 7 bietet (vgl. Internet Explorer 9). Dies lässt sich aber ziemlich einfach aktivieren.

Google Chrome schliessen

Shift + Rechtsklick auf das Google Chrome Symbol in der Taskliste -> Eigenschaften

Am Ende der Zeile "Ausführen in:" muss folgender Parameter hinzugefügt werden:  -enable-aero-peek-tabs 

Fertig! Beim nächsten Öffnen des Browsers habt ihr die Tab-Vorschau aktiviert.

Quelle: http://www.sync-blog.com/sync/2010/06/windows-7-tutorial-how-to-enable-tab-preview-in-google-chrome.html

[juerghunziker]

Eigenen Suchanbieter zu Internet Explorer 9 hinzufügen

Beim Neuaufsetzen meines Laptops musste ich feststellen, dass es anscheinend nicht mehr einfach möglich ist einen eigenen Suchanbieter zum Internet Explorer 9 hinzuzufügen.

Dies war jeweils nötig, wenn man google.ch als Suchmaschine verwenden wollte, welche in den angebotenen Standard-Suchmaschinen nicht aufgeführt wird.

Nach einigen Minuten googlen fand ich dann doch noch eine Lösung welche zu funktionieren scheint:

http://www.enhanceie.com/ie/SearchBuilder.asp

Auf dieser Webseite ist es möglich manuell einen Suchanbieter zum Internet Explorer hinzuzufügen.

[juerghunziker]

Neuen Blog erstellt

Nun habe ich es endlich auch geschafft und mir einen Blog erstellt. Sind diese "Blogs" überhaupt noch in Mode? Egal... In diesem Blog werde ich Tutorials und Tipps zu allen möglichen Themen im Bereich Webdesign und co. posten. Dies ist jedenfalls mein Ziel (mal sehen was dabei rauskommt).

Nun wünsche ich euch schon mal ein frohes neues Jahr und viel Spass mit diesem Blog (wenn er dann Inhalt hat)! 

PS: Es ist schon erstaunlich was das Internet alles zu bieten hat, wenn man für Prüfungen lernen sollte.