//=====================================
// DQ180 - Javascript - Framework
//-------------------------------------
// copyright by dq 180, Autor Heiko Goeb
// v1.1. - May 2008
//=====================================


//=====================================
// CLASS GLOBALS
//-------------------------------------
// GLobale Clientvariablen und -funktionen
//
// @ plattform_pc		: PC-System
// @ brwsr_name			: Browsername
// @ brwsr_version		: Browserversion
//
// @ getIEVersion()		: liest IE Version aus
// @ getClientWidth()	: liest Fensterbreite aus
// @ getClientHeight()	: liest Fensterhoehe aus
//
//=====================================
// CLASS DQ_DOM
//-------------------------------------
// Basis-Klasse prueft auf DOM-Faehigkeit und sammelt HTML-Objekte
// fuer spaetere Verwendung
// Enthaelt Funktionskuerzel fuer getElement-Funktionen und neue
// getElementsByClass-Funktion
//
// @ ELEMENTS			: Array : Alle HTML-Elemente im Dokument
// @ ALL_LINKS			: Array : Alle Links (<a>) im Dokument
// @ dom_active 		: Boolean : Wird ein DOM-faehiger Browser verwendet
//
// @ elmById(ref)		: Alias fuer document.getElementById()
// @ elmsByName(ref) 	: Alias fuer document.getElementsByName()
// @ elmsByTag(ref) 	: Alias fuer document.getElementsByTag()
// @ elmsByClass(ref)	: Array : Alle Elemente mit Klasse "ref"
//
//=====================================
// CLASS DQ_EVENT
//-------------------------------------
// Einfacher DOM-Eventhandler
//
// @ addEvent(obj, event_type, handle_function, use_capture)
//						: Fuegt einem Objekt Eventhandler hinzu
//						: @ obj :  Dem Objekt "obj"
//						: @ event_type : wird Event "event_type"
//						: @ handle_function : mit Eventfunktion "handle_function"
//						: @ use_capture : mit/ohne Bubbleoption hinzugefuegt (nur Safari und Firefox)
//
//=====================================
// CLASS DQ_CSS
//-------------------------------------
// Browserunabhaengige Klasse zum Auslesen und Aendern von Style Sheets und Klassen.
// Erkennt selbst, um welchen Objekttyp es sich handelt.
//
// @ switchCSS(ref_tag, attr, new_value, index_nr)
//						: Funktion zum Aendern einer Style-Angabe
//						: @ ref_tag : ID oder Name des Elements
//						: @ attr : CSS-Eigenschaft
//						: @ new_value : Neuer Wert fuer CSS
//						: @ index_nr : Position im Array, falls ueber "ByName" gesucht wird
// @ switchClass(ref_tag, new_class, index_nr)
//						: Funktion zum Aendern einer Klassen-Angabe
//						: @ ref_tag : ID oder Name des Elements
//						: @ new_class :	Klassenname aus CSS-Datei
//						: @ index_nr : Position im Array, falls ueber "ByName" gesucht wird
// @ addClass(ref_tag, new_class, index_nr)
//						: Funktion zum Anfuegen einer oder mehrerer CSS-Klassen
//						: @ ref_tag : ID oder Name des Elements
//						: @ new_class :	Klassenname aus CSS-Datei
//						: @ index_nr : Position im Array, falls ueber "ByName" gesucht wird
// @ removeClass(ref_tag, delete_class, index_nr)
//						: Funktion zum Loeschen einer oder mehrerer Klassen-Angabe
//						: @ ref_tag : ID oder Name des Elements
//						: @ delete_class :	Klasse, die geloescht wird
//						: @ index_nr : Position im Array, falls ueber "ByName" gesucht wird
// @ getClasses(ref_tag, index_nr)
//						: Funktion zum Auslesen eines class-Attributes; gibt ein Array zurueck
//						: @ ref_tag : ID oder Name des Elements
//						: @ index_nr : Position im Array, falls ueber "ByName" gesucht wird
// @ setClasses(source, ref_tag, index_nr)
//						: Funktion zum Setzen eines class-Attributes mit mehreren Klassen
//						: @ source:	String mit Klassenangaben
//						: @ ref_tag : ID oder Name des Elements
//						: @ index_nr : Position im Array, falls ueber "ByName" gesucht wird
// @ switchAllClasses(ref_tag, new_class, switch_add)
//						: @ ref_tag : ID oder Name des Elements
//						: @ new_class : Bezeichnung der neuen Klasse
//						: @ switch_add : 0 = Klasse wird geaendert, 1 = Klasse wird hinzugefuegt
// @ showLayer(layer_id)
//						: Funktion zum Einblenden eines HTML-Elements mit Id
//						: @ layer_id : Id des HTML-Elements
// @ hideLayer(layer_id)
//						: Funktion zum Ausblenden eines HTML-Elements mit Id
//						: @ layer_id : Id des HTML-Elements
// @ hideAll(bereich_id)
//						: Funktion zum Ausbkenden mehrerer HTML-Elemente mit Id = "xxxxx"+n
//						: @ bereich_id : Gemeinsamer Id-Wert "xxxxx" der HTML-Elemente
//
//=====================================

