var set = {"lf":true,"lus":true,"los":true,"lh":true,"lua":true,"loa":true,"rf":true,"rus":true,"ros":true,"rh":true,"rua":true,"roa":true};

var vg;

Event.observe(window, 'load', init_app);

function init_app(event) {
	var rules = {
		 '.inp' : function(el) {
		 	el.onkeyup = function() {
		 		bmirechner();
			}
		 },
		 '#alter' : function(el) {
		 	el.onchange = function() {
		 		bmirechner();
			}
		 },

		 '.amputierbar' : function(el) {
		 	el.onclick = function() {
				elemid = el.id;
				if (set[elemid] != false) {
					Element.addClassName(el,'opa');
					amput(el.id);
					set[elemid] = false;	
				} else {
					Element.removeClassName(el,'opa');
					heile(el.id);
					set[elemid] = true;
				}
   			bmirechner();	
		 	}
		 }
	};
	Behaviour.register(rules);
	Behaviour.apply(rules); 
	new Draggable($('leftbox'));
	vg = new jsGraphics("rightbox");
	paintBG(0);
	paintGrid();	
}

function paintGrid() {
	var dims = Element.getDimensions('rightbox');
	var w = dims.width;
	var h = dims.height;
	var min = 15;
	var max = 50;
	for(var i=min;i<max;i++) {
		if (i%5==0) {
			var y = h-h/(max-min)*i+60;
			vg.setColor("#777777"); // rot
			vg.drawLine(15,y, w, y); // Koordinaten auf Zeichenfläche bezogen
			vg.paint(); // zeichnet in diesem Fall direkt in's document
			vg.setFont("arial","9px",Font.PLAIN);
			vg.drawString(i,2,y-3);
			}
	}
}

function paintBMI(bmi) {
	var dims = Element.getDimensions('rightbox');
	var w = dims.width;
	var h = dims.height;
	var min = 15;
	var max = 50;
	vg.setColor("#336666"); 
			
	var y = Math.round(h-h/(max-min)*bmi+60);
	vg.fillEllipse(100, y, 7, 6);  
	vg.paint();
}

function paintBG(o) {
	vg.clear();
	var dims = Element.getDimensions('rightbox');
	var w = dims.width;
	var h = dims.height;
	var min = 15;
	var max = 50;
	vg.setColor("#99ff99"); 
	var y1 = Math.round(h-h/(max-min)*(o+10));
	//alert(o);
	vg.fillRect(20,y1,w-20,25);  
	vg.paint();
}

function bmirechner() {
	var body = set.toJSONString();
	if ($F('kg') < 30) return;
	if ($F('cm') < 100) return;
	new Ajax.Updater('result', './bmirechner.php', {
		parameters:'kg='    + encodeURIComponent($F('kg')) 
				 + '&cm='   + encodeURIComponent($F('cm'))
				 + '&alter='   + encodeURIComponent($F('alter'))
				 
				 + '&body=' + body,
		evalScripts:true, 
		asynchronous:true
	  }		
   );		
}

function amput(id) {
	if (id=='ros') {
		Element.addClassName('rus','opa');
		Element.addClassName('rf','opa');
	}
	if (id=='rus') {
		Element.addClassName('rf','opa');
	}
	if (id=='los') {
		Element.addClassName('lus','opa');
		Element.addClassName('lf','opa');
	}	
	if (id=='lus') {
		Element.addClassName('lf','opa');
	}	
	if (id=='roa') {
		Element.addClassName('rua','opa');
		Element.addClassName('rh','opa');
	}	
	if (id=='loa') {
		Element.addClassName('lua','opa');
		Element.addClassName('lh','opa');
	}	
	if (id=='lua') {
		Element.addClassName('lh','opa');
	}	
	

}

function heile(id) {
	if (id=='rh') {
		Element.removeClassName('rua','opa');
		Element.removeClassName('roa','opa');
	}
	if (id=='lh') {
		Element.removeClassName('lua','opa');
		Element.removeClassName('loa','opa');
	}
	if (id=='lf') {
		Element.removeClassName('lus','opa');
		Element.removeClassName('los','opa');
	}
	if (id=='rf') {
		Element.removeClassName('rus','opa');
		Element.removeClassName('ros','opa');
	}

}



