if (!console) {

	var console;
	
	function createConsole() {
		
		var Dom = YAHOO.util.Dom,
			Event = YAHOO.util.Event,
			Lang = YAHOO.lang;
			
		var console = {
			
			consoleElement: null,
			consoleHeader: null,
			consoleBody: null,
			isVisible: true,
			consoleWith: 250,
			
			render: function() {
				this.consoleElement = document.createElement('div');
				document.body.appendChild(this.consoleElement);
				Dom.setStyle(this.consoleElement, 'position', 'absolute');
				Dom.setStyle(this.consoleElement, 'background-color', '#eeeeee');
				Dom.setStyle(this.consoleElement, 'border', 'solid 1px #888888');
				Dom.setStyle(this.consoleElement, 'padding', '2px');
				Dom.setStyle(this.consoleElement, 'top', '10px');
				Dom.setStyle(this.consoleElement, 'left', (Dom.getDocumentWidth()-this.consoleWith-25)+'px');
				Dom.setStyle(this.consoleElement, 'width', this.consoleWith+'px');
				Dom.setStyle(this.consoleElement, 'height', (Dom.getDocumentHeight()-40)+'px');
				Dom.setStyle(this.consoleElement, 'overflow', 'auto');
				
				Event.addListener(window, 'resize', function(event) {
					Dom.setStyle(this.consoleElement, 'left', (Dom.getDocumentWidth()-this.consoleWith-25)+'px');
				}, null, this)
				
				this.consoleHeader = document.createElement('div');
				this.consoleElement.appendChild(this.consoleHeader);
				Dom.setStyle(this.consoleHeader, 'background-color', '#888888');
				Dom.setStyle(this.consoleHeader, 'padding', '2px');
				Dom.setStyle(this.consoleHeader, 'font-size', '11px');
				Dom.setStyle(this.consoleHeader, 'cursor', 'pointer');
				Dom.setStyle(this.consoleHeader, 'overflow', 'auto');
				this.consoleHeader.innerHTML = '<b>Console</b>';
				
				this.consoleBody = document.createElement('div');
				this.consoleElement.appendChild(this.consoleBody);
				Dom.setStyle(this.consoleBody, 'height', (this.consoleElement.clientHeight-this.consoleHeader.clientHeight-8)+'px');
				Dom.setStyle(this.consoleBody, 'font-size', '9px');
				Dom.setStyle(this.consoleBody, 'overflow', 'auto');
				Event.addListener(this.consoleHeader, 'click', function() {
					(this.isVisible) ? hide() : show();
				}, null, this);
				
				this.hideConsole();
			},
			
			hideConsole: function() {
				this.isVisible = false;
				if (this.consoleElement && this.consoleBody && this.consoleHeader) {
					Dom.setStyle(this.consoleElement, 'top', '-9999px');
					Dom.setStyle(this.consoleElement, 'left', '-9999px');
				}
			},
			
			showConsole: function() {
				this.isVisible = true;
				if (this.consoleElement) {
					Dom.setStyle(this.consoleElement, 'top', '10px');
					Dom.setStyle(this.consoleElement, 'left', (Dom.getDocumentWidth()-this.consoleWith-25)+'px');
				}
			},
			
			log: function(msg) {
				if (this.consoleElement && this.consoleBody) {
					var content = this.consoleBody.innerHTML;
					this.consoleBody.innerHTML = msg+'<br/>'+content;
				}
			},
			info: function(msg) {
				if (this.consoleElement && this.consoleBody) {
					var content = this.consoleBody.innerHTML;
					this.consoleBody.innerHTML = '<b>INFO:</b> '+msg+'<br/>'+content;
				}
			},
			warn: function(msg) {
				if (this.consoleElement && this.consoleBody) {
					var content = this.consoleBody.innerHTML;
//					this.consoleBody.innerHTML = '<b>WARNING:</b> '+msg+'<br/>'+content;
					this.consoleBody.innerHTML = '<div style="background-color: #0ff;"><b>WARNING:</b> '+msg+'</div>'+content;
				}
			},
			error: function(msg) {
				if (this.consoleElement && this.consoleBody) {
					var content = this.consoleBody.innerHTML;
					this.consoleBody.innerHTML = '<div style="color: #f00;"><b>ERROR:</b> '+msg+'</div>'+content;
				}
			}
		};
		
		return console;
	};
	
	YAHOO.util.Event.onDOMReady(function() {
		console = createConsole();
		console.render();
	}); 
	
}


YAHOO.namespace('POTISCOM');