// CLASS BUTTONS
//-------------------------------------
// Objekt fuer Menueelemente und Menuesteuerung ueber Events
// Basisfunktionen fuer die Navigation und Links einer Website
// Variablenwerte koennen angepasst werden
//
// @ name_hb			: Attribut-Name der Hauptbuttons in der Navigation
// @ name_sb			: Attribut-Name der Unterbuttons der 1. Ebene in der Navigation
// @ active_menu 		: ID-Referenz fuer das Untermenue, das momentan dynamisch eingeblendet wird
// @ active_hb 			: Aktuell gewaehlter Hauptbutton (wird automatisch generiert)
// @ active_sb 			: Aktuell gewaehlter Unterbutton (wird automatisch generiert)
//
// @ initButtons()
//						: Funktion, die Maus-Events hinzufuegt fuer Navigation und Standardbuttons
//						! Aktive Buttons werden nach Klasse "mOn" ausgelesen
//						! Links mit Untermenue bedingen die Klasse "hlink"
//						! Druckbutton mit id="but_druck" wird aktiviert, falls vorhanden
// @ getActiveButton(ref)
//						: Liest aktiven Button aus
//						: @ ref : Name des Buttons
// @ setActiveButton(ref, index)
//						: Setzt aktiven Button
//						: @ ref : Name des Buttons
//						: @ index : Position im Menu-Array
//
//=====================================
// CLASS DQ_IMG
//-------------------------------------
// Bildmanipulation: Rollover und browserunabhaengige PNG-Anzeige
//
// @ swapImage(where, to)
//						: Bildwechsel bei Mouseover
//						: @ where : Bildname = "where"
// 						: @ to : in JS referenzierte Bildresource (new Image();)
// @ insertPNG(datei, alt_text, breite,hoehe, where)
//						: Browseruebergreifendes Einsetzen von transparenten PNGs
//						: Fuer die Darstellung im IE6 unter Windows, wird das Bild automatisch
//						: mit CSS-Filter generiert
// 						: @ datei : Absoluter Dateipfad des Bildes, mit "./" beginnen
// 						: @ alt_text : Text fuer alt=""
// 						: @ breite : Bildbreite
// 						: @ hoehe : Bildhoehe
// 						: @ where : Id des HTML-Tags, in dem Bild eingefuegt wird
//
//=====================================

//=====================================
// Globale System-Konstanten und Variablen
//=====================================

GLOBALS = {
    plattform_pc 	: navigator.platform,
    brwsr_name		: navigator.appName,
    brwsr_version 	: navigator.appVersion,
    ie_version		: 100,

    getIEVersion : function () {
	regExpr = /icrosoft/;
	if ( regExpr.test(GLOBALS.brwsr_name) ) {
	    pos_MSIE = GLOBALS.brwsr_version.indexOf("MSIE");
	    ie_v =  Number(GLOBALS.brwsr_version.charAt(pos_MSIE+5))
	    return ie_v;
	} else {
	    return 100;
	}
    },

    getClientWidth : function () {
	if( window.document.body.clientWidth ) {
	    return window.document.body.clientWidth;
	} else if ( window.innerWidth ) {
	    return window.innerWidth;
	} else {
	    return window.document.body.offsetWidth;
	}
    },

    getClientHeight: function () {
	if( indow.document.body.clientHeight ) {
	    return window.document.body.clientHeight;
	} else if ( window.innerHeight ) {
	    return window.innerHeight;
	} else {
	    return window.document.body.offsetHeight;
	}
    }
};


