InfoVis ermöglicht das Darstellen interaktiver, dynamischer Graphen und Baumdiagramme. Das hört sich genial an und sieht in der Praxis noch viel besser aus.

In der nun vorliegenden Version 1.1. wurde die Bibliothek in einzelne Module unterteilt um die Wiederverwendbarkeit des Quellcodes zu erhöhen.

Zudem kann man nun mehrfache Instanzen einer jeden Animation erzeugen. Dadurch können nun die Darstellungsformen kombiniert und hintereinander ausgeführt werden.

InfoVis arbeitet mit jeder Javascript-Bibliothek zusammen, egal ob jQuery, Prototype, YUI, MooTools usw, InfoVis lässt sich zusammen mit allen nutzen.

Vorhandere Klasse können leicht verändert und erweiteret werden, außerdem lassen sich eigene Animation erstellen. Die Möglichkeiten sind grenzenlos.

Eine erstklassige Dokumentation und viele Beispiele sind auf der Entwickler-Seite für jedermann zugänglich.

Im Vergleich zur Version 1.0.1, über die wir im Oktober des vergangenen Jahres berichtet hatten, ergeben sich nachfolgende Änderungen und Neuerungen:

• zusätzliche onClick-Option öffnet Bilder in einem neuem Fenster
• Überarbeitung der Evaluierung der individuellen Einstellungen
• Pfeiltasten werden nun in allen Browsern unterstützt, jedoch nur in einer Imageflow-Instanz
• zusätzliche Option scrollbarP (Breite des Scrollbalken in Prozent)
• Fehlerbehebung in der Option imageFocusM in Firefox und Safari
• unload-Fehler im Internet Explorer gefixt
• Verbessertes Bild-Resampling im IE7
• zusätzliche Option aspectRatio zum Anpassen des Verhältnisses von Höhe und Breite des ImageFlow-Containers
• zusätzliche Option zum Festlegen der Bildausmaße: imagesHeight, imagesM, percentOther und percentLandscape

Viel Spaß beim Einbauen. Wir helfen euch auch gern dabei!

Auffälligste Neuerung ist die Unterstützung des IE8. Da der neuste Redmonder Sprößling in Sachen VML etliches anderes handhabte als die Vorgänger, hatten die Explorer Canvas-Entwickler etliches zu tun um ihre Bibliothek für den IE8 fit zu bekommen.

Zusätzlich wurden eine Vielzahl Fehler behoben und einige Funktionen erweitert und beschleunigt. Die Änderungsliste fällt umfangreich aus:

• die Methoden transform und setTransform wurde nach HTML5-Standard integriert
• der aktuelle Pfad wird bei strokeRect, fillRect und clearRect nun stets korrekt entfernt
• vollständige Unterstützung des IE8 in allen Modi
• diverse Fehler in linearen Farbverläufen behoben
• neue, erweiterte Methode zur Berechnung der Linienstärke
• Rendern von Linien mit einer Stärke kleiner 1px sehen besser aus
• stroke-Methode ignoriert nun nicht mehr lineCap, lineJoin and miterLimit, falls fillStyle-Attribut gesetzt wurde
• stroke schließt nun nicht mehr automatisch den Pfad
• strokeRect und fillRect schließt nun stets korrekt den Pfad
• Einbau des document.createElement(‘canvas’)-Hacks von Sjoerd Visscher
• diverse Speicherlecks wurden gefixt

Zur Umsetzung nutzte er lediglich einige Grafiken, simples JavaScript und das Anwenden von Trigonometrie in der Praxis.

Um das Gimmick im eigenen Projekt zu nutzen, müssen die Datei eyes.js eingebunden, die Augen-Bilder eingebaut und die Funktion aufgerufen werden. Beispielsweise wie folgt:

<script type="text/javascript" src="eyes.js"></script>
<div id="myEye" style="width: 100px; height: 100px; background: url('white.png') center center no-repeat;">
<img src="pupil.png" width="30" height="30" />
</div>
<script type="text/javascript">
EYES.follow ('myEye');
</script>

Viel Spaß damit!

Solche Weichen werden im Alltag immer wieder gebraucht, um speziellen Browser Extraanweisungen mitzugeben.