(function() {

	var Dom = YAHOO.util.Dom,
		Event = YAHOO.util.Event,
		Lang = YAHOO.lang;

	var Application = function() {
		
		var _singleton = function() {
		}
	
		_singleton.prototype = {
			
			YUI_SKIN_CLASS: 'yui-skin-sam',
			INIT_PROGRESS_CLASS: 'initializing',
			CSS_CLASS_INVISIBLE: 'invisible',

			fileUploaderUrl: '',

			host: '',
			basePath: '',
			dispatchers: {},
			dialogs: {},
			renderedDialogs: {},
			documentRoot: '',
			applicationPath: '',
			resourceHost: '',
			
			editorLocale: null,
			availableLocales: {},
			fallbackLocale: null,
			
			loader: null,
			loaderEventId: null, // initial loader event id
			
            clickHandlers: {},
            mousedownHandlers: {},
            mouseupHandlers: {},
            mouseoverHandlers: {},
            mouseoutHandlers: {},
            changeHandlers: {},

            currentLocale: 'de',
            loadModulesSilent: false,

			getDispatcher: function(id) {
				id = id || 'default';
				return this.dispatchers[id];
			},
					
			addDispatcher: function(dispatcher, id) {
				id = id || 'default';
				this.dispatchers[id] = dispatcher;
			},
					
			getDispatchers: function() {
				return this.dispatchers;
			},
			
			setDispatchers: function(dispatchers) {
				this.dispatchers = dispatchers;
			},
				
				
				
					
			getDialog: function(id, callback, scope) {
				if (!callback || !scope) {
					throw new Exception('GetDialog: callback and scope must be defined');
				}
				if (!this.renderedDialogs[id]) {
					this.dialogs[id].call(this, callback, scope);
				} else {
					callback.call(scope, this.renderedDialogs[id]);
				}
				
			},
					
			addDialog: function(dialog, id) {
				id = id || 'default';
				this.dialogs[id] = dialog;
			},
					
			getDialogs: function() {
				return this.dialogs;
			},
			
			setDialogs: function(dialogs) {
				this.dialogs = dialogs;
			},
					
					
					
			getHost: function() {
				return this.host;
			},
					
			setHost: function(host) {
				this.host = host;
			},
					
			getBasePath: function() {
				return this.basePath;
			},
					
			setBasePath: function(basePath) {
				this.basePath = basePath;
			},
					
			getDocumentRoot: function() {
				return this.documentRoot;
			},
					
			setDocumentRoot: function(documentRoot) {
				this.documentRoot = documentRoot;
			},
					
			getApplicationPath: function() {
				return this.applicationPath;
			},
					
			setApplicationPath: function(applicationPath) {
				this.applicationPath = applicationPath;
			},
			
			getLoader: function() {
				return this.loader;
			},
					
			initialize: function(config) {
				this.host = config.host || this.host;
				this.basePath = config.basePath || this.basePath;
				this.dispatchers = config.dispatchers || this.dispatchers;
				this.documentRoot = config.documentRoot || this.documentRoot;
				this.applicationPath = config.applicationPath || this.applicationPath;
				this.resourceHost = config.resourceHost || 'http://'+this.host+'/potiscomjsvcl/libs/yui/build/';
				this.loadModulesSilent = config.loadModulesSilent || false;

				var customModuleRegistry = config.customModuleRegistry || null;
				var customModuleRegistries = config.customModuleRegistries || null;
				var loadModules = config.loadModules || [];
				
				this._initLoader(customModuleRegistry, customModuleRegistries, loadModules, this.resourceHost);
			},
			
			_initLoader: function(customModuleRegistry, customModuleRegistries, loadModules, base) {
				var loader;
                if (customModuleRegistry) {
                    loader = new YAHOO.POTISCOM.Loader({
                        addCustomModulesToLoader: [customModuleRegistry],
                        base: base,
                        loadSilent: this.loadModulesSilent
                    });

                } else if (customModuleRegistries) {
                    loader = new YAHOO.POTISCOM.Loader({
                        addCustomModulesToLoader: customModuleRegistries,
                        base: base,
                        loadSilent: this.loadModulesSilent
                    });
                }

				this.loaderEventId = loader.addModuleSet({
					moduleNames: loadModules
				});
				
				this.loader = loader;
			},
			
            getInitModule: function() {
                throw new Exception('Implement this Method');
            },

			initModule: function() {
                var m = this.getInitModule();
                Application.getLoader().load([
                    m.getDependencies()
                ], m.execute, m);
			},
			
			getEditorLocale: function() {
				return this.editorLocale;
			},
			
			setEditorLocale: function(editorLocale) {
				this.editorLocale = editorLocale;
			},
			
			addAvailableLocale: function(locale, name) {
				if (locale && name) {
					this.availableLocales[locale] = name;
				}
			},
			
			getAvailableLocales: function() {
				return this.availableLocales;
			},
			
			getAvailableLocale: function(locale) {
				return this.availableLocales[locale];
			},
			
			setFallbackLocale: function(fallbackLocale) {
				this.fallbackLocale = fallbackLocale;
			},
			
			getFallbackLocale: function() {
				return this.fallbackLocale;
			},



            getCurrentLocale: function() {
                return this.currentLocale;
            },

            setCurrentLocale: function(currentLocale) {
                this.currentLocale = currentLocale;
            },


			execute: function() {
				Event.onDOMReady(function() {
                    this.registerPageEventListeners();

					this.loader[this.loaderEventId].subscribe(function() {
						Dom.removeClass(document.body, this.INIT_PROGRESS_CLASS);
						Dom.addClass(document.body, this.YUI_SKIN_CLASS);
						this.initModule();
					}, null, this);
				
					this.loader.loadModuleSet(this.loaderEventId);
				}, null, this);
			},
	


            /*** CLICK HANDLERS ***********************************************************************************************/
            registerClickPageListener: function() {
                Event.addListener(document, 'click', function(event) {
                    if (this.isValidEventTarget(Event.getTarget(event))) {
                        for (var i in this.clickHandlers) {
                            if (this.clickHandlers.hasOwnProperty(i) && this.clickHandlers[i].handleClick) {
                                this.clickHandlers[i].handleClick.call(this.clickHandlers[i], event);
                            }
                        }
                    }
                }, null, this);
            },

            addClickHandler: function(name, handler) {
                this.clickHandlers[name] = handler;
            },

            removeClickHandler: function(name) {
                if (this.clickHandlers.hasOwnProperty(name)) {
                    delete(this.clickHandlers[name]);
                }
            },



            /*** MOUSEDOWN HANDLERS *******************************************************************************************/
            registerMousedownPageListener: function() {
                Event.addListener(document, 'mousedown', function(event) {
                    if (this.isValidEventTarget(Event.getTarget(event))) {
                        for (var i in this.mousedownHandlers) {
                            if (this.mousedownHandlers.hasOwnProperty(i) && this.mousedownHandlers[i].handleMousedown) {
                                this.mousedownHandlers[i].handleMousedown.call(this.mousedownHandlers[i], event);
                            }
                        }
                    }
                }, null, this);
            },

            addMousedownHandler: function(name, handler) {
                this.mousedownHandlers[name] = handler;
            },

            removeMousedownHandler: function(name) {
                if (this.mousedownHandlers.hasOwnProperty(name)) {
                    delete(this.mousedownHandlers[name]);
                }
            },



            /*** MOUSEUP HANDLERS *********************************************************************************************/
            registerMouseupPageListener: function() {
                Event.addListener(document, 'mouseup', function(event) {
                    if (this.isValidEventTarget(Event.getTarget(event))) {
                        for (var i in this.mouseupHandlers) {
                            if (this.mouseupHandlers.hasOwnProperty(i) && this.mouseupHandlers[i].handleMouseup) {
                                this.mouseupHandlers[i].handleMouseup.call(this.mouseupHandlers[i], event);
                            }
                        }
                    }
                }, null, this);
            },

            addMouseupHandler: function(name, handler) {
                this.mouseupHandlers[name] = handler;
            },

            removeMouseupHandler: function(name) {
                if (this.mouseupHandlers.hasOwnProperty(name)) {
                    delete(this.mouseupHandlers[name]);
                }
            },



            /*** CHANGE HANDLERS *******************************************************************************************/
            registerChangePageListener: function() {
                Event.addListener(document, 'change', this._handleChangeEvent, null, this);
            },

            _handleChangeEvent: function(event) {
                for (var i in this.changeHandlers) {
                    if (this.changeHandlers.hasOwnProperty(i) && this.changeHandlers[i].handleChange) {
                        this.changeHandlers[i].handleChange.call(this.changeHandlers[i], event);
                    }
                }
            },

            registerIeChangePageListener: function() {
//                Event.addListener(document, 'mousedown', this._handleIeChangeDownEvent, null, this);
//                Event.addListener(document, 'mouseup', this._handleIeChangeUpEvent, null, this);

                Event.addListener(document, 'click', this._handleIeChangeUpEvent, null, this);

//                Event.addListener(document, 'keyup', this._handleIeChangeEvent, null, this);
            },

            ieChangeSelectValues: {},

            _handleIeChangeDownEvent: function(event) {
//                var element = Event.getTarget(event);
//                var item = element;
//                if (element.tagName.toUpperCase()==='OPTION') {
//                    item = element.parentNode;
//                }
//                var tagName = item.tagName;
//                var changed = false;
//                if (tagName==='SELECT') {
//                    if (!this.ieChangeSelectValues[item.id]) {
////                        this.ieChangeSelectValues[item.id] = item.value;
//                    }
//                }
            },

            _handleIeChangeUpEvent: function(event) {
                var element = Event.getTarget(event);
                var item = element;
                if (element.tagName.toUpperCase()==='OPTION') {
                    item = element.parentNode;
                }

                var tagName = item.tagName;
                var changed = false;
                if (tagName==='SELECT') {
                    if (this.ieChangeSelectValues[item.id] && this.ieChangeSelectValues[item.id]!==item.value) {
                        this.ieChangeSelectValues[item.id] = null;
                        changed = true;
                    } else if (this.ieChangeSelectValues[item.id] && this.ieChangeSelectValues[item.id]===item.value) {
//                        this.ieChangeSelectValues[item.id] = null;
                    } else {
                        this.ieChangeSelectValues[item.id] = item.value;
                    }
                }

                if (changed) {
                    this._handleChangeEvent(event);
                }
            },
            
            addChangeHandler: function(name, handler) {
                this.changeHandlers[name] = handler;
            },

            removeChangeHandler: function(name) {
                if (this.changeHandlers.hasOwnProperty(name)) {
                    delete(this.changeHandlers[name]);
                }
            },

            

            /*** MOUSEOVER HANDLERS *******************************************************************************************/
            registerMouseoverPageListener: function() {
                Event.addListener(document, 'mouseover', function(event) {
                    if (this.isValidEventTarget(Event.getTarget(event), true)) {
                        for (var i in this.mouseoverHandlers) {
                            if (this.mouseoverHandlers.hasOwnProperty(i) && this.mouseoverHandlers[i].handleMouseover) {
                                this.mouseoverHandlers[i].handleMouseover.call(this.mouseoverHandlers[i], event);
                            }
                        }
                    }
                }, null, this);
            },

            addMouseoverHandler: function(name, handler) {
                this.mouseoverHandlers[name] = handler;
            },

            removeMouseoverHandler: function(name) {
                if (this.mouseoverHandlers.hasOwnProperty(name)) {
                    delete(this.mouseoverHandlers[name]);
                }
            },



            /*** MOUSEOUT HANDLERS ********************************************************************************************/
            registerMouseoutPageListener: function() {
                Event.addListener(document, 'mouseout', function(event) {
                    if (this.isValidEventTarget(Event.getTarget(event), true)) {
                        for (var i in this.mouseoutHandlers) {
                            if (this.mouseoutHandlers.hasOwnProperty(i) && this.mouseoutHandlers[i].handleMouseout) {
                                this.mouseoutHandlers[i].handleMouseout.call(this.mouseoutHandlers[i], event);
                            }
                        }
                    }
                }, null, this);
            },

            addMouseoutHandler: function(name, handler) {
                this.mouseoutHandlers[name] = handler;
            },

            removeMouseoutHandler: function(name) {
                if (this.mouseoutHandlers.hasOwnProperty(name)) {
                    delete(this.mouseoutHandlers[name]);
                }
            },



            /*** PAGE EVENT HANDLER HELPERS ***********************************************************************************/
            registerPageEventListeners: function() {
                this.registerClickPageListener();
                this.registerMousedownPageListener();
                this.registerMouseupPageListener();
                this.registerMouseoverPageListener();
                this.registerMouseoutPageListener();
                (YAHOO.env.ua.ie) ? this.registerIeChangePageListener() : this.registerChangePageListener();
            },

            isValidEventTarget: function(element, doNotFocusElement) {
                if (element.tagName.toUpperCase()==='TEXTAREA') {
                    if (!element.id || element.id.match('_override'+"$")!='_override') {
                        if (!doNotFocusElement) {
                            element.focus();
                        }
                        return false;
                    }
                }

                if (element.tagName.toUpperCase()==='INPUT' && element.type.toUpperCase()==='TEXT') {
                    if (!doNotFocusElement) {
                        element.focus();
                    }
                    return false;
                }

                if (element.tagName.toUpperCase()==='INPUT' && element.type.toUpperCase()==='CHECKBOX') {
                    return false;
                }

                if (element.tagName.toUpperCase()==='INPUT' && element.type.toUpperCase()==='RADIO') {
                    return false;
                }

                return true;
            }

		}
		
		return new _singleton();
	} ();
	
	YAHOO.POTISCOM.Application = Application;
	
})();