//=====================================
// DOM-Funktionen:
//=====================================
DQ_DOM = {
    ELEMENTS	: new Array(),	//Alle HTML-Elemente im Dokument
    ALL_LINKS	: new Array(),  //Alle Links im Dokument
    dom_active 	: -1, 			//true oder false

    //=====================================
    // Browsertest: Alle Scripte nur ausfuehren, wenn DOM2+-kompatibler Browser im Einsatz ist
    //=====================================
    init 		: function () {
	if ( document.getElementById && document.createTextNode ) {
	    DQ_DOM.dom_active = true;
	    DQ_DOM.ELEMENTS = DQ_DOM.elmsByTag("*");
	    DQ_DOM.ALL_LINKS = DQ_DOM.elmsByTag("a");
	} else if ( document.all ) {
	    DQ_DOM.dom_active = "MSIE";
	    DQ_DOM.ELEMENTS = DQ_DOM.elmsByTag("*");
	    DQ_DOM.ALL_LINKS = DQ_DOM.elmsByTag("a");
	} else {
	    DQ_DOM.dom_active = false;
	}
    },

    //=====================================
    // Kurzschreibweisen
    //=====================================
    elmById 	: function (ref) {		    
	if ( DQ_DOM.dom_active && document.getElementById(ref) ) {
	   return document.getElementById(ref);
	} else {
	    return false;
	}
    },

    elmsByName 	: function (ref) {
	if ( DQ_DOM.dom_active && document.getElementsByName(ref) ) {
	   return document.getElementsByName(ref);
	} else {
	    return false;
	}
    },

    elmsByTag 	: function (ref) {
	if ( DQ_DOM.dom_active && document.getElementsByTagName(ref) ) {
	   return document.getElementsByTagName(ref);
	} else {
	    return false;
	}
    },

    //=====================================
    // Elemente mit bestimmter Klasse finden
    //=====================================
    elmsByClass : function (ref) {
	if ( DQ_DOM.dom_active ) {
	    ELMARRAY = new Array();
	    counter=0;
	    for (x=0; x<DQ_DOM.ELEMENTS.length; x++) {
		if ( DQ_DOM.ELEMENTS[x].className==ref )
		{
		    ELMARRAY[counter] = DQ_DOM.ELEMENTS[x];
		    counter++;
		}
	    }
	    return ELMARRAY;
	} else {
	    return false;
	}
    }
};

//=====================================
//Cross-Browser Event-Handler, da IE bisher nur attachEvent versteht
//=====================================
DQ_EVENT = {
    addEvent: function (obj, event_type, handle_function, use_capture) {
	if ( obj.attachEvent ){
	    //Internet Explorer und Opera
	    obj["event" + event_type + handle_function] = handle_function;
	    obj[event_type + handle_function] = function() {
		obj["event"+event_type+handle_function](window.event);
	    }
	    obj.attachEvent("on"+event_type,obj[event_type+handle_function]);
	} else {
	    //Safari und Firefox (Mozilla)
	    obj.addEventListener(event_type, handle_function, use_capture);
	}
    }
};