Als kürzeste Variante setzte sich der nachfolgender Code durch, der nur im IE (einschließlich “true” zurückliefert, in allen anderen Browsern “false” zurückgibt.

IE="\v"=="v" // true only in IE

Damit zog diese Variante an dem zuvor favorisierten, nachfolgenden Code vorbei:

try{IE=window=!1}catch(e){IE=!0}

Bei der Suche noch dem besten und ultimativen Ansatz habe ich etliche interessante Projekte ausprobiert.

Vier Lösungsansätze möchte ich hier genauer vorstellen und auf den Einbau und deren Funktionsweise eingehen. Zusätzliche werde ich noch ein paar Alternativen nennen.

jQuery Round Corner

Avinoam Henig stellte auf seiner Homepage mit jQuery Round Corners ein insgesamt ziemlich ausgereiftes jQuery-Plugin zur Verfügung.

Um es nutzen zu können, benötigt man eine jQuery-Version ( die aktuelle Version 1.3(.1)  funktioniert auch! ) und Explorer-Canvas. Beide Skripte müssen zusammen mit dem roundCorner-Skript in den Dateikopf eingebunden werden.

Anschließend bettet man beispielsweise solchen Code wie $(‘#roundCorners’).roundCorners(“25px”); ein. RoundCorners erzeugt daraus um (beziehungsweise “hinter”) das Element eine Canvas-Grafik mit runden Ecken.

Der Rahmenradius lässt sich für jede Ecke individuell angeben, zum Beispiel .roundCorners(“25px”, 0, “25px”, 0); . Die erste Angabe steht für die linke obere Ecke, weiter folgen rechts oben, rechts unten und links unten.

Angaben zu Rahmenfarbe und – dicke werden entsprechend der CSS-Formatierung des betreffenden Elements angewendet.

Das Ergebnis kann sich insgesamt in allen gängigen Browsern sehen lassen.

Was ich an dieser Umsetzung merkwürdig finde, ist die Veränderung der Element- / Rahmengröße beim Überfahren mit der Maus.

LiquidCanvas

LiquidCanvas von Steffen Rusitschka ist von der Funktionsweise her dem oben genannten RoundCorners sehr ähnlich. Auch hier wird eine Canvas-Grafik verwendet, die das betreffende Element umfasst.

Ebenfalls benötigt LC jQuery und ExCanvas als eingebundene Header-Files. Zusätzlich müssen beide LC-Dateien (liquid-canvas.js und liquid-canvas-plugins.js) eingebunden sein.

Im Gegensatz zu anderen Implementieren lässt sich der Radius der runden Ecken hier nur für alle Ecken allgemein angeben. Dafür bietet LiquidCanvas die Möglichkeit, linieare Farbverläufe als Hintergrund-Füllfarbe zu nutzen.

Ein typischer Aufruf sieht so aus: $(“#liquidCanvas”).liquidCanvas( “[fill{color:#000000} border{color:#dd0000; width:5}] => roundedRect{radius:25}” );.

Die Farbe und Dicke der Rahmen wird hierbei in dem Aufruf selbst definiert. Das bedeutet aber wiederum, dass man etwaige vorherige Rahmenformatierungen aufheben muss. Dies geht zum Beispiel mit dem Code $(“#liquidCanvas”).css(“border-style”,”none”).

Bei LiquidCanvas fiel mir auf, dass das Skript die padding-Abstände nicht korrekt übernimmt. Hier muss im nachhinein noch Hand an die Elemente gelegt werden, um die Abstände zu korrigieren.

scale9grid

Einen gänzlich anderen Weg geht “Gordon” mit scale9grid. Dieses orientiert sich an der traditionellen Methode zum Erstellen individueller Rahmen mittels div-Verschachtelungen.

Um scale9grid zu nutzen, benötigt man zum einen jQuery, das Plugin scale9grid und eine (größere) Rahmengrafik, die das Aussehen des zukünftigen Elementrahmens beinhaltet.

Um das betreffende Element werden acht div’s angehangen – für jede Richtung eins – und mit einem Ausschnitt der Rahmengrafikdatei beklebt.

Besonders interessant finde ich die Möglichkeit mit jQuery die Hintergrundgrafik erst kurz vor dem scale9grid-Aufruf hinzu zufügen.

Dies sieht dann beispielsweise so aus: $(‘#scale9grid’).css(“background-image”,”url(schwarzrot.png)”).scale9Grid({top:30,bottom:30,left:30,right:30});

Die vier Parameter der Methode bestimmen die Schnittpunkte der Grafik. Der Reihe nach: Abstand von oben, von unten, von links und von rechts.

Was mich an dieser Lösung frustriert, sind die Abweichungen von Breite und padding-Angabe. Diese kann man in der Demo gut nachvollziehen.

dd_roundies

Drew Millers Projekt dd_roundies richtet sich speziell an den Internet Explorer (Version 6). Hierbei nutzt die IE-Vektoren-Auszeichnungssprache VML genutzt, um Vektorgrafiken für den IE zu erzeugen, die runde Ecken darstellen (Anmerkung: Explorer Canvas tut das selbe).

dd_roundies benötigt keine anderen (fremden) Skript-Dateien außer die eigene DD_roundies.js.

Mit der Anweisung DD_roundies.addRule(‘#dd_roundies’, ’25px’, true); kann beispielsweise ein 25 Pixel breiter Rahmenradius erzeugt werden. Auch hierbei können 4 verschiedene Werte (wie "10px 5px 3px 0" als zweiten Parameter) angegeben werden, um jeder Ecke einen indiviuellen Rahmenradius zuzuweisen.

Millers Skript kann jedoch nicht mit table-Elementen und textarea’s umgehen. Desweiteren gibt es aktuell noch etliche Probleme mit der Beta der 8. IE-Generation.

Für Browser, die von Haus aus Rahmenradius-Eigenschaften css-seitig ( -moz-border-radius, -webkit-border-radius oder das W3C-konforme border-radius ) unterstützen, gibt es den optionalen dritten Parameter, der diese nativen Eigenschaft nutzt.

Opera bleibt bei dieser Lösung jedoch außen vor. Zudem sehen die nativen runden Ecken im Firefox 2 sehr dürftig aus, so dass man hier andere Techniken wählen sollte.

Ansonsten erzeugt dd_roundies eine pixelgenaue Übereinstimmung zwischen Firefox 3, Webkit/Safari 3 und IE6 /7.

Auf meiner eingerichteten Demo-Seite kann jeder sich selbst ein Bild über die erzielten Ergebnisse der einzelnen Lösungen machen.

Alternative (jQuery-) Projekte, die sich auch mit runden Ecken beschäftigen:

• jQuery Curvy Corners
• jQuery BackgroundCanvas
• jQuery Corners
• CSS Multiple Backgrounds

Fazit

Die perfekte Lösung gibt es noch nicht.

Grundsätzliche bevorzuge ich, soweit es möglich ist, die nativen CSS-Eigenschaften runde Rahmen um Elemente zu erzeugen.

Für IE und Opera bietet es sich, die Projekte, die mit Canvas arbeiten, genauer anzuschauen und eines davon zu nutzen.

In den meisten Anwendungsfällen ändert man das Erscheinungsbild von Elementen, indem man diese direkt anspricht (zum Beispiel mit getElementById(id) ) und mittels style-Attribut beeinflusst.

Mit DOM CSS ist es möglich, solche Änderungen in CSS-Regeln wie div.menu { color: black } durchzuführen. Dazu bieten alle modernen Browser Funktionen zum Entfernen bestehender und zum Erstellen neuer CSS-Regeln.

Dabei halten sich die meisten Browser-Entwickler an die W3C-Vorgaben, nur Microsofts Internet Explorer – wie so oft – nicht. Dennoch bietet der IE ähnliche Funktionen.

Grundsätzlich adressiert man zuerst das Stylesheet, das man mit Javascript beeinflussen will. Dies kann man zum Beispiel über die getElement-Methoden tun.

Das document-Object stellt mit document.styleSheets[index] eine weitere Möglichkeit zum Ansprechen von Stylesheets zur Verfügung, womit sowohl alle internen style-Elemente als auch alle externen, mit link erzeugten CSS-Definitionen erreicht werden können.

In standardkonformen Browsern greift man mit cssRules[index] auf bestehende CSS-Regeln zu, der IE reagiert nur auf die MS-eigene Methode rules[index].

Anschließend kann man mit dem style-Attribut wie gewohnt die Eigenschaftswerte verändern. Zum Beispiel:

document.styleSheets[0].cssRules[0].style.backgroundColor = "yellow";

Außerdem gibt es die Möglichkeit mittels der selectorText-Methode den Selector eines CSS-Regel auszulesen. Damit lässt eine Schleife konstruieren, die alle CSS-Regeln nach einem bestimmten Eintrag durchsucht, wie nachfolgend demonstriert:

if( document.styleSheets[0].cssRules ) {
	var myrules = document.styleSheets[0].cssRules;
} else {
	if ( document.styleSheets[0].rules ) {
		var myrules = document.styleSheets[0].rules;
	}
}

if( myrules ) {
	for( i = 0; myrules[i]; i++ ){
		if( myrules[i].selectorText == "p"){
			myrule = myrules[i];
			break;
		}
	}
}

Um neue Regeln hinzuzufügen, verwendet man in standardkonformen Browsern die insertRule[definition, index]-Methode, für den Explorer heißt die Funktion addRule[selector, style, index (optional)].

Vorhandene CSS-Definitionen löscht man mittels deleteRule[index] beziehungsweise removeRule[index (optional)] im IE.

Nachfolgend ist der komplette Code eines Mini-Beispiel zu finden. Dabei wird zuerst ein neues style-Elemente zur Laufzeit erstellt, in das HTML-Gerüst eingebettet und abschließend mittels DOM CSS eine Regel für das body-Element festgelegt, die Hintergrund- und Schriftfarbe verändert.

<br />
if( document.styleSheets ) {
	var myStyle = document.createElement("style");
	myStyle.setAttribute( "type", "text/css" );
	document.getElementsByTagName("head")[0].appendChild(myStyle);

	var styles = document.styleSheets.length;
	myStyle = document.styleSheets[styles-1];

	if( document.styleSheets[0].cssRules ) {
		myStyle.insertRule("body { color: red; background-color: black; }", 0);
	} else {
		if ( document.styleSheets[0].rules ) {
			myStyle.addRule("body", "color: red; background-color: black;");
		}
	}
}

Ich favorisiere den Weg über das Hinzufügen eines neuen style-Elements anstatt dem Bearbeiten vorhandener Definitionen, da mir dies übersichtlicher und logischer vorkommt. Zumal – in den meisten Fällen – die zuletzt festgelegte CSS-Regel bei Überschneidungen zur Darstellung vom Browser genutzt wird.

Der Vorteil gegenüber dem traditionellen Ändern von style-Attributen über das direkte Ansprechen liegt vor allem in der Geschwindigkeit bei einer großen Anzahl von Elementen, die verändert werden sollen.

Ein Browser kann erheblich schneller 1.000 Elementen eine neue Schriftfarbe über eine CSS-Regel zuweisen als in einer Schleife eben diese Elemente direkt zu adressieren und jedem die neue Schriftfarbe zuzuweisen.

Interessant ist DOM CSS daher bei Javascript-Anwendungen, die neue HTML-Elemente (für runde Ecken beispielsweise) in den Code einbinden.

Dadurch ist es für einen Webseitenbesucher leichter zu erkennen, ob ein Verweis auf die selbe, eine externe, eine interne oder eine Subdomain-Seite verweist. Außerdem erkennt DLINK auch Verweise auf Emails und Subdomains.

Um DLINK zu nutzen, bindet man zuerst die JS-Datei im Header ein, gruppiert die Links, die hervorgehoben werden sollen und weist der Gruppe die dlink-CSS-Klasse zu. Anschließend formatiert man noch die Link-Typen in CSS. Fertig.

Der folgende Quellcode soll das Vorgehen verdeutlichen:

<script type="text/javascript" src="http://oopstudios.com/dlink/dlink.js"></script>

<style type="text/css">
a.internal  {color: #D47700;}
a.external  {color: #0074D4;}
a.subdomain {color: #D43500;}
a.email     {color: #00B235;}
</style>

<div class="dlink">
your <a href="#">link filled</a> content...
</div>

Um seine Querbalken darzustellen, nutzte er einzig Canvas. Mit ein wenig JavaScript hauchte er diesen durch Animation Leben ein.

Das Ergebnis ist vielleicht die alltagstaugliche Einsatzmöglichkeit für moderne Web2.0-Anwendungen, aber jedoch ein schicke Anregung für eigene Spielereien.

Die Rundungen werden zur Laufzeit über Canvas generiert und automatisch in den HTML-Code eingebettet. Der Einsatz von herkömmlichen Bildbearbeitungsprogrammen wie Gimp, Inkscape oder Photoshop entfällt völlig.

Die Features im Einzelnen:

• automatisches Erzeugen von HTML-Canvas-Elementen, die sich der Größe des HTML-Elements anpassen
• Canvas-Abstraktion – jedes HTML-Element erhält eine paint-Methode
• Plugins zum Rendern können verwendet werden
• etliche Plugins existieren bereits, eigene können ebenso eingebunden werden
• vereinfachte Render-Sprache für Plugin basiertes Rendern
• an CSS angelehnte Syntax der Render-Sprache für die plugin-Formatierung
• nutzt nur HTML, Canvas, jQuery und exCanvas
• funktioniert mit Firefox (2+), Internet Explorer (6+), Safari (3+), Chrome