if (!Object.prototype.toJSONString) {

    Array.prototype.toJSONString = function () {
        var a = ['['],  // The array holding the text fragments.
            b,          // A boolean indicating that a comma is required.
            i,          // Loop counter.
            l = this.length,
            v;          // The value to be stringified.

        function p(s) {

// p accumulates text fragments in an array. It inserts a comma before all
// except the first fragment.

            if (b) {
                a.push(',');
            }
            a.push(s);
            b = true;
        }

// For each value in this array...

        for (i = 0; i < l; i += 1) {
            v = this[i];
            switch (typeof v) {

// Serialize a JavaScript object value. Ignore objects thats lack the
// toJSONString method. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

            case 'object':
                if (v) {
                    if (typeof v.toJSONString === 'function') {
                        p(v.toJSONString());
                    }
                } else {
                    p("null");
                }
                break;

// Otherwise, serialize the value.

            case 'string':
            case 'number':
            case 'boolean':
                p(v.toJSONString());

// Values without a JSON representation are ignored.

            }
        }

// Join all of the fragments together and return.

        a.push(']');
        return a.join('');
    };


    Boolean.prototype.toJSONString = function () {
        return String(this);
    };


    Date.prototype.toJSONString = function () {

// Ultimately, this method will be equivalent to the date.toISOString method.

        function f(n) {

// Format integers to have at least two digits.

            return n < 10 ? '0' + n : n;
        }

        return '"' + this.getFullYear() + '-' +
                f(this.getMonth() + 1) + '-' +
                f(this.getDate()) + 'T' +
                f(this.getHours()) + ':' +
                f(this.getMinutes()) + ':' +
                f(this.getSeconds()) + '"';
    };


    Number.prototype.toJSONString = function () {

// JSON numbers must be finite. Encode non-finite numbers as null.

        return isFinite(this) ? String(this) : "null";
    };


    Object.prototype.toJSONString = function () {
        var a = ['{'],  // The array holding the text fragments.
            b,          // A boolean indicating that a comma is required.
            k,          // The current key.
            v;          // The current value.

        function p(s) {

// p accumulates text fragment pairs in an array. It inserts a comma before all
// except the first fragment pair.

            if (b) {
                a.push(',');
            }
            a.push(k.toJSONString(), ':', s);
            b = true;
        }

// Iterate through all of the keys in the object, ignoring the proto chain.

        for (k in this) {
            if (this.hasOwnProperty(k)) {
                v = this[k];
                switch (typeof v) {

// Serialize a JavaScript object value. Ignore objects that lack the
// toJSONString method. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

                case 'object':
                    if (v) {
                        if (typeof v.toJSONString === 'function') {
                            p(v.toJSONString());
                        }
                    } else {
                        p("null");
                    }
                    break;

                case 'string':
                case 'number':
                case 'boolean':
                    p(v.toJSONString());

// Values without a JSON representation are ignored.

                }
            }
        }

// Join all of the fragments together and return.

        a.push('}');
        return a.join('');
    };


    (function (s) {

// Augment String.prototype. We do this in an immediate anonymous function to
// avoid defining global variables.

// m is a table of character substitutions.

        var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        };


        s.parseJSON = function (filter) {
            var j;

            function walk(k, v) {
                var i;
                if (v && typeof v === 'object') {
                    for (i in v) {
                        if (v.hasOwnProperty(i)) {
                            v[i] = walk(i, v[i]);
                        }
                    }
                }
                return filter(k, v);
            }


// Parsing happens in three stages. In the first stage, we run the text against
// a regular expression which looks for non-JSON characters. We are especially
// concerned with '()' and 'new' because they can cause invocation, and '='
// because it can cause mutation. But just to be safe, we will reject all
// unexpected characters.

            if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
                    test(this)) {

// In the second stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.

                try {
                    j = eval('(' + this + ')');
                } catch (e) {
                    throw new SyntaxError("parseJSON");
                }
            } else {
                throw new SyntaxError("parseJSON");
            }

// In the optional third stage, we recursively walk the new structure, passing
// each name/value pair to a filter function for possible transformation.

            if (typeof filter === 'function') {
                j = walk('', j);
            }
            return j;
        };


        s.toJSONString = function () {

// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can simply slap some quotes around it.
// Otherwise we must also replace the offending characters with safe
// sequences.

            if (/["\\\x00-\x1f]/.test(this)) {
                return '"' + this.replace(/([\x00-\x1f\\"])/g, function (a, b) {
                    var c = m[b];
                    if (c) {
                        return c;
                    }
                    c = b.charCodeAt();
                    return '\\u00' +
                        Math.floor(c / 16).toString(16) +
                        (c % 16).toString(16);
                }) + '"';
            }
            return '"' + this + '"';
        };
    })(String.prototype);
}