YAHOO.register('POTISCOM.Application', YAHOO.POTISCOM.Application, {version: "0.1", build: '1'});

YAHOO.namespace('POTISCOM');

(function() {
	
	var Dom = YAHOO.util.Dom,
		Event = YAHOO.util.Event,
		Lang = YAHOO.lang,
		Application = YAHOO.POTISCOM.Application;

	var Loader = function(config) {
		config = config || {};
		this.init(config);
	};

	Loader.prototype = {
		
		yuiLoader: null,
		moduleSetsCount: 0,
		moduleSets: {},
		currentModuleSet: {},
		moduleSetsToLoad: [],
		loadInProgress: false,
        loadSilent: false,
		
		/**
		 * overwrite this method in the config object
		 * @param {Object} ldr
		 */
		addCustomModulesToLoader: function(yuiLoader) {},
		
		init: function(config) {

            this.loadSilent = config.loadSilent || false;

			loaderConfig = {
				allowRollup: true,
				loadOptional: true,
				timeout: 10000,
				base: config.base,
				//comboBase: '/combo/?b=libs&f=',
				//filter: { 
		        //	'searchExp': /&2/g,  
		        //	'replaceStr': ",2" 
		    	//},
				//skin: { 
			    //    defaultSkin: 'sam',  
			    //    base: 'assets/skins/', 
			    //    path: 'skin.css', 
			    //    rollup: 1 
			    //},
				combine: false
			};
			
			
			this.yuiLoader = new YAHOO.util.YUILoader(loaderConfig);

			var closureThis = this;
			this.yuiLoader.onProgress = function(o) {
				closureThis.onProgress(o);
			}; 
			this.yuiLoader.onSuccess = function() {
				closureThis.onSuccess();
			}; 
			this.yuiLoader.onFailure = function(o) {
				closureThis.onFailure(o);
			}; 


			this.addCustomModulesToLoader = config.addCustomModulesToLoader || this.addCustomModulesToLoader;
			YAHOO.POTISCOM.addModulesToLoader(this.yuiLoader);
            for (var i in this.addCustomModulesToLoader) {
                if (this.addCustomModulesToLoader.hasOwnProperty(i)) {
                    this.addCustomModulesToLoader[i](this.yuiLoader);
                }
            }
		},
		
		
		addModuleSet: function(loadDefinition) {
			this.moduleSetsCount += 1;
			var eventName = 'ModuleSetsChain_'+this.moduleSetsCount;
			var event = new YAHOO.util.CustomEvent('subcategorySelected', this);
			event.signature = YAHOO.util.CustomEvent.FLAT;

			loadDefinition.moduleNames = loadDefinition.moduleNames || [];
			loadDefinition.eventName = eventName;
			
			this.moduleSets[eventName] = loadDefinition;
			this[eventName] = event;

			return eventName;
		},
		
		loadModuleSet: function(eventId) {
            if (!Dom.hasClass(document.body, 'initializing')) {
                Dom.addClass(document.body, 'moduleprogress');
            }
			if (!this.loadInProgress>0 && this.moduleSets[eventId]) {
				this.loadInProgress = 1;
                this.showLoadingDialog();
				this.currentModuleSet = this.moduleSets[eventId];
				this._loadModuleSet();				
			} else {
				this.moduleSetsToLoad.push(eventId);
			}
		},

		_loadModuleSet: function() {
			var mSet = this.currentModuleSet;
			for (var i in mSet.moduleNames) {
				if (mSet.moduleNames.hasOwnProperty(i)) {
					this.yuiLoader.require(mSet.moduleNames[i]);
				}
			}
			this.yuiLoader.insert(null, 'js');
		},
		
		showLoadingDialog: function() {
            if (YAHOO.POTISCOM.Tools && !this.loadSilent) {
                YAHOO.POTISCOM.Tools.disableElement('SYSTEM_WINDOW', true);
            }
		},
		
		hideLoadingDialog: function() {
            if (YAHOO.POTISCOM.Tools && !this.loadSilent) {
                YAHOO.POTISCOM.Tools.enableElement('SYSTEM_WINDOW');
            }
		},
		
		onProgress: function(o) {
			console.log("Module loaded: " + o.name);
		},

		onSuccess: function() {
			this.loadInProgress -= 1;
			var mSet = this.currentModuleSet;
			this[mSet.eventName].fire();

            if (this.loadInProgress<=0) {
                this.hideLoadingDialog();
            }
		},
	
		onFailure: function(o) {
			console.error('Failed to load module\n'+Lang.dump(o));
		},
		
		load: function(dependencies, callback, scope) {
			var eventId = this.addModuleSet({
				moduleNames: dependencies
			});
			this[eventId].subscribe(callback, null, scope);
			this.loadModuleSet(eventId);
		}			
		
	}
	
	YAHOO.POTISCOM.Loader = Loader;
	
})();


YAHOO.namespace('POTISCOM');
//YAHOO.namespace('POTISCOM.Singletons');