//=====================================
// Objekt: DQ_CSS
//=====================================
DQ_CSS = {
    //=====================================
    //Aendern einer CSS-Angabe
    //=====================================
    switchCSS : function (ref_tag, attr, new_value, index_nr) {
	if ( document.images[ref_tag] ) {
	    eval("document.images['"+ref_tag+"'].style." + attr + " = '" + new_value + "'");
	} else {
	    if ( isNaN(index_nr) ) {
		eval("document.getElementById('" + ref_tag +"').style." + attr + " = '" + new_value + "'");
	    } else {
		eval ("document.getElementsByName(" + ref_tag + ")[" +index_nr + "].style." + attr +" = '" + new_value + "'");
	    }
	}
    },

    //=====================================
    // Aendern einer CSS-Klasse
    //=====================================
    switchClass : function (ref_tag, new_class, index_nr)
    {
	if ( DQ_DOM.dom_active ) {
	    if ( document.images[ref_tag] ) {
		document.images[ref_tag].className = new_class;
	    } else {
		if ( isNaN(index_nr) ) {
		    if ( DQ_DOM.elmById(ref_tag) ) {
			alert("wechsel Klasse");
			DQ_DOM.elmById(ref_tag).className = new_class;
		    } else {
			//nach DQ_DOM-Funktionen ausgelesene Objekte
			ref_tag.className = new_class;
		    }
		} else {
		    DQ_DOM.elmsByName(ref_tag)[index_nr].className = new_class;
		}
	    }
	}
    },

    //=====================================
    //Klassennamen ergaenzen
    //=====================================
    addClass : function (ref_tag, new_class, index_nr)  {
	if ( DQ_DOM.dom_active ) {
	    if ( document.images[ref_tag] ) {
		class_txt = DQ_DOM.elmsByName(ref_tag)[0].className;
		DQ_DOM.elmsByName(ref_tag)[0].className = class_txt + " " + new_class;
	    } else {
		if ( isNaN(index_nr) ) {
		    if ( DQ_DOM.elmById(ref_tag) ) {
			class_txt = DQ_DOM.elmById(ref_tag).className;
//alert(ref_tag);
			if (DQ_CSS.testClassName(class_txt,new_class)) {
			    DQ_DOM.elmById(ref_tag).className = class_txt + " " + new_class;
			}
		    } else {
			//nach DQ_DOM-Funktionen ausgelesene Objekte
			class_txt = ref_tag.className;
			if (DQ_CSS.testClassName(class_txt,new_class)){
			    ref_tag.className = class_txt + " " + new_class;
			}
		    }
		} else {
		    if (DQ_CSS.testClassName(DQ_DOM.elmsByName(ref_tag)[index_nr].className,new_class)){
			DQ_DOM.elmsByName(ref_tag)[index_nr].className = DQ_DOM.elmsByName(ref_tag)[index_nr].className + " " + new_class;
		    }
		}
	    }
	}
    },

    testClassName : function (testclass, searchstring)
    {
	//alert(testclass);
	
	teststr = "/"+searchstring+"/";
	//alert(testclass.indexOf(searchstring));
	if(testclass && testclass.indexOf(searchstring) >= 0)
	{
	    return false
	} else
	{
	    return true
	}
    },


    //=====================================
    //Klassennamen loeschen
    //=====================================
    removeClass : function (ref_tag, delete_class, index_nr)
    {
	if ( !DQ_DOM.dom_active ) {
	    return;
	}

	//Auslesen der aktuellen Klassen
	if ( isNaN(index_nr) ) {
	    classes_now = this.getClasses(ref_tag);
	} else {
	    classes_now = this.getClasses(ref_tag,index_nr);
	}
	//alert(classes_now+":  entfernen von "+delete_class);
	if(classes_now){
	    //Zu loeschende Klasse finden und loeschen
	    eval ("regExpr = /" + delete_class + "/");
	    classes_now = ( OPENSOURCE.trim(classes_now.replace(regExpr, "")) );
	    //neue Klassen setzen
	    if (classes_now)
	    {
		//alert ("neu: "+classes_now);
	       this.setClasses(classes_now, ref_tag, index_nr);
	    }
	}
    },

    //=====================================
    //Aus Objekt "class" auslesen
    //=====================================
    getClasses : function (ref_tag, index_nr)
    {
	if ( isNaN(index_nr) ) {
	    if ( DQ_DOM.elmById(ref_tag) ) {
		return DQ_DOM.elmById(ref_tag).className;
	    } else {
		//nach DQ_DOM-Funktionen ausgelesene Objekte
		return ref_tag.className;
	    }
	} else {
	    return DQ_DOM.elmsByName(ref_tag)[index_nr].className;
	}
    },

    //=====================================
    //Daten auslesen und als Klassen zusammenfuegen
    //=====================================
    setClasses : function (source, ref_tag, index_nr)
    {
	if ( isNaN(index_nr) ) {
	    if ( DQ_DOM.elmById(ref_tag) ) {
		DQ_DOM.elmById(ref_tag).className = source;
	    } else {
		//nach DQ_DOM-Funktionen ausgelesene Objekte
		ref_tag.className = source;
	    }
	} else
	{
	    DQ_DOM.elmsByName(ref_tag)[index_nr].className = source;
	}
    },

    //=====================================
    //Schleife zum Aendern von mehreren HTML-Elementen
    //=====================================
    switchAllClasses : function (ref_tag, new_class, switch_add)
    {
	if ( !DQ_DOM.dom_active ) {
	    return;
	}

	if ( DQ_DOM.elmById(ref_tag+"0") || document.images[ref_tag+"0"] ) {
	    for (x=0;x<100;x++){
		//aendern von id='xxxx'0 bis id='xxxx'n
		target = ref_tag + x;
		if ( DQ_DOM.elmById(target) || document.images[target] ) {
		    //alert(target);
		    if (switch_add==0 || switch_add=="undefined") {
			this.switchClass(target, new_class);
		    } else {
			this.addClass(target, new_class);
		    }
		}
	    }
	} else if ( DQ_DOM.elmsByName(ref_tag).length>0 ) {
	    for (x=0;x<DQ_DOM.elmsByName(ref_tag).length;x++){
		if (switch_add==0 || switch_add=="undefined") {
		    this.switchClass(ref_tag, new_class, x);
		} else {
		    this.addClass(ref_tag, new_class, x);
		}
	    }
	}
    },


    //=====================================
    // Layer zeigen - verbergen
    //=====================================
    showLayer : function (layer_id)
    {
	DQ_CSS.switchCSS (layer_id, "visibility", "visible");
    },

    hideLayer : function (layer_id)
    {
	DQ_CSS.switchCSS (layer_id, "visibility", "hidden");
    },

    //=====================================
    // alle Layer einer Gruppe verbergen
    //=====================================
    hideAll : function (bereich_id)
    {
	eval("regExp = /"+bereich_id+"/;");
	for(i=0; i<DQ_DOM.ELEMENTS.length; i++){
	    if (regExp.test(DQ_DOM.ELEMENTS[i].id)) {
		DQ_CSS.switchCSS (DQ_DOM.ELEMENTS[i].id, "visibility", "hidden");
	    }
	}
    }
};


