Freie Grafik: Umzug der Webseite Reiner`s Tilesets

Reiner Prokein hat mit den freien Grafiken auf seiner Webseite schon vielen Hobby-Entwicklern von Spielen das Leben erleichtert. Wer hatte nicht schonmal eine zündende Spielidee, jedoch keinen fähigen Grafiker zur Hand? Mir passierte dies leider viel zu oft, weshalb ich hiermit auf eine tolle Sammlung von Texturen, Sprites und Animationen aufmerksam machen möchte, die selbst vor 3D-Modellen keinen Halt macht:

http://www.reinerstilesets.de/

Viel Spaß beim Stöbern auf der Webseite.

PS: Für mein neues Buch hat mir Reiner die Grafiken zu den Beispielen geliefert, wofür ich mich hiermit nochmal rechtherzlich Bedanken möchte.

TinyMCE-API: Commands per JavaScript im WYSIWYG-Editor

Die API des WYSIWYG-Editors TinyMCE ist zwar umfangreich, jedoch recht unübersichtlich. Möchte man von außen per JavaScript einige Commands ausführen, findet man dazu in der API folgende Hilfe:

http://tinymce.moxiecode.com/wiki.php/API3:method.tinymce.execCommand

Allerdings ist die Liste der Commands, die hier leider nicht verlinkt wurde, ein absolutes Muss, weil sie einem Entwickler diverse Möglichkeiten zur Interaktion mit dem Editor aufweist. Der Link innerhalb der Referenz ist folgender:

http://tinymce.moxiecode.com/wiki.php/Command_identifiers

Per JavaScript kann man jetzt folgenden Beispielcode verwenden, um ein Bild an die markierte stelle einzufügen:

tinyMCE.activeEditor.execCommand('mceReplaceContent',false,
'<img src="/myFolder/myImage.jpg" />');

Intermedia Fotoficient: Relaunch der Webseite

Pixelboxx hat diese Woche die neue Webseite von Intermedia Fotoficient ins Netz gestellt. In Kürze werden auch die deutschen Seiten online gestellt, bisher gibt es (wie auch auf der alten Homepage) nur englische Texte. Die Webseite glänzt durch das helle und freundliche Design, durch welches die einzelnen Themenbereiche sehr übersichtlich präsentiert werden.

Link zum neuen Webauftritt von Intermedia Fotoficient

JavaScript: Einfaches 4-Gewinnt Spiel

An dieser Stelle möchte ich ein einfaches 4-Gewinnt Spiel vorstellen, dass ich als Basis für eine andere Webanwendung benötige. Dieses “Abfallprodukt” ist viel zu interessant, um es einfach zu löschen. Also kann man hier zu zweit ein wenig Spaß haben. Eine KI habe ich allerdings nicht implementiert. Wer möchte kann dies gerne selbst erstellen und mir den Code schicken. In diesem Fall würde ich die KI hier veröffentlichen:

Link zum Testspiel

Der JavaScript-Bereich in der Seite sieht folgendermaßen aus:

<script>
window.onload = function()
{
 var p1 = '#0000ff', p2 = '#ff0000', color = p1, gameOver = false;

 function attach(element, type, fn)
 {
   if(element.addEventListener)
   {
     element.addEventListener(type, fn, false);
   }
   else if(element.attachEvent)
   {
     element.attachEvent('on' + type, fn);
   }
 }

 function check4End(x,y)
 {
   var i, n, m, counter,
        checkColor = document.getElementById(x+'_'+y).getAttribute('title');

   function checkCounter(c)
   {
     if(c >= 4)
     {
       document.getElementById('infotext').innerHTML = '&nbsp;&nbsp;hat gewonnen';
       gameOver = true;
     }
   }

   //horizontal -----------------------
   counter = 0;
   for(i=0;i<7;i++)
   {
     if(document.getElementById(i+'_'+y).getAttribute('title') === checkColor)
     {
       counter++;
     }
     else
     {
       counter = 0;
     }

     checkCounter(counter);
   }

   //vertikal -----------------------
   counter = 0;
   for(i=0;i<6;i++)
   {
     if(document.getElementById(x+'_'+i).getAttribute('title') === checkColor)
     {
       counter++;
     }
     else
     {
       counter = 0;
     }

     checkCounter(counter);
   }

   //diagonal 1 -----------------------
   counter = 0;
   n = x;
   m = y;

   while(n>0 && m>0)
   {
     n--;
     m--;
   }

   for(i=0;i<6;i++)
   {
     if(document.getElementById(n+'_'+m))
     {
       if(document.getElementById(n+'_'+m).getAttribute('title') === checkColor)
       {
         counter++;
       }
       else
       {
         counter = 0;
       }

       checkCounter(counter);

       n++;
       m++;
     }
     else
     {
       break;
     }
   }

   //diagonal 2 -----------------------
   counter = 0;
   n = x;
   m = y;

   while(n>0 && m<5)
   {
     n--;
     m++;
   }

   for(i=0;i<6;i++)
   {
     if(document.getElementById(n+'_'+m))
     {
       if(document.getElementById(n+'_'+m).getAttribute('title') === checkColor)
       {
         counter++;
       }
       else
       {
         counter = 0;
       }

       checkCounter(counter);

       n++;
       m--;
     }
     else
     {
       break;
     }
   }

 }

 function init()
 {
   var n, el = document.getElementsByTagName('body')[0];

   document.getElementById('info').style.backgroundColor = color;

   for(n=0;n<el.childNodes.length;n++)
   {
     if(el.childNodes[n])
     {
       attach(el.childNodes[n], 'click', function() {

         if(gameOver === false)
         {
           var i, col = this.getAttribute('class').replace('col','');

           for(i=5;i>=0;i--)
           {
             if(document.getElementById(col+'_'+i).getAttribute('title') === '')
             {
               document.getElementById(col+'_'+i).style.backgroundColor = color;
               document.getElementById(col+'_'+i).setAttribute('title',color);
               if(color === p1)
               {
                 color = p2;
               }
               else
               {
                 color = p1;
               }
               break;
             }
           }

           check4End(col,i);

           if(gameOver === false)
           {
             document.getElementById('info').style.backgroundColor = color;
           }
         }

     });
   }
 }
}

init();
};
</script>

Die Styles sind relativ simpel und sollten so aufgebaut sein:

<style>
  .box
  {
    width:20px;
    height:20px;
    border:1px solid #000;
    margin:1px;
    float:left;
  }
  .clear
  {
    clear:both;
  }
</style>

Im Prinzip gibt es innerhalb des “window.load” nur drei Funktionen: die Hilfsfunktion “Attach”, mit der man neue Events anlegt, die Funktion “Check4End”, welche testet, ob ein Spiel zuende ist und die Funktion “init”, die alle Events setzt und somit das Spiel initial startet.
“Check4End” muss horizontal, vertikal und diagonal prüfen, ob eine Farbe vier in einer Reihe hat. Das ist auch schon die aufwändigste Funktion des ganzen Spiels, weil sie alle vorhandenen Reihen durchlaufen muss. Allerdings habe ich den Test auf die Reihe/Spalte der aktuellen Position beschränkt, damit etwas Geschwindigkeit eingespart werden kann.

Der BODY-Bereich hat folgenden Aufbau:

<div id="0_0" title=""></div>
<div id="1_0" title=""></div>
<div id="2_0" title=""></div>
<div id="3_0" title=""></div>
<div id="4_0" title=""></div>
<div id="5_0" title=""></div>
<div id="6_0" title=""></div>
<div></div>
<div id="0_1" title=""></div>
<div id="1_1" title=""></div>
<div id="2_1" title=""></div>
<div id="3_1" title=""></div>
<div id="4_1" title=""></div>
<div id="5_1" title=""></div>
<div id="6_1" title=""></div>
<div></div>
<div id="0_2" title=""></div>
<div id="1_2" title=""></div>
<div id="2_2" title=""></div>
<div id="3_2" title=""></div>
<div id="4_2" title=""></div>
<div id="5_2" title=""></div>
<div id="6_2" title=""></div>
<div></div>
<div id="0_3" title=""></div>
<div id="1_3" title=""></div>
<div id="2_3" title=""></div>
<div id="3_3" title=""></div>
<div id="4_3" title=""></div>
<div id="5_3" title=""></div>
<div id="6_3" title=""></div>
<div></div>
<div id="0_4" title=""></div>
<div id="1_4" title=""></div>
<div id="2_4" title=""></div>
<div id="3_4" title=""></div>
<div id="4_4" title=""></div>
<div id="5_4" title=""></div>
<div id="6_4" title=""></div>
<div></div>
<div id="0_5" title=""></div>
<div id="1_5" title=""></div>
<div id="2_5" title=""></div>
<div id="3_5" title=""></div>
<div id="4_5" title=""></div>
<div id="5_5" title=""></div>
<div id="6_5" title=""></div>
<div></div>
<br />
<div id="info"></div>
<span id="infotext">&nbsp;&nbsp;ist am Zug</span>

Die Felder habe ich alle von Hand angelegt, könnten aber auch in einer späteren Version dynamisch angelegt und mit Click-Event versehen werden. So könnte man auch dem Spieler eine Auswahl der Spielfeldgröße ermöglichen.

X3DOM: Einfache Implementierung von 3D per XML-Schnittstelle

Wer wollte nicht immer schon einmal eine tolle 3D-Anwendung mit rotierenden Planeten auf seine Webseite setzen? So ein Eye-Catcher muss nicht schwierig zu erstellen sein. Mit der auf WebGL basierenden Open-Source-Lösung X3DOM ist das kein Problem mehr.
Dieses kleine Beispiel soll etwas Licht ins dunkle All bringen. Hier der Link zum Live-Demo:

LAB-Schenk2000-X3DOM

Ihr solltet unbedingt mal die linke Maustaste gedrückt halten und die Maus bewegen oder das Mausrad testen. :-)

Quellcode
Als erstes benötigen wir ein bisschen Vorbereitung. Zum Beispiel müssen wir uns von der X3DOM-Webseite die entsprechende CSS- und JavaScript-Datei herunterladen oder diese einfach verlinken. Im Anschluss legen wir ein paar Styles für die Buttons fest und definieren eine JavaScript-Funktion, um die Position des zentralen Planeten zu manipulieren.

Hier der Code für den HEAD-Bereich der HTML-Datei:

<!-- CSS -->
<link rel="stylesheet" type="text/css" href="css/x3dom.css"></link>
<style>
    .clear
    {
        clear:              both;
    }
    .menu_bt
    {
        float:              left;
        border:             none;
        width:              3em;
        height:             2em;
        margin:             2px;
        background-color:   #555;
        color:              #ccc;
    }
    .menu_bt:hover
    {
        background-color:   #55f;
    }
</style>
<!-- JavaScript -->
<script type="text/javascript" src="js/x3dom.js"></script>
<script>
    var x = 0, y = 0, z = 0;

    function moveObj(addX,addY,addZ)
    {
        x = x + addX;
        y = y + addY;
        z = z + addZ;
        document.getElementById('t_earth').setAttribute('translation', x+' '+y+' '+z);
    }
</script>

Jetzt können wir uns die XML-Struktur von X3DOM etwas genauer anschauen. Die Ausmaße des x3d-Objektes legen wir zu Beginn fest, damit ein Canvas-Element erstellt wird, auf dem die Scene gezeichnet werden kann. Dies geschieht automatisch durch X3DOM, was viel Zeit und Arbeit einspart.

Insgesamt benötigen wir drei Grafiken für die Scene, eine Hintergrundgrafik (es dürfen auch mehrere sein) und je eine für Planet und Mond. Die Hintergrundgrafik(en) werden im Background-Tag definiert und die anderen beiden in den imageTexture-Tags.

Ich will jetzt nicht zu stark auf die einzelnen Attribute eingehen. Wer sich ein wenig mit XML und evtl. auch mit 3D-Anwendungen auskennt wird hier sofort alles wiedererkennen. Wichtig für die Darstellung der 3D-Objekte ist das Transform-Tag, indem alle Informationen übergeben werden. Es muss z.B. ein Shape- oder ein Box-Tag vorhanden sein, mit dem man die geometrische Grundform festlegen kann. Mit dem Material-Tag kann man sehr leicht Füll- und Reflektionsfarbe festlegen.

Hier der Quellcode des Beispiels für den BODY-Bereich des HTML-Dokuments:

<x3d width="400px" height="400px">
<scene>
<background backUrl="img/the_space.jpg" bottomUrl="img/the_space.jpg"
frontUrl="img/the_space.jpg" leftUrl="img/the_space.jpg"
rightUrl="img/the_space.jpg" topUrl="img/the_space.jpg">
</background>
<transform def="earth" translation="0 0 0" scale="1.25 1.25 1.25" id="t_earth">
<shape id="s_earth">
<appearance>
<material id="mat" diffuseColor="1 1 1" specularColor=".2 .2 .2"></material>
<imageTexture url="img/planet_jupiter.jpg"></imageTexture>
</appearance>
<sphere def="geo"></sphere>
</shape>
</transform>
<transform def="moon" translation="8 0 0" center="-8 0 0" scale="0.35 0.35 0.35" id="t_moon">
<shape id="s_moon">
<appearance>
<material use="mat"></material>
<imageTexture url="img/planet_lava.jpg"></imageTexture>
</appearance>
<sphere use="geo"></sphere>
</shape>
</transform>
<DirectionalLight direction='0 -1 0' intensity="0.3"></DirectionalLight>
<TimeSensor DEF='TS_erde' cycleInterval='5' loop='true'></TimeSensor>
<OrientationInterpolator DEF='OI_erde' key='0, 0.5, 1' keyValue='0 1 0 0, 0 1 0 3.14, 0 1 0 6.28'></OrientationInterpolator>
<ROUTE fromNode='TS_erde' fromField='fraction_changed' toNode='OI_erde' toField='set_fraction'></ROUTE>
<ROUTE fromNode='OI_erde' fromField='value_changed' toNode='earth' toField='set_rotation'></ROUTE>
<TimeSensor DEF='TS_mond' cycleInterval='27' loop='true'></TimeSensor>
<OrientationInterpolator DEF='OI_mond' key='0, 0.5, 1' keyValue='0 1 0 0, 0 1 0 3.14, 0 1 0 6.28'></OrientationInterpolator>
<ROUTE fromNode='TS_mond' fromField='fraction_changed' toNode='OI_mond' toField='set_fraction'></ROUTE>
<ROUTE fromNode='OI_mond' fromField='value_changed' toNode='moon' toField='set_rotation'></ROUTE>
</scene>
</x3d>
<div></div>
<button onclick="moveObj(1,0,0);return false;">X+1</button>
<button onclick="moveObj(-1,0,0);return false;">X-1</button>
<button onclick="moveObj(0,1,0);return false;">Y+1</button>
<button onclick="moveObj(0,-1,0);return false;">Y-1</button>
<button onclick="moveObj(0,0,1);return false;">Z+1</button>
<button onclick="moveObj(0,0,-1);return false;">Z-1</button>

Viel Spaß beim Basteln.

Messebilder: CeBit 2011 in Hannover

Ja, auch ich war auf der CeBit 2011 in Hannover – und zwar am Donnerstag den 3. März. Neben mir waren noch ein oder zwei weitere Besucher auf dieser gigantischen Messe, die sich über ca. 20 Hallen verteilte. Eigentlich wollte ich so lange nach der CeBit keinen Messebericht abliefern. Das wäre ja auch nach einer Woche ein alter Hut, außerdem gibt es tausend andere Messeberichte, die sicherlich ausführlicher sind, als es mein eigener wäre. Aber dennoch möchte ich zumindest ein paar Bilder von der Messe hier zeigen, die ich selbst geschossen habe.

Ein kleiner Shopping Basket

Wörter auf Wasser projeziert

Ein E-Smart

So macht Formel 1 Spaß – passt auch sicher in mein Wohnzimmer

Clanspiele auf der Bühne

Der Google Maps Vortrag fiel wegen mangelnder Internetverbindung sehr kurz aus

Ein Fußball-Bot

Der sprechende, singende und gestikulierende Robot

CSS: Less Framework 4 – Stolpersteine für Umsteiger

Die neue Version 4 von Less Framework ist erschienen und birgt für Entwickler, die von Version 3 umstellen möchten, einige Stolpersteine. Eine Neuerung beinhaltet, dass die Aufteilung der vier wichtigen Layouts geändert wurde. Wer also seine eigene Seite auf die Pixelmaße der alten Layouts aus Version 3 abgestimmt hat, wird diese neu anpassen müssen. Der wichtigste Hinweis ist aber, dass sich die Reihenfolge der Layouts in der CSS Datei geändert hat. Das Basislayout ist in der Version 4 das größte Layout und nicht mehr das zweitgrößte. Aufgrund der Tatsache, dass die Layouts aufeinander aufbauen, ist das eine elementare Änderung, die etwas Umstrukturierung erfordert.

Intermedia Fotoficient läd Bilder schneller als sein Schatten

Mit Intermedia Fotoficient bietet Pixelboxx eine extrem schnelle Möglichkeit, Bilder schnell an Webapplikationen auszuliefern. Dabei spielt es keine Rolle, ob es sich um eine normale Webseite oder einen Webshop handelt. Dieser Beitrag soll zeigen, wie der Intermedia Fotoficient Server Bilder im (mit Caching auch einstelligen) Millisekundenbereich ausliefert und wie Webseiten davon profitieren können.

Dynamisch erstellte Bilder werden aktuell im Internet nicht überwiegend genutzt. Das Problem liegt an der Performance, einzelne Bilder “on the fly” zu berechnen und in einem passenden Zeitrahmen auszuliefern. In den meisten Fällen werden (z.B. in CMS Systemen) Bilder in diversen Auflösungen einfach vorberechnet und in allen evtl. benötigten Formaten auf den Server gelegt.

Unsere kleine aber rasannte Reise in die Welt der dynamisch erstellten Internetbilder erfolgt in vier Schritten:

  • 1. Schnelle Pixel-Transformation
  • 2. Effiziente Kommunikation
  • 3. Auf ein Minimum redizierte Dateigröße
  • 4. Effektive Seitenberechnung

1. Schnelle Pixel-Transformation

Schnelle dynamische Bilder benötigen schnelle Pixel-Transformationen – das ist offensichtlich. Aber was macht diese Pixel-Transformationen schnell?

Die Intermedia Fotoficient Transformations-Engine ist flink wie ein Wiesel
Als die Transformations-Engine konzipiert wurde, lag die Priorität der Entwicklung auf der Geschwindigkeit. Intermedia liefert ein Bild schneller aus, als der Apache Webserver eine statische Datei ausliefern kann. Aber was sind die Geheimnisse dieser Architektur?

Weniger ist mehr
Intermedia verwendet einen sehr effizienten internen Speicher und Caching Mechanismus. Wir speichern nicht nur die generierten Ergebnisse, sondern auch Zwischenschritte, die auf Bildfragmenten beruhen. Dies sind gute Ausgangspositionen, sollte eine leicht abgewandelte Version eines Bildes benötigt werden. Keine Operation mit einem Bild ist isoliert von einer anderen im Intermedia Framework.

Der Client ma(h)lt zuerst
Im Gegensatz zu diversen anderen Bildtransformations-Frameworks, übergibt Intermedia zuerst die Daten (per Filestream) an den Client (jpeg, gif, png, xml oder json), bevor es die Daten in den Cache schreibt. Auf diese Weise muss der Client nicht darauf warten, dass Intermedai die Daten in den Speicher geschrieben hat. Die meisten anderen Frameworks prodizieren zuerst die lokale Datei mit den Transformationen und liefern erst im Anschluss den Inhalt aus. Sich auf den lokalen Chache zu verlassen ist ein Fehler, weil andere Prozesse auf dem Server diesen ausbremsen können. Intermedia hat interne, speicherbasierte PixelProcessoren, die keinerlei Dateien für die Transformationen benötigen.

Pixel wiederverwerten
Speicher und Cache verwalten nicht nur die fertigen Bilder, sondern auch die Zwischenschritte. Durch eine Prüfung, welcher Teil der Transformation wieder benötigt wird, verwenden wir die Pixel erneut für grundliegende Transformationen.

2. Effiziente Kommunikation

Weil das HTTP Protokoll sehr gesprächig ist, zählt jedes Byte. Vergessen Sie nicht, dass Requests ein Teil des Auslieferungsprozesses sind. Je kleiner der Request, umso schnelle die Auslieferung.

Eine magische Wand heißt MTU (maximum transfer unit) des TCP Protokolls. Bei Ethernet/DSL basierten Medien hat die MTU eine Größe von 1400 Bytes. Ist ein HTTP Request größer als 1400 Bytes, muss TCP den Request in mehrere Packete aufteilen. Das hört sich erst einmal nicht schlimm an, verlangsamt allerdings den Prozess.

Ein einfacher Request für ein Bild muss nicht größer als 1400 Bytes sein. Dieser besteht aus ein paar Headern:

  • Pfad
  • Host
  • Connection

Weitere sind nützlich für den Bild Request:

  • Accept
  • Accept-Encoding
  • Accept-Language
  • User-Agent

Folgende Header sind für den Bild Request nutzlos, werden aber trotzdem übertragen:

  • Accept-Charset

Einer der größten Header ist der Cookie. Wenn die eigene Applikation keine Informationen aus dem Cookie benötigt, setzt man einfach den Bildserver in eine andere Domain, um den Cookie zu umgehen.

Hinweis:
Jeder dieser Header wird bei jedem einzelnen Request verwendet und belegt diverse Bytes. Intermedia reduziert die Header bei der Antwort auf diese Requests auf ein Minimum.

Beispiel, bei dem nur der Server optional ist:

HTTP/1.1 200 OK
Server: Intermedia Fotoficient
Date: Tue, 28 Dec 2010 20:55:24 GMT
Expires: Tue, 28 Dec 2010 21:55:24 GMT
Cache-Control: max-age=3600, public, must-revalidate
Content-Type: image/png
ETag: "f2ebe9b7332cc739fdf103609872685b"
Content-Length: 9802

3. Auf ein Minimum redizierte Dateigröße

Ein Bild besteht nicht nur aus Pixeln. Alle Bildformate unterstützen Header bzw. Metadaten. Das JPEG Dateiformat ist das Format mit dem höchsten Verbrauch an unnötigen Daten. JPEG, PNG und GIF Dateien haben einen Header, welcher für Textinformationen bzw. Kommentare reserviert ist. Intermedia übernimmt die Kontrolle über dieses Feld und setzt die Informationen über die Quelle so kurz wie möglich. Bei JPEG Dateien gibt es noch andere Informationen, die möglicherweise eingebunden sind: IPTC, EXIF, XMP und ICC/colormanagement. Diese verbrauchen evtl. einige Kilobyte an Speicher. Speziell der XMP Teil wird mit Daten regelrecht zugepflastert (machmal mit bis zu 32 Kilobyte). Wenn man sich eine Thumbnail-Bildvorschau eines Produktbilder in einem Webshop anschaut, hat dies in einigen Fällen nur 2 Kilobyte an Bilddaten, aber 32 Kilobyte an Metadaten. Intermedia generiert Bilddaten, die nur die nötigen Pixelinformationen inkl. des oben genannten Inhalts. Das Orginalbild inkl. aller Metadaten bleibt natürlich unangetastet.

4. Effektive Seitenberechnung

Um Bilder im Internet darzustellen benötigt man Webseiten, die diese Bilder referenzieren. Wie kann Intermedia dabei helfen, diesen Mechanismus effizienter zu nutzen? Intermedia verwendet kurze URLs, die leicht gecached werden können. Es wird immer eine kurze ID (shortkey id) für ein Bild verwendet, um keinen einzigen Buchstaben in der URL zu verschwenden. Sämtliche URLs sind kurz aber dennoch lesbar.

Mit dem Bootloader kann man Ansammlungen von Bildern in RIA-Widgets verwenden und auf diese Weise eine große Anzahl von Bildern in einem einzigen Request zu verarbeiten (Voraussetzung hierfür ist ein moderner Browser). Wenn diese Technik richtig eingesetzt wird, kann man den Seitenaufbau um Faktor 2 beschleunigen.

Zur Webseite von Intermedia Fotoficient

Neues Release von Intermedia Fotoficient (v1.2.80320)

Das erste Release von Intermedia Fotoficient im noch jungen Jahr 2011 ist online. Diverse Neuerungen sind in das Release eingeflossen. Hier eine kleine Übersicht über alle Änderungen:

Neue Features

  • Die SilderGallery inkl. automatischer Animation, welche sich auch für 360 Grad Produktpräsentationen eignet
  • Dokumentation: WebSphere Integrationen
  • Dokumentation: WordPress Integrationen

Änderungen

  • Der Intermedia Cache wurde verbessert
  • Die Behandlung der FileHandler wurde verbessert
  • Neue Übersichtsseite für die Galerien wurde integriert
  • Performance des Folderscans der Datenquelle wurde verbessert

Eigehen möchte ich an dieser Stelle hauptsächlich auf die neue SliderGallery, die mittlerweile mein absoluter Favorit ist. Diese Galerie holt sich vom Intermedia Fotoficient Server die Bilder mit einer einzigen Connection (JSONP), wodurch sich sämtliche Bilder im Speicher befinden, sobald die Galerie vollständig geladen wurde. Dies hat zur Folge, dass man ruckelfreie Animationen erstellen kann, ohne ein Nachladen zu erzwingen. Außerdem sind damit Animationen ganz ohne Flash-Plugin möglich. Die Konfigurationsmöglichkeiten reichen von der Anzeige des Sliders bzw. des AnimationsButtons bis hin zum Autostart der Animation oder zum Einstellen des Animationsintervals.

An dieser Stelle möchte ich auf die Demoseite von Intermedia Fotoficient und auch auf meinen älteren Blogeintrag über die SliderGallery verweisen:

Joomla: Neuer Header für das ja_purity Template

Letzte Woche habe ich an einer Joomla-Webseite diverse CSS-Änderungen vorgenommen, um diese Seite der Designvorlage anzugleichen. Die Basis war das ja_purity-Template von JoomlArt.com, welches sich scheinbar nicht für den Internet Explorer 7 eignet. Zumindest der Header der Seite war definitiv nicht das, was andere Browser darstellten. Der Header besteht, neben einem H1 mit Link und einem Logo im Hintergrund, aus einer Tabelle, in welcher die Kontakt-Links eingesetzt werden. Kurzerhand habe ich Header neu erstellt und diesen etwas übersichtlicher gestaltet:

<div id="logo_new">
    <img src="/templates/ja_purity/images/logo.png" alt="" />
    <div id="logo_title">Titel der Webseite</div>
    <div id="logo_links">
        <a href="#">Kontakt</a>
        <span>  - </span>
        <a href="#">Impressum</a></div>
    </div>
</div>

Verwundert war ich über den PHP-Code direkt im Template. Meine Idee von einem CMS war bisher immer, dass man nicht gleich PHP-Entwickler sein muss, um ein Template zu ändern.
Die Links innerhalb des letzten DIVs werden so wie sie sind von Joomla in die Seite gesetzt. Wichtigster Part ist das umliegende DIV, indem die DIVs und das Image ganz ungestört “floaten” können. :)

Der CSS-Teil ist ebenfalls sehr übersichtlich:

#logo_new
{
    padding:        30px;
    margin:         0px;
    width:          770px;
    height:         41px;
}
#logo_new img
{
    float:          left;
}
#logo_title
{
    margin-left:    20px;
    float:          left;
    color:          #9D9D9C;
    font-size:      20px;
    line-height:    45px;
    font-weight:    bold;
}
#logo_links
{
    margin-top:     10px;
    float:          right;
    color:          #999;
    font-size:      11px;
}
#logo_links a
{
    text-decoration:none;
}
#logo_links a:hover
{
    color:          #000;
}

Interessant war die Tatsache, dass die template.css mehr als 1500 Codezeilen hat. Das halte ich für extrem übertrieben und ist mir bisher für ein “einfaches” Template in der Form noch nicht unter die Augen gekommen. Meine Empfehlung: ein Joomla-Template auf Basis eines CSS-Frameworks erstellen.