(function() {

	var Dom = YAHOO.util.Dom,
		Event = YAHOO.util.Event,
		Lang = YAHOO.lang,
		Application = YAHOO.POTISCOM.Application;

	var Tools = function() {
		
		var _singleton = function() {
		}
	
		_singleton.prototype = {

			/**
			 * 
			 * @param {Object} containerId
			 */
			collectSubmittables_OLD: function(containerId) {
				var data = [];
				var item = 0;
				if(containerId) {
					Dom.getElementsByClassName('submittable', null, containerId, function(elem) {
					var elemName = elem.name;
					if(!elem.disabled && elemName) {
						elemName = encodeURIComponent(elemName) + '=';
						switch(elem.type) {
						case 'radio':
						case 'checkbox':
							if(elem.checked){
								data[item++] = elemName + encodeURIComponent(elem.value);
							}
							break;
							 default:
								 data[item++] = elemName + encodeURIComponent(elem.value); 
						 }
					 }
					 });
				}
				data = data.join('&');

				Conn.asyncRequest(method, url, {
					success: function(o)  {
						// ...
					}
				}, data);			
			},

			/**
			 * 
			 * @param {Object} containerId
			 */
			collectSubmittables: function(containerId) {
				var result = {};
				var elements = YAHOO.util.Selector.query('#'+containerId+' .submittable');
				elements.each(function(submittable) {
					if (submittable.type=='checkbox') {
						var resultKey = submittable.name || submittable.id;
						result[resultKey] = submittable.checked;
					} else if (submittable.value!=undefined) {
						var resultKey = submittable.name || submittable.id;
						result[resultKey] = submittable.value;
					} else {
						result[submittable.id] = submittable.innerHTML;
					}
				});
				return result;
			},

            collectSubmittables_Michi: function(containerId) {
                var data = [];
                if(containerId) {
                    var item = 0;
                    Dom.getElementsByClassName('submittable', null, containerId, function(elem) {
                        var elemName = elem.name;
                        if(!elem.disabled && elemName) {
                            elemName = encodeURIComponent(elemName) + '=';
                            switch(elem.type) {
                                case 'radio':
                                case 'checkbox':
                                    if(elem.checked){
                                        data[item++] = elemName + encodeURIComponent(elem.value);
                                    }
                                    break;

                                default:
                                    data[item++] = elemName + encodeURIComponent(elem.value);
                            }
                        }
                    });
                }
                return data.join('&');
            },

			/**
			 * 
			 * @param {Object} element
			 * @param {Object} contents
			 */			
			cloneElement: function(element) {
                if (!Dom.hasClass(element, 'clonable')) {
                    var clonedElement = document.createElement('div');
                    var reg = Dom.getRegion(element);
                    Dom.setStyle(clonedElement, 'width', (reg.right-reg.left)+'px');
                    Dom.setStyle(clonedElement, 'height', (reg.bottom-reg.top)+'px');
                    Dom.addClass(clonedElement, 'draggingproxy');
                    return clonedElement;
                }
                
                function removeId(element) {
                    if (element.removeAttribute) {
                        element.removeAttribute('id');
                    }
                    for (var i=0, k=element.childNodes.length; i<k; i++) {
                        removeId(element.childNodes[i]);
                    }
                }

                var clonedElement = element.cloneNode(true);
                var toRemove = [];
                for (var i = 0, k = clonedElement.childNodes.length; i < k; i++) {
                    if (clonedElement.childNodes[i].className && clonedElement.childNodes[i].className.indexOf('yui-module')>=0) {
                        toRemove.push(clonedElement.childNodes[i]);
                    }
                }
                for (var i = 0, k = toRemove.length; i < k; i++) {
                    clonedElement.removeChild(toRemove[i]);
                }
                removeId(clonedElement);
                Dom.addClass(clonedElement, 'cloneddraggingproxy');
                return clonedElement;
			},
			
			isInputElement: function(element, autofocus) {
				if (element.tagName.toUpperCase()==='TEXTAREA') {
					if (autofocus) {
						element.focus();
					}
					return true;
				}
				
				if (element.tagName.toUpperCase()==='INPUT' && element.type.toUpperCase()==='TEXT') {
					if (autofocus) {
						element.focus();
					}
					return true;
				}
				
				if (element.tagName.toUpperCase()==='SELECT' || element.tagName.toUpperCase()==='OPTION') {
					return true;
				}
			},
			
			getCommandObject: function(elementId) {
                var element = Dom.get(elementId);
				if (!element.id) {
					Dom.generateId(element, 'yui-gen-');
				}
				return YAHOO.util.Selector.query('#'+element.id+' > div.commandobject', element.parentNode, true);
			},

			getCommand: function(commandObjectId, name) {
                var commandObject = Dom.get(this.getCommandObject(commandObjectId));

                if (commandObject) {
                    var el = Dom.getFirstChildBy(commandObject, function(element) {
                        return element.name == name;
                    });

                    if (el) {
                        return (el.value) ? el.value : '';
                    }
                    throw 'YAHOO.POTISCOM.Module: Command with name '+name+' not found';
                }

                throw 'YAHOO.POTISCOM.Module: No command object found for this module';
            },

			getCommando: function(commandObjectId, name) {
                return this.getCommand(commandObjectId, name);
			},

			setCommand: function(commandObjectId, name, newValue) {
				var commandObject = Dom.get(this.getCommandObject(commandObjectId));
				
				if (commandObject) {
					var el = Dom.getFirstChildBy(commandObject, function(element) {
						return element.name == name;
					});
					
					if (el) {
						el.value = newValue;
						return true;
					} else {
						var cmd = document.createElement('input');
						cmd.type = "text";
						cmd.value = newValue;
						commandObject.appendChild(cmd);
						return true;
					}
					throw 'YAHOO.POTISCOM.Module: Command with name '+name+' not found';
				}
				
				throw 'YAHOO.POTISCOM.Module: No command object found for this module';
			},

            setCommando: function(commandObjectId, name, newValue) {
                this.setCommand(commandObjectId, name, newValue);
            },

            blockers: {},

			disableElement: function(id, dark) {
//				var element = Dom.get(id);
//				Dom.addClass(id, 'containerloading');

                if (!YAHOO.widget.Overlay) {
                    return;
                }

                var over;
                if (id==='SYSTEM_WINDOW') {
//                    var w = Dom.getClientWidth();
//                    var h = Dom.getClientHeight();
                    over = new YAHOO.widget.Overlay('SYSTEM_WINDOW', {
                        visible: true,
                        xy: [0,0]
//                        width: '100%',
//                        height: '100%',
//                        width: '5px',
//                        height: '5px'
//                        constraintoviewport: true,
//                        fixedcenter: true,
//                        context: [document.body, 'tl', 'tl']
//                        width: w+'px',
//                        height: h+'px'
                    });

                    this.blockers['SYSTEM_WINDOW'] = over;

                    if (dark) {
                        over.setBody('<div class="progressdark" style="position: fixed; width: 100%; height: 100%;"></div>');
                    } else {
                        over.setBody('<div class="progress" style="position: fixed; width: 100%; height: 100%;">&nbsp;</div>');
                    }
                    over.render(document.body);

                } else {
                    id = Dom.get(id);
                    if (!id.id) {
                        Dom.generateId(id, 'yui-gen-');
                    }
                    var reg = Dom.getRegion(id);
                    var w = reg.right-reg.left;
                    var h = reg.bottom-reg.top;

                    if (this.blockers.hasOwnProperty(id.id)) {
                        over = this.blockers[id.id];
                        over.cfg.setProperty('width', w+'px');
                        over.cfg.setProperty('height', h+'px');
                    } else {
                        var newId = id.id+'-blocker';

                        over = new YAHOO.widget.Overlay(newId, {
                            context:[id, 'tl', 'tl', ['beforeShow', 'windowResize']],
                            visible: true,
                            width: w+'px',
                            height: h+'px'
                        });

                        this.blockers[id.id] = over;

                        if (dark) {
                            over.setBody('<div class="progressdark"></div>');
                        } else {
                            over.setBody('<div class="progress">&nbsp;</div>');
                        }
                        over.render(document.body);
                    }
                }
                over.show();
                over.bringToTop();
			},
			
			enableElement: function(id) {
                var lookupId = id;
                if (id!=='SYSTEM_WINDOW') {
                    id = Dom.get(id);
                    if (!id.id) {
                        Dom.generateId(id, 'yui-gen-');
                    }
                    lookupId = id.id;
                } else {

                }
                if (this.blockers.hasOwnProperty(lookupId)) {
                    var over = this.blockers[lookupId];
                    over.hide();
                }
			},



            /**
             * @param element
             * @param command optional
             */
			isDoHandler: function(element, command) {
				if (!element.id) {
					return false;
				}
				var params = element.id.split('_');
				
				if (params.length <= 0) {
					return false;
				}
				
				if (params[0].toLowerCase() != 'do') {
					return false;
				}
				if (!command) {
					return true;
				}
				if (params[1].toLowerCase() === command.toLowerCase()) {
					return true;
				}
				return false;
			},

            /**
             * @param element
             * @param command optional
             */
			getDoHandler: function(element, command) {
				if (this.isDoHandler(element, command)) {
					return element;
				}
				while (element.parentNode) {
					return this.getDoHandler(element.parentNode, command);
				}
				return undefined;
			},

            /**
             * @param String id
             * @return array
             */
            tokenizeDoHandler: function(id) {
                var elementId = id.replace('-button', '');
                return elementId.split('_');
            },

			getInternalDerefer: function(href) {
                throw 'Method deprecated';
			},
			
			showContainer: function(containerOrId) {
                throw 'Method deprecated';
			},
			
			hideContainer: function(containerOrId) {
                throw 'Method deprecated';
			},
			
			isContainerVisible: function(containerOrId) {
                throw 'Method deprecated';
			},
			
			arrayContains: function(arr, obj) {
			     var i, listed = false;
			     for (i=0; i<arr.length; i++) {
			       if (arr[i] === obj) {
			         return true;
			       }
			     }
			     return false;
			},
			
            /**
             * Sends a request and calls callback afterwards
             *
             * @param string url
             * @param string method
             * @param {Object} callback
             * @param {Object} data
             */
            sendRequest: function(url, method, callback, data) {
                if (!url) {
                    throw 'YAHOO.POTISCOM.Tools.sendReqest(): Required parameter "url" not specified.';
                }
                if (!method) {
                    var method = 'get';
                }

                if (data) {
                    data = $H(data); // BAD Mootools function
                    if (method.toLowerCase() !== 'post') {
                        url = url + '?' + data.toQueryString();
                        var data = undefined;
                    }
                    else {
                        var data = data.toQueryString();
                    }
                }
                YAHOO.util.Connect.asyncRequest(method, url, callback, data);
            },

			/**
			 * Executes request and updates a container.
			 * 
			 * @todo: ADD A ADDITINAL CALLBACK (like finally)
			 * @todo: generate container id automatically
			 * 
			 * @param string|element container
			 * @param string url
			 * @param string method
			 * @param object data
			 */
			execRequest: function(container, url, method, data, customCallback, customCallbackParams, scope) {
				container = Dom.get(container);
				var callback = { 
					success: function(o) {
						Tools.updateContainer(container, o.responseText);
						if (customCallback) {
							customCallback.call(this, customCallbackParams, o.responseText);
						}
						Tools.enableElement(container, true);
					}, 
					failure: function(o) {
						console.warn('REQUEST FAILED!');
					}, 
					scope: scope
				} 
				
				Tools.disableElement(container);
				
				if (!method) {
					var method = 'get';
				}
				
				//if (typeof(data)=='string' && data.indexOf('testform')==0) {
				if (typeof(data)=='string' && Dom.get(data).tagName && Dom.get(data).tagName.toUpperCase()=='FORM') {
					var formObject = Dom.get(data);
					YAHOO.util.Connect.setForm(formObject);
					var request = YAHOO.util.Connect.asyncRequest(method, url, callback);
				} else {
					if (data) {
						data = $H(data); // BAD Mootools function
						if (method.toLowerCase() !== 'post') {
							url = url + '?' + data.toQueryString();
							var data = undefined;
						} else {
							var data = data.toQueryString();
						}
					}
					var request = YAHOO.util.Connect.asyncRequest(method, url, callback, data);
				}
                return request;
			},

            cancelRequest: function(request) {
                return YAHOO.util.Connect.abort(request);
            },
			
			/**
			 * Injects HTML content into a container.
			 * 
			 * @param string|element container
			 * @param string content
			 */
			updateContainer: function(container, content) {
				var div = Dom.get(container);
				if (content !== undefined) {
					div.innerHTML = content;
				}
			},

            reportError: function(msg) {
                console.error('EXCEPTION: '+msg);
            },

            getDraggableElement: function(elementOrDraghandle) {
                throw 'Mehtod deprecated - moved into DragDropManager';
            },

            getAncestorByClassName: function(elementOrId, className) {
                if (Dom.hasClass(elementOrId, className)) {
                    return elementOrId;
                }
                return Dom.getAncestorByClassName(elementOrId, className);
            },

            hasAncestor: function(element, ancestor) {
                var parent = YAHOO.util.Dom.getAncestorBy(element, function(node) {
                    return node === ancestor;
                });
                return (parent) ? true : false;
            },

            findMenuItemById: function(itemId, yuiMenu) {
                var items = yuiMenu.getItems();
                for (var i in items) {
                    if (items.hasOwnProperty(i)) {
                        if (items[i].id && items[i].id===itemId) {
                            return items[i];
                        }
                        var submenu = items[i].cfg.getProperty('submenu');
                        if (submenu) {
                            var result = this.findMenuItemById(itemId, submenu);
                            if (result) {
                                return result;
                            }
                        }
                    }
                }
                return false;
            }

		}
		
		return new _singleton();
	} ();
	
	YAHOO.POTISCOM.Tools = Tools;
	
})();