//=====================================
// Objekt: BUTTONS
//=====================================
BUTTONS = {
    //Variablen
    name_hb	: 	"hbut",
    name_sb	: 	"sbut",
    id_sub	:	"submenue_",
    active_menu : 	-1,
    active_submenu : -1,
    active_subsubmenu : -1,
    active_hb : 	-1,
    active_sb : 	-1,
    active_ssb : 	-1,
    selected_menu : -1,
    selected_submenu : -1,

    //=====================================
    // Buttons aktivieren
    //=====================================
    initButtons : function ()
    {
	// alle Buttons
	butArray = DQ_DOM.ALL_LINKS;
	// Hauptbuttons...
	//hbArray = DQ_DOM.elmsById(BUTTONS.name_hb);
	// Subbuttons...
	//sbArray = DQ_DOM.elmsByName(BUTTONS.name_sb);

	// blur() einsetzen und href fuer Safari und Firefox (Maus wird zur Hand)
	for (x=0;x<butArray.length;x++) {
	    target = butArray[x];
	    DQ_EVENT.addEvent(target, "focus", function() {
		this.blur()
	    }, false);

	    if ( !target.href && !(/Opera/.test(GLOBALS.brwsr_name)) && !(/Microsoft/.test(GLOBALS.brwsr_name)) ) {
		target.href="#";
	    }
	}
	//Aktive Menues setzen
	hauptmenue = document.getElementById("hauptmenue_0");
	links_hm = hauptmenue.getElementsByTagName("li");

	for (i=0; i<links_hm.length; i++)
	{
	    if (links_hm[i].className==="aktiv")
	    {
		link_aktiv=links_hm[i].id;
		BUTTONS.active_hb = parseInt(link_aktiv.match(/\d+/));
		BUTTONS.active_menu = parseInt(link_aktiv.match(/\d+/));

		if (document.getElementById("submenue_"+BUTTONS.active_menu))
		{
		    submenue = document.getElementById("submenue_"+BUTTONS.active_menu);
		    links_sm = submenue.getElementsByTagName("li");

		    for (ii=0; ii<links_sm.length; ii++)
		    {
			if (links_sm[ii].className==="aktiv")
			{
			    slink_aktiv=links_sm[ii].id;
			    BUTTONS.active_sb = slink_aktiv;
			    BUTTONS.active_submenu = BUTTONS.active_menu+"_"+ii;
			}
		    }
		}

		if (document.getElementById("submenue_"+BUTTONS.active_submenu))
		{
		    submenue = document.getElementById("submenue_"+BUTTONS.active_submenu);
		    links_sm = submenue.getElementsByTagName("li");

		    for (ii=0; ii<links_sm.length; ii++)
		    {
			if (links_sm[ii].className==="aktiv")
			{
			    slink_aktiv=links_sm[ii].id;
			    BUTTONS.active_ssb = slink_aktiv;
			   // alert(BUTTONS.active_ssb);
			}
		    }
		}
	    }
	}
    },

    //=====================================
    // Aus einer Element-Gruppe name="xxx" aktiven finden
    //=====================================
    getActiveButton : function (ref)
    {
	ButArray = DQ_DOM.elmsByName(ref);
	for (x=0;x<ButArray.length;x++) {
	    target = ButArray[x];
	    if ( target.className == "aktiv" ){
		return x;
	    } else {
		return -1;
	    }

	}
    },

    //=====================================
    // In einer Element-Gruppe name="ref" aktiven setzen
    //=====================================
    setActiveButton: function (ref, index)
    {
	eval ("DQ_CSS.addClass(ref, CSS_" + ref.toUpperCase() + ".aktiv, index)");
	eval ("BUTTONS.active_" + ref + " = index");
    }
};