YAHOO.register('POTISCOM.Tools', YAHOO.POTISCOM.Tools, {version: "0.1", build: '1'});

/*
Script: Core.js
	MooTools - My Object Oriented JavaScript Tools.

License:
	MIT-style license.

Copyright:
	Copyright (c) 2006-2007 [Valerio Proietti](http://mad4milk.net/).

Code & Documentation:
	[The MooTools production team](http://mootools.net/developers/).

Inspiration:
	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2006 Dean Edwards, [GNU Lesser General Public License](http://opensource.org/licenses/lgpl-license.php)
	- Some functionality inspired by [Prototype.js](http://prototypejs.org) Copyright (c) 2005-2007 Sam Stephenson, [MIT License](http://opensource.org/licenses/mit-license.php)
*/

var MooTools = {
	'version': '1.2.0',
	'build': ''
};
      
var Native = function(options){
	options = options || {};

	var afterImplement = options.afterImplement || function(){};
	var generics = options.generics;
	generics = (generics !== false);
	var legacy = options.legacy;
	var initialize = options.initialize;
	var protect = options.protect;
	var name = options.name;

	var object = initialize || legacy;

	object.constructor = Native;
	object.$family = {name: 'native'};
	if (legacy && initialize) object.prototype = legacy.prototype;
	object.prototype.constructor = object;

	if (name){
		var family = name.toLowerCase();
		object.prototype.$family = {name: family};
		Native.typize(object, family);
	}

	var add = function(obj, name, method, force){
		if (!protect || force || !obj.prototype[name]) obj.prototype[name] = method;
		if (generics) Native.genericize(obj, name, protect);
		afterImplement.call(obj, name, method);
		return obj;
	};
	
	object.implement = function(a1, a2, a3){
		if (typeof a1 == 'string') return add(this, a1, a2, a3);
		for (var p in a1) add(this, p, a1[p], a2);
		return this;
	};
	
	object.alias = function(a1, a2, a3){
		if (typeof a1 == 'string'){
			a1 = this.prototype[a1];
			if (a1) add(this, a2, a1, a3);
		} else {
			for (var a in a1) this.alias(a, a1[a], a2);
		}
		return this;
	};

	return object;
};

Native.implement = function(objects, properties){
	for (var i = 0, l = objects.length; i < l; i++) objects[i].implement(properties);
};

Native.genericize = function(object, property, check){
	if ((!check || !object[property]) && typeof object.prototype[property] == 'function') object[property] = function(){
		var args = Array.prototype.slice.call(arguments);
		return object.prototype[property].apply(args.shift(), args);
	};
};

Native.typize = function(object, family){
	if (!object.type) object.type = function(item){
		return ($type(item) === family);
	};
};

Native.alias = function(objects, a1, a2, a3){
	for (var i = 0, j = objects.length; i < j; i++) objects[i].alias(a1, a2, a3);
};

(function(objects){
	for (var name in objects) Native.typize(objects[name], name);
})({'boolean': Boolean, 'native': Native, 'object': Object});

(function(objects){
	for (var name in objects) new Native({name: name, initialize: objects[name], protect: true});
})({'String': String, 'Function': Function, 'Number': Number, 'Array': Array, 'RegExp': RegExp, 'Date': Date});

(function(object, methods){
	for (var i = methods.length; i--; i) Native.genericize(object, methods[i], true);
	return arguments.callee;
})
(Array, ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice', 'toString', 'valueOf', 'indexOf', 'lastIndexOf'])
(String, ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'match', 'replace', 'search', 'slice', 'split', 'substr', 'substring', 'toLowerCase', 'toUpperCase', 'valueOf']);

function $chk(obj){
	return !!(obj || obj === 0);
};

function $clear(timer){
	clearTimeout(timer);
	clearInterval(timer);
	return null;
};

function $defined(obj){
	return (obj != undefined);
};

function $empty(){};

function $arguments(i){
	return function(){
		return arguments[i];
	};
};

function $lambda(value){
	return (typeof value == 'function') ? value : function(){
		return value;
	};
};

function $extend(original, extended){
	for (var key in (extended || {})) original[key] = extended[key];
	return original;
};

function $unlink(object){
	var unlinked;
	
	switch ($type(object)){
		case 'object':
			unlinked = {};
			for (var p in object) unlinked[p] = $unlink(object[p]);
		break;
		case 'hash':
			unlinked = $unlink(object.getClean());
		break;
		case 'array':
			unlinked = [];
			for (var i = 0, l = object.length; i < l; i++) unlinked[i] = $unlink(object[i]);
		break;
		default: return object;
	}
	
	return unlinked;
};

function $merge(){
	var mix = {};
	for (var i = 0, l = arguments.length; i < l; i++){
		var object = arguments[i];
		if ($type(object) != 'object') continue;
		for (var key in object){
			var op = object[key], mp = mix[key];
			mix[key] = (mp && $type(op) == 'object' && $type(mp) == 'object') ? $merge(mp, op) : $unlink(op);
		}
	}
	return mix;
};

function $pick(){
	for (var i = 0, l = arguments.length; i < l; i++){
		if (arguments[i] != undefined) return arguments[i];
	}
	return null;
};

function $random(min, max){
	return Math.floor(Math.random() * (max - min + 1) + min);
};

function $splat(obj){
	var type = $type(obj);
	return (type) ? ((type != 'array' && type != 'arguments') ? [obj] : obj) : [];
};

var $time = Date.now || function(){
	return new Date().getTime();
};

function $try(){
	for (var i = 0, l = arguments.length; i < l; i++){
		try {
			return arguments[i]();
		} catch(e){}
	}
	return null;
};

function $type(obj){
	if (obj == undefined) return false;
	if (obj.$family) return (obj.$family.name == 'number' && !isFinite(obj)) ? false : obj.$family.name;
	if (obj.nodeName){
		switch (obj.nodeType){
			case 1: return 'element';
			case 3: return (/\S/).test(obj.nodeValue) ? 'textnode' : 'whitespace';
		}
	} else if (typeof obj.length == 'number'){
		if (obj.callee) return 'arguments';
		else if (obj.item) return 'collection';
	}
	return typeof obj;
};

var Hash = new Native({

	name: 'Hash',

	initialize: function(object){
		if ($type(object) == 'hash') object = $unlink(object.getClean());
		for (var key in object) this[key] = object[key];
		return this;
	}

});

Hash.implement({
	
	getLength: function(){
		var length = 0;
		for (var key in this){
			if (this.hasOwnProperty(key)) length++;
		}
		return length;
	},

	forEach: function(fn, bind){
		for (var key in this){
			if (this.hasOwnProperty(key)) fn.call(bind, this[key], key, this);
		}
	},
	
	getClean: function(){
		var clean = {};
		for (var key in this){
			if (this.hasOwnProperty(key)) clean[key] = this[key];
		}
		return clean;
	}

});

Hash.alias('forEach', 'each');

function $H(object){
	return new Hash(object);
};

Array.implement({

	forEach: function(fn, bind){
		for (var i = 0, l = this.length; i < l; i++) fn.call(bind, this[i], i, this);
	}

});

Array.alias('forEach', 'each');

function $A(iterable){
	if (iterable.item){
		var array = [];
		for (var i = 0, l = iterable.length; i < l; i++) array[i] = iterable[i];
		return array;
	}
	return Array.prototype.slice.call(iterable);
};

function $each(iterable, fn, bind){
	var type = $type(iterable);
	((type == 'arguments' || type == 'collection' || type == 'array') ? Array : Hash).each(iterable, fn, bind);
};


/*
Script: Browser.js
	The Browser Core. Contains Browser initialization, Window and Document, and the Browser Hash.

License:
	MIT-style license.
*/

var Browser = new Hash({
	Engine: {name: 'unknown', version: ''},
	Platform: {name: (navigator.platform.match(/mac|win|linux/i) || ['other'])[0].toLowerCase()},
	Features: {xpath: !!(document.evaluate), air: !!(window.runtime)},
	Plugins: {}
});

if (window.opera) Browser.Engine = {name: 'presto', version: (document.getElementsByClassName) ? 950 : 925};
else if (window.ActiveXObject) Browser.Engine = {name: 'trident', version: (window.XMLHttpRequest) ? 5 : 4};
else if (!navigator.taintEnabled) Browser.Engine = {name: 'webkit', version: (Browser.Features.xpath) ? 420 : 419};
else if (document.getBoxObjectFor != null) Browser.Engine = {name: 'gecko', version: (document.getElementsByClassName) ? 19 : 18};
Browser.Engine[Browser.Engine.name] = Browser.Engine[Browser.Engine.name + Browser.Engine.version] = true;

if (window.orientation != undefined) Browser.Platform.name = 'ipod';

Browser.Platform[Browser.Platform.name] = true;

Browser.Request = function(){
	return $try(function(){
		return new XMLHttpRequest();
	}, function(){
		return new ActiveXObject('MSXML2.XMLHTTP');
	});
};

Browser.Features.xhr = !!(Browser.Request());

Browser.Plugins.Flash = (function(){
	var version = ($try(function(){
		return navigator.plugins['Shockwave Flash'].description;
	}, function(){
		return new ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version');
	}) || '0 r0').match(/\d+/g);
	return {version: parseInt(version[0] || 0 + '.' + version[1] || 0), build: parseInt(version[2] || 0)};
})();

function $exec(text){
	if (!text) return text;
	if (window.execScript){
		window.execScript(text);
	} else {
		var script = document.createElement('script');
		script.setAttribute('type', 'text/javascript');
		script.text = text;
		document.head.appendChild(script);
		document.head.removeChild(script);
	}
	return text;
};

Native.UID = 1;

var $uid = (Browser.Engine.trident) ? function(item){
	return (item.uid || (item.uid = [Native.UID++]))[0];
} : function(item){
	return item.uid || (item.uid = Native.UID++);
};

var Window = new Native({

	name: 'Window',

	legacy: (Browser.Engine.trident) ? null: window.Window,

	initialize: function(win){
		$uid(win);
		if (!win.Element){
			win.Element = $empty;
			if (Browser.Engine.webkit) win.document.createElement("iframe"); //fixes safari 2
			win.Element.prototype = (Browser.Engine.webkit) ? window["[[DOMElement.prototype]]"] : {};
		}
		return $extend(win, Window.Prototype);
	},

	afterImplement: function(property, value){
		window[property] = Window.Prototype[property] = value;
	}

});

Window.Prototype = {$family: {name: 'window'}};

new Window(window);

var Document = new Native({

	name: 'Document',

	legacy: (Browser.Engine.trident) ? null: window.Document,

	initialize: function(doc){
		$uid(doc);
		doc.head = doc.getElementsByTagName('head')[0];
		doc.html = doc.getElementsByTagName('html')[0];
		doc.window = doc.defaultView || doc.parentWindow;
		if (Browser.Engine.trident4) $try(function(){
			doc.execCommand("BackgroundImageCache", false, true);
		});
		return $extend(doc, Document.Prototype);
	},

	afterImplement: function(property, value){
		document[property] = Document.Prototype[property] = value;
	}

});

Document.Prototype = {$family: {name: 'document'}};

new Document(document);

/*
Script: Array.js
	Contains Array Prototypes like copy, each, contains, and remove.

License:
	MIT-style license.
*/

Array.implement({

	every: function(fn, bind){
		for (var i = 0, l = this.length; i < l; i++){
			if (!fn.call(bind, this[i], i, this)) return false;
		}
		return true;
	},

	filter: function(fn, bind){
		var results = [];
		for (var i = 0, l = this.length; i < l; i++){
			if (fn.call(bind, this[i], i, this)) results.push(this[i]);
		}
		return results;
	},
	
	clean: function() {
		return this.filter($defined);
	},

	indexOf: function(item, from){
		var len = this.length;
		for (var i = (from < 0) ? Math.max(0, len + from) : from || 0; i < len; i++){
			if (this[i] === item) return i;
		}
		return -1;
	},

	map: function(fn, bind){
		var results = [];
		for (var i = 0, l = this.length; i < l; i++) results[i] = fn.call(bind, this[i], i, this);
		return results;
	},

	some: function(fn, bind){
		for (var i = 0, l = this.length; i < l; i++){
			if (fn.call(bind, this[i], i, this)) return true;
		}
		return false;
	},

	associate: function(keys){
		var obj = {}, length = Math.min(this.length, keys.length);
		for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
		return obj;
	},

	link: function(object){
		var result = {};
		for (var i = 0, l = this.length; i < l; i++){
			for (var key in object){
				if (object[key](this[i])){
					result[key] = this[i];
					delete object[key];
					break;
				}
			}
		}
		return result;
	},

	contains: function(item, from){
		return this.indexOf(item, from) != -1;
	},

	extend: function(array){
		for (var i = 0, j = array.length; i < j; i++) this.push(array[i]);
		return this;
	},

	getLast: function(){
		return (this.length) ? this[this.length - 1] : null;
	},

	getRandom: function(){
		return (this.length) ? this[$random(0, this.length - 1)] : null;
	},

	include: function(item){
		if (!this.contains(item)) this.push(item);
		return this;
	},

	combine: function(array){
		for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
		return this;
	},

	erase: function(item){
		for (var i = this.length; i--; i){
			if (this[i] === item) this.splice(i, 1);
		}
		return this;
	},

	empty: function(){
		this.length = 0;
		return this;
	},

	flatten: function(){
		var array = [];
		for (var i = 0, l = this.length; i < l; i++){
			var type = $type(this[i]);
			if (!type) continue;
			array = array.concat((type == 'array' || type == 'collection' || type == 'arguments') ? Array.flatten(this[i]) : this[i]);
		}
		return array;
	},

	hexToRgb: function(array){
		if (this.length != 3) return null;
		var rgb = this.map(function(value){
			if (value.length == 1) value += value;
			return value.toInt(16);
		});
		return (array) ? rgb : 'rgb(' + rgb + ')';
	},

	rgbToHex: function(array){
		if (this.length < 3) return null;
		if (this.length == 4 && this[3] == 0 && !array) return 'transparent';
		var hex = [];
		for (var i = 0; i < 3; i++){
			var bit = (this[i] - 0).toString(16);
			hex.push((bit.length == 1) ? '0' + bit : bit);
		}
		return (array) ? hex : '#' + hex.join('');
	}

});