//=====================================
// Bild-Funktionen
//=====================================
DQ_IMG = {
    //=====================================
    // Function swapImage
    //=====================================
    swapImage 	: function (where, to)
    {
	if ( eval("window.document." + where)) {
	    eval("window.document." + where + ".src=" + to + ".src");
	}
    },

    //=====================================
    // Function insertPNG: NUR FUER IE<7 BENUTZEN
    //=====================================
    insertPNG 	: function (datei, alt_text, breite, hoehe, where)
    {
	document.getElementById(where).innerHTML="";
	obj = document.getElementById(where);
	obj.style.width=breite;
	obj.style.height=hoehe;
	obj.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + datei + "', sizingMethod='scale')";

    }
}

OPENSOURCE = {
    //=====================================
    // http://kevin.vanzonneveld.net
    // +   original by: Ash Searle (http://hexmen.com/blog/)
    // + namespaced by: Michael White (http://crestidg.com)
    // *     example 1: sprintf("%01.2f", 123.1);
     // *     returns 1: 123.10
    //=====================================

    sprintf : function()
    {
	var regex = /%%|%(\d+\$)?([-+#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
	var a = arguments, i = 0, format = a[i++];
	// pad()
	var pad = function(str, len, chr, leftJustify) {
	    var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
	    return leftJustify ? str + padding : padding + str;
	};

	// justify()
	var justify = function(value, prefix, leftJustify, minWidth, zeroPad) {
	    var diff = minWidth - value.length;
	    if (diff > 0) {
		if (leftJustify || !zeroPad) {
		    value = pad(value, minWidth, ' ', leftJustify);
		} else {
		    value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
		}
	    }
	    return value;
	};

	// formatBaseX()
	var formatBaseX = function(value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
	    // Note: casts negative numbers to positive ones
	    var number = value >>> 0;
	    prefix = prefix && number && {
		'2': '0b',
		'8': '0',
		'16': '0x'
	    }
	    [base] || '';
	    value = prefix + pad(number.toString(base), precision || 0, '0', false);
	    return justify(value, prefix, leftJustify, minWidth, zeroPad);
	};

	// formatString()
	var formatString = function(value, leftJustify, minWidth, precision, zeroPad) {
	    if (precision != null) {
		value = value.slice(0, precision);
	    }
	    return justify(value, '', leftJustify, minWidth, zeroPad);
	};

	// finalFormat()
	var doFormat = function(substring, valueIndex, flags, minWidth, _, precision, type) {
	    if (substring == '%%') return '%';

	    // parse flags
	    var leftJustify = false, positivePrefix = '', zeroPad = false, prefixBaseX = false;
	    for (var j = 0; flags && j < flags.length; j++) switch (flags.charAt(j)) {
		case ' ':
		positivePrefix = ' ';
		    break;
		case '+':
		    positivePrefix = '+';
		    break;
		case '-':
		    leftJustify = true;
		    break;
		case '0':
		    zeroPad = true;
		    break;
		case '#':
		    prefixBaseX = true;
		    break;
	    }

	    // parameters may be null, undefined, empty-string or real valued
	    // we want to ignore null, undefined and empty-string values
	    if (!minWidth) {
		minWidth = 0;
	    } else if (minWidth == '*') {
		minWidth = +a[i++];
	    } else if (minWidth.charAt(0) == '*') {
		minWidth = +a[minWidth.slice(1, -1)];
	    } else {
		minWidth = +minWidth;
	    }

	    // Note: undocumented perl feature:
	    if (minWidth < 0) {
		minWidth = -minWidth;
		leftJustify = true;
	    }

	    if (!isFinite(minWidth)) {
		throw new Error('sprintf: (minimum-)width must be finite');
	    }

	    if (!precision) {
		precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : void(0);
	    } else if (precision == '*') {
		precision = +a[i++];
	    } else if (precision.charAt(0) == '*') {
		precision = +a[precision.slice(1, -1)];
	    } else {
		precision = +precision;
	    }

	    // grab value using valueIndex if required?
	    var value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];

	    switch (type) {
		case 's':
		    return formatString(String(value), leftJustify, minWidth, precision, zeroPad);
		case 'c':
		    return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
		case 'b':
		    return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
		case 'o':
		    return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
		case 'x':
		    return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
		case 'X':
		    return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
		case 'u':
		    return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
		case 'i':
		case 'd': {
		    var number = parseInt(+value);
		    var prefix = number < 0 ? '-' : positivePrefix;
		    value = prefix + pad(String(Math.abs(number)), precision, '0', false);
		    return justify(value, prefix, leftJustify, minWidth, zeroPad);
		}
		case 'e':
		case 'E':
		case 'f':
		case 'F':
		case 'g':
		case 'G':
		{
			var number = +value;
			var prefix = number < 0 ? '-' : positivePrefix;
			var method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
			var textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
			value = prefix + Math.abs(number)[method](precision);
			return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
		    }
		default:
		    return substring;
	    }
	};
	return format.replace(regex, doFormat);
    },

    //=====================================
    // http://kevin.vanzonneveld.net
    // +   original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +     bugfix by: Michael White (http://crestidg.com)
    // +     bugfix by: Benjamin Lupton
    // +     bugfix by: Allan Jensen (http://www.winternet.no)
    // +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +     bugfix by: Howard Yeend
    // *     example 1: number_format(1234.5678, 2, '.', '');
    // *     returns 1: 1234.57
    //=====================================
    number_format	: function ( number, decimals, dec_point, thousands_sep )
    {
	var n = number, c = isNaN(decimals = Math.abs(decimals)) ? 2 : decimals;
	var d = dec_point == undefined ? "." : dec_point;
	var t = thousands_sep == undefined ? "," : thousands_sep, s = n < 0 ? "-" : "";
	var i = parseInt(n = Math.abs(+n || 0).toFixed(c)) + "", j = (j = i.length) > 3 ? j % 3 : 0;
	return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "");
    },

    trim : function (chars) {
	return chars.replace (/^\s+/, '').replace (/\s+$/, '');
    }
}