/*
Script: Function.js
	Contains Function Prototypes like create, bind, pass, and delay.

License:
	MIT-style license.
*/

Function.implement({

	extend: function(properties){
		for (var property in properties) this[property] = properties[property];
		return this;
	},

	create: function(options){
		var self = this;
		options = options || {};
		return function(event){
			var args = options.arguments;
			args = (args != undefined) ? $splat(args) : Array.slice(arguments, (options.event) ? 1 : 0);
			if (options.event) args = [event || window.event].extend(args);
			var returns = function(){
				return self.apply(options.bind || null, args);
			};
			if (options.delay) return setTimeout(returns, options.delay);
			if (options.periodical) return setInterval(returns, options.periodical);
			if (options.attempt) return $try(returns);
			return returns();
		};
	},

	pass: function(args, bind){
		return this.create({arguments: args, bind: bind});
	},

	attempt: function(args, bind){
		return this.create({arguments: args, bind: bind, attempt: true})();
	},

	bind: function(bind, args){
		return this.create({bind: bind, arguments: args});
	},

	bindWithEvent: function(bind, args){
		return this.create({bind: bind, event: true, arguments: args});
	},

	delay: function(delay, bind, args){
		return this.create({delay: delay, bind: bind, arguments: args})();
	},

	periodical: function(interval, bind, args){
		return this.create({periodical: interval, bind: bind, arguments: args})();
	},

	run: function(args, bind){
		return this.apply(bind, $splat(args));
	}

});

/*
Script: Number.js
	Contains Number Prototypes like limit, round, times, and ceil.

License:
	MIT-style license.
*/

Number.implement({

	limit: function(min, max){
		return Math.min(max, Math.max(min, this));
	},

	round: function(precision){
		precision = Math.pow(10, precision || 0);
		return Math.round(this * precision) / precision;
	},

	times: function(fn, bind){
		for (var i = 0; i < this; i++) fn.call(bind, i, this);
	},

	toFloat: function(){
		return parseFloat(this);
	},

	toInt: function(base){
		return parseInt(this, base || 10);
	}

});

Number.alias('times', 'each');

(function(math){
	var methods = {};
	math.each(function(name){
		if (!Number[name]) methods[name] = function(){
			return Math[name].apply(null, [this].concat($A(arguments)));
		};
	});
	Number.implement(methods);
})(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan']);

/*
Script: String.js
	Contains String Prototypes like camelCase, capitalize, test, and toInt.

License:
	MIT-style license.
*/

String.implement({

	test: function(regex, params){
		return ((typeof regex == 'string') ? new RegExp(regex, params) : regex).test(this);
	},

	contains: function(string, separator){
		return (separator) ? (separator + this + separator).indexOf(separator + string + separator) > -1 : this.indexOf(string) > -1;
	},

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

	clean: function(){
		return this.replace(/\s+/g, ' ').trim();
	},

	camelCase: function(){
		return this.replace(/-\D/g, function(match){
			return match.charAt(1).toUpperCase();
		});
	},

	hyphenate: function(){
		return this.replace(/[A-Z]/g, function(match){
			return ('-' + match.charAt(0).toLowerCase());
		});
	},

	capitalize: function(){
		return this.replace(/\b[a-z]/g, function(match){
			return match.toUpperCase();
		});
	},

	escapeRegExp: function(){
		return this.replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1');
	},

	toInt: function(base){
		return parseInt(this, base || 10);
	},

	toFloat: function(){
		return parseFloat(this);
	},

	hexToRgb: function(array){
		var hex = this.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
		return (hex) ? hex.slice(1).hexToRgb(array) : null;
	},

	rgbToHex: function(array){
		var rgb = this.match(/\d{1,3}/g);
		return (rgb) ? rgb.rgbToHex(array) : null;
	},

	stripScripts: function(option){
		var scripts = '';
		var text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi, function(){
			scripts += arguments[1] + '\n';
			return '';
		});
		if (option === true) $exec(scripts);
		else if ($type(option) == 'function') option(scripts, text);
		return text;
	},

	substitute: function(object, regexp){
		return this.replace(regexp || (/\\?\{([^}]+)\}/g), function(match, name){
			if (match.charAt(0) == '\\') return match.slice(1);
			return (object[name] != undefined) ? object[name] : '';
		});
	}

});

/*
Script: Hash.js
	Contains Hash Prototypes. Provides a means for overcoming the JavaScript practical impossibility of extending native Objects.

License:
	MIT-style license.
*/

Hash.implement({

	has: Object.prototype.hasOwnProperty,

	keyOf: function(value){
		for (var key in this){
			if (this.hasOwnProperty(key) && this[key] === value) return key;
		}
		return null;
	},

	hasValue: function(value){
		return (Hash.keyOf(this, value) !== null);
	},

	extend: function(properties){
		Hash.each(properties, function(value, key){
			Hash.set(this, key, value);
		}, this);
		return this;
	},

	combine: function(properties){
		Hash.each(properties, function(value, key){
			Hash.include(this, key, value);
		}, this);
		return this;
	},

	erase: function(key){
		if (this.hasOwnProperty(key)) delete this[key];
		return this;
	},

	get: function(key){
		return (this.hasOwnProperty(key)) ? this[key] : null;
	},

	set: function(key, value){
		if (!this[key] || this.hasOwnProperty(key)) this[key] = value;
		return this;
	},

	empty: function(){
		Hash.each(this, function(value, key){
			delete this[key];
		}, this);
		return this;
	},

	include: function(key, value){
		var k = this[key];
		if (k == undefined) this[key] = value;
		return this;
	},

	map: function(fn, bind){
		var results = new Hash;
		Hash.each(this, function(value, key){
			results.set(key, fn.call(bind, value, key, this));
		}, this);
		return results;
	},

	filter: function(fn, bind){
		var results = new Hash;
		Hash.each(this, function(value, key){
			if (fn.call(bind, value, key, this)) results.set(key, value);
		}, this);
		return results;
	},

	every: function(fn, bind){
		for (var key in this){
			if (this.hasOwnProperty(key) && !fn.call(bind, this[key], key)) return false;
		}
		return true;
	},

	some: function(fn, bind){
		for (var key in this){
			if (this.hasOwnProperty(key) && fn.call(bind, this[key], key)) return true;
		}
		return false;
	},

	getKeys: function(){
		var keys = [];
		Hash.each(this, function(value, key){
			keys.push(key);
		});
		return keys;
	},

	getValues: function(){
		var values = [];
		Hash.each(this, function(value){
			values.push(value);
		});
		return values;
	},
	
	toQueryString: function(base){
		var queryString = [];
		Hash.each(this, function(value, key){
			if (base) key = base + '[' + key + ']';
			var result;
			switch ($type(value)){
				case 'object': result = Hash.toQueryString(value, key); break;
				case 'array':
					var qs = {};
					value.each(function(val, i){
						qs[i] = val;
					});
					result = Hash.toQueryString(qs, key);
				break;
				default: result = key + '=' + encodeURIComponent(value);
			}
			if (value != undefined) queryString.push(result);
		});
		
		return queryString.join('&');
	}

});

Hash.alias({keyOf: 'indexOf', hasValue: 'contains'});

/*
Script: Event.js
	Contains the Event Native, to make the event object completely crossbrowser.

License:
	MIT-style license.
*/

var Event = new Native({

	name: 'Event',

	initialize: function(event, win){
		win = win || window;
		var doc = win.document;
		event = event || win.event;
		if (event.$extended) return event;
		this.$extended = true;
		var type = event.type;
		var target = event.target || event.srcElement;
		while (target && target.nodeType == 3) target = target.parentNode;
		
		if (type.test(/key/)){
			var code = event.which || event.keyCode;
			var key = Event.Keys.keyOf(code);
			if (type == 'keydown'){
				var fKey = code - 111;
				if (fKey > 0 && fKey < 13) key = 'f' + fKey;
			}
			key = key || String.fromCharCode(code).toLowerCase();
		} else if (type.match(/(click|mouse|menu)/i)){
			doc = (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html : doc.body;
			var page = {
				x: event.pageX || event.clientX + doc.scrollLeft,
				y: event.pageY || event.clientY + doc.scrollTop
			};
			var client = {
				x: (event.pageX) ? event.pageX - win.pageXOffset : event.clientX,
				y: (event.pageY) ? event.pageY - win.pageYOffset : event.clientY
			};
			if (type.match(/DOMMouseScroll|mousewheel/)){
				var wheel = (event.wheelDelta) ? event.wheelDelta / 120 : -(event.detail || 0) / 3;
			}
			var rightClick = (event.which == 3) || (event.button == 2);
			var related = null;
			if (type.match(/over|out/)){
				switch (type){
					case 'mouseover': related = event.relatedTarget || event.fromElement; break;
					case 'mouseout': related = event.relatedTarget || event.toElement;
				}
				if (!(function(){
					while (related && related.nodeType == 3) related = related.parentNode;
					return true;
				}).create({attempt: Browser.Engine.gecko})()) related = false;
			}
		}

		return $extend(this, {
			event: event,
			type: type,
			
			page: page,
			client: client,
			rightClick: rightClick,
			
			wheel: wheel,
			
			relatedTarget: related,
			target: target,
			
			code: code,
			key: key,
			
			shift: event.shiftKey,
			control: event.ctrlKey,
			alt: event.altKey,
			meta: event.metaKey
		});
	}

});

Event.Keys = new Hash({
	'enter': 13,
	'up': 38,
	'down': 40,
	'left': 37,
	'right': 39,
	'esc': 27,
	'space': 32,
	'backspace': 8,
	'tab': 9,
	'delete': 46
});

Event.implement({

	stop: function(){
		return this.stopPropagation().preventDefault();
	},

	stopPropagation: function(){
		if (this.event.stopPropagation) this.event.stopPropagation();
		else this.event.cancelBubble = true;
		return this;
	},

	preventDefault: function(){
		if (this.event.preventDefault) this.event.preventDefault();
		else this.event.returnValue = false;
		return this;
	}

});

/*
Script: Class.js
	Contains the Class Function for easily creating, extending, and implementing reusable Classes.

License:
	MIT-style license.
*/

var Class = new Native({

	name: 'Class',

	initialize: function(properties){
		properties = properties || {};
		var klass = function(empty){
			for (var key in this) this[key] = $unlink(this[key]);
			for (var mutator in Class.Mutators){
				if (!this[mutator]) continue;
				Class.Mutators[mutator](this, this[mutator]);
				delete this[mutator];
			}

			this.constructor = klass;
			if (empty === $empty) return this;
			
			var self = (this.initialize) ? this.initialize.apply(this, arguments) : this;
			if (this.options && this.options.initialize) this.options.initialize.call(this);
			return self;
		};

		$extend(klass, this);
		klass.constructor = Class;
		klass.prototype = properties;
		return klass;
	}

});

Class.implement({

	implement: function(){
		Class.Mutators.Implements(this.prototype, Array.slice(arguments));
		return this;
	}

});

Class.Mutators = {
  
  Implements: function(self, klasses){
  	$splat(klasses).each(function(klass){
  		$extend(self, ($type(klass) == 'class') ? new klass($empty) : klass);
  	});
  },
  
  Extends: function(self, klass){
  	var instance = new klass($empty);
  	delete instance.parent;
  	delete instance.parentOf;

  	for (var key in instance){
  		var current = self[key], previous = instance[key];
  		if (current == undefined){
  			self[key] = previous;
  			continue;
  		}

  		var ctype = $type(current), ptype = $type(previous);
  		if (ctype != ptype) continue;

  		switch (ctype){
  			case 'function': 
  				// this code will be only executed if the current browser does not support function.caller (currently only opera).
  				// we replace the function code with brute force. Not pretty, but it will only be executed if function.caller is not supported.

  				if (!arguments.callee.caller) self[key] = eval('(' + String(current).replace(/\bthis\.parent\(\s*(\))?/g, function(full, close){
  					return 'arguments.callee._parent_.call(this' + (close || ', ');
  				}) + ')');

  				// end "opera" code
  				self[key]._parent_ = previous;
  			  break;
  			case 'object': self[key] = $merge(previous, current);
  		}

  	}

  	self.parent = function(){
  		return arguments.callee.caller._parent_.apply(this, arguments);
  	};

  	self.parentOf = function(descendant){
  		return descendant._parent_.apply(this, Array.slice(arguments, 1));
  	};
  }
  
};

/*
Script: Class.Extras.js
	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.

License:
	MIT-style license.
*/

var Chain = new Class({

	chain: function(){
		this.$chain = (this.$chain || []).extend(arguments);
		return this;
	},

	callChain: function(){
		return (this.$chain && this.$chain.length) ? this.$chain.shift().apply(this, arguments) : false;
	},

	clearChain: function(){
		if (this.$chain) this.$chain.empty();
		return this;
	}

});

var Events = new Class({

	addEvent: function(type, fn, internal){
		type = Events.removeOn(type);
		if (fn != $empty){
			this.$events = this.$events || {};
			this.$events[type] = this.$events[type] || [];
			this.$events[type].include(fn);
			if (internal) fn.internal = true;
		}
		return this;
	},

	addEvents: function(events){
		for (var type in events) this.addEvent(type, events[type]);
		return this;
	},

	fireEvent: function(type, args, delay){
		type = Events.removeOn(type);
		if (!this.$events || !this.$events[type]) return this;
		this.$events[type].each(function(fn){
			fn.create({'bind': this, 'delay': delay, 'arguments': args})();
		}, this);
		return this;
	},

	removeEvent: function(type, fn){
		type = Events.removeOn(type);
		if (!this.$events || !this.$events[type]) return this;
		if (!fn.internal) this.$events[type].erase(fn);
		return this;
	},

	removeEvents: function(type){
		for (var e in this.$events){
			if (type && type != e) continue;
			var fns = this.$events[e];
			for (var i = fns.length; i--; i) this.removeEvent(e, fns[i]);
		}
		return this;
	}

});

Events.removeOn = function(string){
	return string.replace(/^on([A-Z])/, function(full, first) {
		return first.toLowerCase();
	});
};

var Options = new Class({

	setOptions: function(){
		this.options = $merge.run([this.options].extend(arguments));
		if (!this.addEvent) return this;
		for (var option in this.options){
			if ($type(this.options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
			this.addEvent(option, this.options[option]);
			delete this.options[option];
		}
		return this;
	}

});

YAHOO.register('OLD.MooToolsMinimal', {}, {version: "0.1", build: '1'});

YAHOO.namespace('POTISCOM');

(function() {

    var Dom = YAHOO.util.Dom,
        Event = YAHOO.util.Event,
        Lang = YAHOO.lang,
        Selector = YAHOO.util.Selector,
        Tools = YAHOO.POTISCOM.Tools,
        Application = YAHOO.POTISCOM.Application;

	var Manager = function() {

		var _singleton = function() {
		}

		_singleton.prototype = {

            authenticated: false,
            roles: [],

            setAuthenticated: function(authenticated) {
                this.authenticated = authenticated;
            },

            isAuthenticated: function() {
                return this.authenticated;
            },

            setRoles: function(roles) {
                this.roles = roles;
            },

            checkRole: function(role) {
                for (var i in this.roles) {
                    if (this.roles.hasOwnProperty(i)) {
                        if (this.roles[i]===role) {
                            return true;
                        }
                    }
                }
                throw 'Role Check failed';
            }
		}

		return new _singleton();
	} ();

	YAHOO.POTISCOM.AuthManager = Manager;

})();

YAHOO.register('POTISCOM.AuthManager', YAHOO.POTISCOM.AuthManager, {version: "0.1", build: '1'});