// Mouse move controller ----------------------------------------------------------------------------------------------------//
var mouseObj = {
	position: {
		x: 0,
		y: 0
	},
	
	getX: function()
	{
		return this.position.x
	},
	getY: function()
	{
		return this.position.y
	},
	onMove: {
		items: new Array()
	}
	
}

mouseObj.onMove.add = function( funct )
{
	mouseObj.onMove.items.push( funct );
}

mouseObj.isOnElement = function( el )
{
	var element = {
		left: Dimension.getLeftRelativeByElement( el, document.body ),
		top: Dimension.getTopRelativeByElement( el, document.body ),
		width: Dimension.getWidth( el ),
		height: Dimension.getHeight( el )
	}

	if ( mouseObj.getX() >= element.left && mouseObj.getX() < element.left + element.width  && mouseObj.getY() >= element.top && mouseObj.getY() < element.top + element.height )
	{
		return true;
	}
	
	
	
	return false;
}

mouseObj.getPositionRelativeByElement = function( el )
{
	return {
		left: mouseObj.getX() - Dimension.getLeftRelativeByElement( el, document.body ),
		top: mouseObj.getY() - Dimension.getTopRelativeByElement( el, document.body )
	}
}

document.onmousemove = function( e )
{
	if ( !e )
	{
		e = window.event;
	}
	
	if ( e.pageX || e.pageY )
	{
		mouseObj.position.x = e.pageX
		mouseObj.position.y = e.pageY
	}
	else if ( e.clientX || e.clientY )
	{
		mouseObj.position.x = e.clientX + scrollObj.getLeft();
		mouseObj.position.y = e.clientY + scrollObj.getTop()
	}
	
	for ( var i = 0; i < mouseObj.onMove.items.length; i++ )
	{
		if ( isFunction( mouseObj.onMove.items[i] ) )
		{
			mouseObj.onMove.items[i]();
		}
	}

};


// Screen controller ----------------------------------------------------------------------------------------------------//

var screenObj = {
	getWidth: function()
	{
		return screen.width;
	},
	getHeight: function()
	{
		return screen.height;
	}
}

// Window controller ----------------------------------------------------------------------------------------------------//

var windowObj = {
	getWidth: function()
	{
		if ( isSet( window.innerWidth ) )
		{
			return window.innerWidth
		}
		else if ( isSet( document.documentElement ) )
		{
			return document.documentElement.clientWidth
		}
		
		return 0;
	},
	getHeight: function()
	{
		if ( isSet( window.innerHeight ) )
		{
			return window.innerHeight
		}
		else if ( isSet( document.documentElement ) )
		{
			return document.documentElement.clientHeight
		}
		
		return 0;
	}
	
}

// Document controller ----------------------------------------------------------------------------------------------------//
var documentObj = {
	onClick: {
		items: new Array()
	},
	onMouseUp: {
		items: new Array()
	},
	onMouseDown: {
		items: new Array()
	},
	onMouseMove: {
		add: function( funct )
		{
			mouseObj.onMove.add( funct )
		}
	},
	getWidth: function()
	{
		return scrollObj.getMaxX() + windowObj.getWidth();
		if ( isSet( document.width ) )
		{
			return document.width;
		}
		
		return document.body.offsetWidth;
	},
	getHeight: function()
	{
		return scrollObj.getMaxY() + windowObj.getHeight();
		if ( isSet( document.height ) )
		{
			return document.height;
		}
		
		return document.body.offsetHeight;
	}
	
}

documentObj.onClick.add = function( funct )
{
	documentObj.onClick.items.push( funct );
}

document.onclick = function()
{
	for ( var i = 0; i < documentObj.onClick.items.length; i++ )
	{
		if ( isFunction( documentObj.onClick.items[i] ) )
		{
			documentObj.onClick.items[i]();
		}
	}
};

documentObj.onMouseUp.add = function( funct )
{
	documentObj.onMouseUp.items.push( funct );
}

document.onmouseup = function()
{
	for ( var i = 0; i < documentObj.onMouseUp.items.length; i++ )
	{
		if ( isFunction( documentObj.onMouseUp.items[i] ) )
		{
			documentObj.onMouseUp.items[i]();
		}
	}
};

documentObj.onMouseDown.add = function( funct )
{
	documentObj.onMouseDown.items.push( funct );
}

document.onmousedown = function()
{
	for ( var i = 0; i < documentObj.onMouseDown.items.length; i++ )
	{
		if ( isFunction( documentObj.onMouseDown.items[i] ) )
		{
			documentObj.onMouseDown.items[i]();
		}
	}
};





// Scroll controller --------------------------------------------------------------------------------------------------//
var scrollObj = {	
	getTop: function( el )
	{
		var top = 0;
		
		if ( document.documentElement.scrollTop && !isElement( el ) )
		{
			top = document.documentElement.scrollTop;
		}
		else if ( document.body.scrollTop || isElement( el ) )
		{
			el = isSet( el ) ? el : document.body;
			top = el.scrollTop;
		}

		return top;
	},
	getLeft: function( el )
	{
		var left = 0;

		if ( document.documentElement.scrollLeft && !isElement( el ) )
		{
			left = document.documentElement.scrollLeft;
		}
		else if ( document.body.scrollLeft || isElement( el ) )
		{
			el = isSet( el ) ? el : document.body;
			left = el.scrollLeft;
		}

		return left;
	},
	setScroll: function( x, y, el )
	{
		if ( isElement( el ) )
		{
			el.scroll( x, y );
		}
		else
		{
			window.scrollTo( x, y );
		}	
	},
	getMaxX: function()
	{
		return 'scrollMaxX' in window ? window.scrollMaxX : document.documentElement.scrollWidth - document.documentElement.clientWidth;
	},
	getMaxY: function()
	{
		return 'scrollMaxX' in window ? window.scrollMaxY : document.documentElement.scrollHeight - document.documentElement.clientHeight;
	}
}

scrollObj.setTop = function( value, el )
{
	if ( isElement( el ) )
	{
		if ( isSet( el.scrollTo ) )
		{
			el.scroll( scrollObj.getLeft( el ), value );
		}
	}
	else
	{
		window.scrollTo( scrollObj.getLeft(), value );
	}
}

scrollObj.setLeft = function( value, el )
{
	if ( isElement( el ) )
	{
		el.scroll( value, scrollObj.getTop( el ) );
	}
	else
	{
		window.scrollTo( value, scrollObj.getTop() );
	}
}

var Dimension = {
	getHeight: function( element )
	{
		var ee, retVal;

		try
		{
			var $cs = document.defaultView.getComputedStyle( element, '' );
			retVal = style2px( $cs.getPropertyValue( "height" ) );

		}
		catch( ee )
		{
			retVal = element.offsetHeight;

			if ( retVal < 0 )
			{
				retVal = 0;
			}
		}
		
		if ( retVal == 0 )
		{
			retVal = Css.getStyle( element, 'height' ).toInt();
		}

		return retVal;
	},
	getWidth: function( element )
	{
		var ee, retVal;

		try
		{
			var $cs = document.defaultView.getComputedStyle( element, '' );
			retVal = style2px( $cs.getPropertyValue( "width" ) );
		}
		catch( ee )
		{
			retVal = element.offsetWidth;

			if ( retVal < 0 )
			{
				retVal = 0;
			}
		}
		
		if ( retVal == 0 )
		{
			retVal = Css.getStyle( element, 'width' ).toInt();
		}
		
		return retVal;
	},
	getTop: function( element )
	{
		var ee, retVal;

		try
		{
			var cs = document.defaultView.getComputedStyle( element, '' );
			retVal = style2px( cs.getPropertyValue( "top" ) );
		}
		catch( ee )
		{
			retVal = element.offsetTop;
		}
		return retVal;
	},
	
	getTopRelativeByElement: function( element, parentEl )
	{
        var first = true;
        var rValue = 0;
		
		if ( !isSet( parentEl ) )
		{
			parentEl = document.getElementsByTagName( 'html' )[0];
		}

        while ( element != parentEl )
        {
            if ( first )
            {
                try
                {
                    var cs = document.defaultView.getComputedStyle( element, '' );
                    rValue = style2px( cs.getPropertyValue( 'top' ) );
                }
                catch( e )
				{
                    rValue = element.offsetTop;
                }
                first = false;
            }
            else
            {
                if ( Css.getStyle( element, 'position' ).toLowerCase() == 'relative' || Css.getStyle( element, 'position' ).toLowerCase() == 'absolute' )
                {
                    try
                    {
                        cs = document.defaultView.getComputedStyle(element,'');
                        rValue += style2px(cs.getPropertyValue("top"));
                    }
                    catch( e )
					{
                        var tempVal = element.offsetTop;
                        rValue += tempVal;
                    }
                }
				
				if ( Css.getStyle( element, 'overflow' ).toLowerCase() == 'auto' || Css.getStyle( element, 'overflow-y' ).toLowerCase() == 'auto' )
				{
					rValue -= scrollObj.getTop( element );
				}
            }
            element = element.parentNode;
        }

        return rValue;
    },
	
	
	
	getTopOnScreen: function( element )
	{
        var first = true;
        var rValue = 0;
		var parentEl = document.body;

        while ( element != parentEl )
        {
            if ( first )
            {
                try
                {
                    var cs = document.defaultView.getComputedStyle( element, '' );
                    rValue = style2px( cs.getPropertyValue( 'top' ) );
                }
                catch( e )
				{
                    rValue = element.offsetTop;
                }
                first = false;
            }
            else
            {
                if ( Css.getStyle( element, 'position' ).toLowerCase() == 'relative' || Css.getStyle( element, 'position' ).toLowerCase() == 'absolute' )
                {
                    try
                    {
                        cs = document.defaultView.getComputedStyle(element,'');
                        rValue += style2px( cs.getPropertyValue( 'top' ) );
                    }
                    catch( e )
					{
                        var tempVal = element.offsetTop;
                        rValue += tempVal;
                    }
                }
				
				if ( !isEmpty( scrollObj.getTop( element ) ) )
				{
					alert( scrollObj.getTop( element ) );
					rValue -= scrollObj.getTop( element );
				}
            }
			
            element = element.parentNode;
        }
		
		rValue -=  scrollObj.getTop();

        return rValue;
    },

    getLeftRelativeByElement: function( element, parentEl )
    {
        var first = true;
        var rValue = 0;

		if ( !isSet( parentEl ) )
		{
			parentEl = document.getElementsByTagName( 'html' )[0];
		}
		
        while ( element != parentEl )
        {
            if ( first )
            {
                try
                {
                    var cs = document.defaultView.getComputedStyle(element,'');
                    rValue = style2px(cs.getPropertyValue("left"));
                }
                catch( e )
				{
                    rValue = element.offsetLeft;
                }
                first = false;
            }
            else
            {
                if ( Css.getStyle( element, 'position' ).toLowerCase() == 'relative' || Css.getStyle( element, 'position' ).toLowerCase() == 'absolute' )
                {
                    try
                    {
                        cs = document.defaultView.getComputedStyle( element, '' );
                        rValue += style2px( cs.getPropertyValue( 'left' ) );
                    }
                    catch( e )
					{
                        var tempVal = element.offsetLeft;

                        rValue += tempVal;
                    }
                }
            }
			
            element = element.parentNode;
        }

        return rValue;
    },
	
	
	getLeftOnScreen: function( element )
    {
        var first = true;
        var rValue = 0;
		var parentEl = document.getElementsByTagName( 'html' )[0];
		
        while ( element != parentEl )
        {
            if ( first )
            {
                try
                {
                    var cs = document.defaultView.getComputedStyle(element,'');
                    rValue = style2px(cs.getPropertyValue("left"));
                }
                catch( e )
				{
                    rValue = element.offsetLeft;
					
                    if ( rValue < 0 )
					{
						rValue = 0;
					}
                }
                first = false;
            }
            else
            {
                if ( Css.getStyle( element, 'position' ).toLowerCase() == 'relative' || Css.getStyle( element, 'position' ).toLowerCase() == 'absolute' )
                {
                    try
                    {
                        cs = document.defaultView.getComputedStyle( element, '' );
                        rValue += style2px( cs.getPropertyValue( 'left' ) );
                    }
                    catch( e )
					{
                        var tempVal = element.offsetLeft;

                        rValue += tempVal;
                    }
                }
				
				if ( Css.getStyle( element, 'overflow' ).toLowerCase() == 'auto' || Css.getStyle( element, 'overflow-x' ).toLowerCase() == 'auto' )
				{
					rValue -= scrollObj.getLeft( element );
				}
            }
            element = element.parentNode;
        }

        return rValue;
    },
	
	getLeft: function( element ) {
		var ee, retVal;

		try
		{
			var cs = document.defaultView.getComputedStyle( element, '' );
			retVal = style2px( cs.getPropertyValue( "left" ) );
		}
		catch( ee )
		{
			retVal = element.offsetLeft;

			/*if ( retVal < 0 )
			{
				retVal = 0;
			}*/
		}

		return retVal;
	}
}


var Css = {

	exceptions: {
		ie: {
			'float' : 'styleFloat'
		},
		firefox: {
			'float' : 'cssFloat'
		}
	},

    getStyle: function( el, styleProp )
    {
			var element = el;
			var output = false;
			//try{
				if ( element.currentStyle )
				{
					styleProp = styleProp.toDromedar( '-', true );

					if ( isSet( this.exceptions.ie[styleProp] ) )
					{
						styleProp = this.exceptions.ie[styleProp];
					}

					output = element.currentStyle[styleProp];
				}
				else if ( window.getComputedStyle )
				{
					output = document.defaultView.getComputedStyle( element, null ).getPropertyValue( styleProp );
				}
//			}
//			catch( e ){};

			return output;
    },
	
	getPaddingForce: function( el, direction )
	{
		var retVal = Css.getStyle( el, 'padding-'+direction ).toInt();
		
		if ( isEmpty( retVal ) )
		{
			var oldWidth = Dimension.getWidth( el );
			var styleValue = 'padding-'+direction;
			styleValue = styleValue.toDromedar( '-', true );
			el.style[styleValue] = 0;
			var newWidth = Dimension.getWidth( el );
			retVal = oldWidth - newWidth;
			el.style[styleValue] = retVal+'px';
		}
		
		return retVal;
	},
	
	getMarginForce: function( el, direction )
	{
		var retVal = Css.getStyle( el, 'margin-'+direction ).toInt();
		
		if ( isEmpty( retVal ) )
		{
			var oldWidth = Dimension.getWidth( el );
			var styleValue = 'margin-'+direction;
			styleValue = styleValue.toDromedar( '-', true );
			el.style[styleValue] = 0;
			var newWidth = Dimension.getWidth( el );
			retVal = oldWidth - newWidth;
			el.style[styleValue] = retVal+'px';
		}
		
		return retVal;
	},

    hasClassName: function( element, className )
    {
        return element.className.match( new RegExp( "(^|\\s)"+className+"(\\s|$)" ) );
    },
    
    addClassName: function( element, className )
    {
        if ( !Css.hasClassName( element, className ) )
        {
            element.className = element.className+' '+className;
            return true;
        }
        else
        {
            return false
        }
    },

    removeClassName: function( element, className )
    {
        element.className.replace( new RegExp( "^"+className+"\\s" ), '' );
        element.className.replace( new RegExp( "\\s"+className+"$" ), '' );
        element.className.replace( new RegExp( "\\s"+className+"\\s" ), ' ' );

        return true;
    }
}






/*obj.prototype.getAllClassElements = function (className, parentElement)
{
    var elements = Array();
    var parentEl;

    if ( null == parentElement )
    {
        parentEl = document.getElementsByTagName( 'html' )[0];
    }
    else
    {
        parentEl = parentElement;
    }

    var nodes = parentEl.getElementsByTagName( '*' );

    for ( var i = 0, child; child = nodes[i]; i++ )
    {
        if ( child.className && Css.hasClassName( child, className ) )
        {
            elements.push( child );
        }
    }

    if ( elements.length == 0 )
    {
        elements = false;
    }

    return elements;
}

obj.prototype.getAllTagElements = function (tagName, parentElement)
{
    var parentEl;

    if ( null == parentElement )
    {
        parentEl = document.getElementsByTagName( 'html' )[0];
    }
    else
    {
        parentEl = parentElement;
    }

    return parentEl.getElementsByTagName( tagName );
}

obj.prototype.getIdElement = function ( id )
{
    return document.getElementById( id );
}


obj.prototype.hasClassName = function( className )
{
    if ( isElement( this ) )
    {
        return this.className.match( new RegExp( "(^|\\s)"+className+"(\\s|$)" ) );
    }

    return false;
}



Object.prototype.getAllClassElements = function ( className )
{
    if ( isElement( this ) )
    {
        var parentEl = this;
        var elements = Array();
        var nodes = parentEl.getElementsByTagName('*');

        for ( var i = 0; i < nodes.length; i++ )
        {
            if ( nodes[i].hasClassName( className ) )
            {
                elements[elements.length] = nodes[i];
            }
        }

        if ( elements.length == 0 )
        {
            elements = false;
        }

        return elements;

    }

    return false
}

Object.prototype.removeAllChildren = function( withParent )
{
    if ( isElement( this ) )
    {
        var parentEl = this;

        var children = parentEl.getElementsByTagName('*');

        for (var i = 0; i < children.length; i++)
        {
            parentEl.removeChild( children[i] );
        }

        if ( withParent )
        {
            parentEl.parentNode.removeChild( parentEl );
        }
    }
}*/





// Object type check ----------------------------------------------------------------------------------------------------//


/** funkce isSet zjistí existenci nebo prázdnou hodnotu objektu
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isSet( obj )
{
    return ( typeof( obj ) != 'undefined' && obj != null );
}

/** funkce isSet zjistí prázdnou hodnotu objektu
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isEmpty( obj )
{
    return ( !isSet( obj ) || obj == '' || obj == 0 );
}

/** funkce isElement zjistí, zda je objekt element
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isElement( obj )
{
    return isSet( obj ) && isSet( obj.tagName );
}

/** funkce isFunction zjistí, zda je objekt funkce
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isFunction( obj )
{
    return typeof( obj ) == 'function';
}

/** funkce isString zjistí, zda je objekt textový řetězec
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isString( obj )
{
    return typeof( obj ) == 'string';
}

/** funkce isInt zjistí, zda je objekt Integer
 *
 *  @author SomeBW
 *  @param value - objekt ke kontrole
 */
function isInt( value )
{
	if ( value.search( new RegExp( /^(-?[0-9]+)$/ ) ) )
	{
		return false;
	}
	else
	{
		return true;
	}
}

/** funkce isInt zjistí, zda je objekt Integer
 *
 *  @author SomeBW
 *  @param value - objekt ke kontrole
 */
function isNumber( value )
{
	return typeof( value ) == 'number';
}

/** funkce isArray zjistí, zda je objekt pole
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isArray( obj )
{
    return ( obj instanceof Array  );
}

/** funkce isObjArray zjistí, zda je objekt pole objektu
 *
 *  @author SomeBW
 *  @param obj - objekt ke kontrole
 */
function isObjArray( obj )
{
    if ( !isEmpty( obj ) && typeof( obj ) == 'object' && !isArray( obj ) )
    {
		try
		{
			for ( var i in obj )
			{
				return true;
			}
		}
		catch (e){}
    }

    return false;
}


// Array operations ----------------------------------------------------------------------------------------------------//

/** funkce inArray zjistí existenci objektu v poli
 *
 *  @author SomeBW
 *  @param item - objekt
 *  @param arrayObj - pole
 */
function inArray( item, arrayObj )
{
	if ( isObjArray( arrayObj ) )
    {
        for ( var i in arrayObj )
        {
            if ( arrayObj[i] == item )
            {
                return true;
            }
        }
    }
    else if ( isArray( arrayObj )  )
    {
        for ( var i = 0; i < arrayObj.length; i++ )
        {
            if ( arrayObj[i] == item )
            {
                return true;
            }
        }
    }

    return false;
}


// String operations ----------------------------------------------------------------------------------------------------//

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

/** funkce charRepeat vytvoří řetězec z zadaného řetězce a zadaného počtu opakování
 *
 *  @author SomeBW
 *  @param String character - řetězec
 *  @param int repeat - počet opakování řetězce
 */
String.prototype.charRepeat = function( repeat )
{
    var retVal = '';

    for (var i = 0; i < repeat; i++)
    {
        retVal += this;
    }

    return retVal;
}

/** funkce splitStringByCharCount rozděláí řetězec na řádky po určitým počtu znaků
 *
 *  @author SomeBW
 *  @param int charCount - počet znaků na řádek
 *  @param boolean splitWords - rozdělovat slova
 */
String.prototype.splitStringByCharCount = function( charCount, splitWords )
{
	var value = this.toString();
	var retVal = '';
	var j = 0;

	for ( var i = 0; i < value.length; i += charCount )
	{
		if ( splitWords )
		{
			retVal += value.substr( i , charCount )+'\n';
		}
		else
		{
			var sub = value.substr( i , charCount );
			if ( i + charCount < value.length )
			{
				for (var j = sub.length; j > 0; j--)
				{
					if ( sub.substr( j - 1, 1 ) == ' ' )
					{
						retVal += value.substr( i, j )+'\n';
						i = i - charCount + j;
						break;
					}
				}

				if ( j == 0 )
				{
					for ( var j = i + charCount; j < value.length; j++ )
					{
						if ( value.substr( j, 1 ) == ' ' )
						{
							retVal += value.substr( i , j - i )+'\n';
							i = j;
							break;
						}
					}
				}
			}
			else{

			}
		}
	}

	return retVal+this.substr( i - charCount, this.length - (i - charCount) );

    return false;
}

String.prototype.toDromedar = function( separator, firstLower )
{
	var items = this.split( separator );
	var output = '';
	var start = 0;

	if ( isSet( firstLower ) && firstLower == true )
	{
		start = 1;
		output = items[0].toString();
	}

	for ( var i = start; i < items.length; i++ )
	{
		output += items[i].toString().firstUpper();
	}

	return output;
}

String.prototype.firstUpper = function()
{
	var firstPart = this.substr( 0, 1 ).toUpperCase();
	var secondPart = this.substr( 1 );

	return firstPart+secondPart;
}

String.prototype.toInt = function( useAllNumbers )
{
	if ( !isSet( useAllNumbers ) )
	{
		useAllNumbers = false;
	}
	
	var output;
	
	if ( useAllNumbers )
	{
		output = this.replace( new RegExp(/\D/), '');
	}
	else
	{
		output = this.replace( new RegExp(/^(-?[0-9]+).*$/), '$1');
	}

	if ( !isInt( output ) )
	{
		output = 0;
	}

	return parseInt( output );
}

String.prototype.toBoolean = function()
{
	return ( this == '' || this == null ) ? false : true;
}

// Number operations ----------------------------------------------------------------------------------------------------//


Number.prototype.toBoolean = function()
{
	return ( this == 0 || this == null ) ? false : true;
}

Number.prototype.toInt = function( value )
{
	return parseInt( value );
}

// Boolean operations ----------------------------------------------------------------------------------------------------//


Boolean.prototype.toInt = function()
{
	return ( this ) ? 1 : 0;
}

// Element Operations ----------------------------------------------------------------------------------------------------//


function HtmlElement( tag, params, style, inner, appendTo )
{
    var element = document.createElement( tag );

    if ( isSet( params ) )
    {
		var replacement = { 
			'class' : 'className' 
		};
		
        for ( var i in params )
        {
			var change = false;
			
			for ( var j in replacement )
			{
				if ( i == j )
				{
					element[replacement[j]] = params[i];
					change = true;
					break;
				}
			}
			
			if ( !change )
			{
				element.setAttribute(i, params[i]);
			}
        }
    }
    if ( isSet( style ) )
    {
        for ( var i in style )
        {
            element.style[i] = style[i];
        }
    }
    if ( isSet( appendTo ) )
    {
        appendTo.appendChild( element );
    }

    if ( !isEmpty( inner ) )
    {
        setContentText( element, inner );
    }

    return element;
}

function insertAfter( newElement, targetElement )
{
    var parent = targetElement.parentNode;

    if (parent.lastchild == targetElement)
    {
        parent.appendChild(newElement);
    }
    else
    {
        parent.insertBefore(newElement, targetElement.nextSibling);
    }
}

function insertBefore( newElement, targetElement )
{
    var parent = targetElement.parentNode;
    parent.insertBefore(newElement, targetElement);
}

function setContentText( el, value )
{
    try
    {
        el.innerHTML = value;
    }
    catch( ee )
    {
        var ee2;

        try
        {
            el.innerText = value;
        }
        catch( ee2 )
        {
            alert( "Error in using innerHTML function, if you are using fucking IE, check if your select element isn't child of 'p' element" );
        }
    }
}

function allowOnlyNumericKeys( el, evt, minValue, maxValue )
{
    var charCode = isSet( evt ) && isSet( evt.which ) ? evt.which : event.keyCode;
	var allowedKeys = Array( null, 0, 8, 13, 16, 27, 18, 46, 39, 37, 38, 39, 40, 46 );
	
	
	
	/*for ( var i = 48; i < 58; i++ )
	{
		numericKeys.push( i );
	}
	
	for ( var i = 96; i < 106; i++ )
	{
		numericKeys.push( i );
	}*/
    
    if ( inArray( charCode, allowedKeys ) )
    {
        return true;
    }

    el.onkeyup = function()
    {
        if ( inArray( charCode, allowedKeys ))
        {
            return true;
        }
		
		if ( this.value != this.value.toInt() )
		{
			this.value = this.value.toInt( true );
		}
		
		if ( isSet( maxValue ) && this.value > maxValue )
		{
			this.value = maxValue;
		}		
		else if ( isSet( minValue ) && this.value < minValue )
		{
			this.value = minValue;
		}
		
		return false;
    }

    if ( ( charCode >=0 && charCode < 48 ) || (charCode > 57 && charCode < 96) || charCode > 105 )
    {
        return false;
    }

    return true;
}


// AJAX Operations ----------------------------------------------------------------------------------------------------//

function postAJAX( url, query )
{
    var status = false;
    var contentType = "application/x-www-form-urlencoded; charset=UTF-8";

    // Native XMLHttpRequest object
    if (window.XMLHttpRequest) {
        request = new XMLHttpRequest();
        request.onreadystatechange = function(){
            if(request.readyState == 4) {
                //alert(request.responseText);
            }
        }
        request.open("post", url, true);
        request.setRequestHeader("Content-Type", contentType);
        request.send(query);
        status = true;

    // ActiveX XMLHttpRequest object
    } else if (window.ActiveXObject) {
        request = new ActiveXObject("Microsoft.XMLHTTP");
        if (request) {
            request.onreadystatechange = function(){
                if(request.readyState == 4) {
                    //alert(request.responseText);
                }
            }
            request.open("post", url, true);
            request.setRequestHeader("Content-Type", contentType);
            request.send(query);
            status = true;
        }
    }

    return status;
}




// functions addressed to testing ----------------------------------------------------------------------------------------------------//

function alertEr( val )
{
    if ( isObjArray( val ) )
    {
        var retVal = 'Object = ';
        var nesting = 0;
        getString( val );
    }
    else if ( isString( val ) )
    {
        retVal = val;
    }

    function getString( values )
    {
		if ( isObjArray( values ) )
		{
			retVal += isEmpty( nesting ) ? " {" : ": {";
		}
		else if ( isArray( values ))
		{
			retVal += isEmpty( nesting ) ? " [" : ": [";
		}
		
        nesting += 1;
		
        if ( isObjArray( values ) )
        {
            for ( var key in values )
            {
                retVal += '\n'+charRepeat('\t', nesting)+key;
				
                if ( !isObjArray(values[key]) && !isArray(values[key]) || isElement( values[key] ) )
                {
					//alert(values[key])
                    retVal += isSet( values[key] ) ? " : '"+values[key].toString().replace( ' ', " " )+'\'' : " : ''";
                }
                else
                {
                    getString(values[key]);
                }
            }
        }
		else if ( isArray( values ) )
        {
            for ( var i = 0; i < values.length; i++ )
            {
                retVal += '\n'+charRepeat('\t', nesting)+i;

                if ( !isObjArray( values[i] ) && !isArray( values[i] ) || isElement( values[i] ) )
                {
                    retVal += isSet( values[i] ) ? " : '"+values[i].toString().replace( ' ', " " )+'\'' : " : ''";
                }
                else
                {
                    getString(values[i]);
                }
            }
        }
        nesting -= 1;
        retVal += isObjArray( values ) ? '\n'+charRepeat('\t', nesting)+'}' : '\n'+charRepeat('\t', nesting)+']';
    }
    alert(retVal);
}

function charRepeat( character, repeat )
{
    var retVal = '';

    for (var i = 0; i < repeat; i++)
    {
        retVal += character
    }

    return retVal;
}








// Not yet functionally ----------------------------------------------------------------------------------------------------//


/* changeAjaxContent - změní obsah
 *
 * @author SomeBW
 * @version 0.2b
 * @param selectbox (<i>nepovinný parametr</i>) - selectbox ve tvaru {
 *      elementId: 'id elementu selectboxu',
 *      param: 'parametr odesílaný pomocí get s hodnotou value vybraného prvku',
 *      disabled: 'prvek selectboxu s neaktivním přepínáním'
 *  }
 * @param outputId - id výstupního elementu
 * @param params - parametry ve tvaru {parametr1: 'hodnota1', parametr2: 'hodnota2', ...}
 * @param preloader (<i>nepovinný parametr</i>) - objekt Preloaderu
 *
 */
function changeAjaxContent( outputId, params, preloader, selectbox )
{
    var disabledValue;

    try
    {
        disabledValue = selectbox.disabled;
    }
    catch( e )
    {
        disabledValue = null;
    }

    if ( isSet( selectbox ) )
    {
        selectbox.element = document.getElementById( selectbox.elementId );

        var selectedValue = selectbox.element.options[selectbox.element.selectedIndex].value;
    }

    if ( !isSet( disabledValue ) || ( isSet( disabledValue ) && isSet( selectedValue ) && selectedValue != disabledValue ) )
    {
        if ( isSet( preloader ) )
        {
            preloader.show();
        }

        var urlParams = '';

        for (var i in params)
        {
            if (urlParams == '')
            {
                urlParams = '?'+i+'='+params[i];
            }
            else
            {
                urlParams += '&'+i+'='+params[i];
            }
        }

        if ( isSet( selectbox ) && isSet( selectbox.param ) )
        {
            if (urlParams == '')
            {
                urlParams = '?'+selectbox.param+'='+selectedValue;
            }
            else
            {
                urlParams += '&'+selectbox.param+'='+selectedValue;
            }
        }

        $( '#'+outputId ).load( 'ajax.php'+urlParams, function(){

            $('.jNiceAjax').jNice();

            if ( isSet( preloader ) )
            {
                preloader.hide();
            }
        } );
    }
}


/*  Preloader - objekt preloadru zobrazí nebo skryje ukazatele načítání
 *
 * @author SomeBW
 * @param preloaderId - id elementu preloaderu
 * @param elementId - id elementu ke skrytí (nepovinný parametr)
 */
function Preloader( preloaderId, elementId )
{
    
    if ( !isSet( elementId ) )
    {
        elementId = false;
    }

    this.show = function()
    {
        if ( elementId != false )
        {
            $( '#'+elementId ).removeClass( 'displayed' );
            $( '#'+elementId ).addClass( 'hidden' );
        }

        $( '#'+preloaderId ).removeClass( 'hidden' );
        $( '#'+preloaderId ).addClass( 'displayed' );
    }

    this.hide = function()
    {
        if ( elementId != false )
        {
            $( '#'+elementId ).removeClass( 'hidden' );
            $( '#'+elementId ).addClass( 'displayed' );
        }

        $( '#'+preloaderId ).removeClass( 'displayed' );
        $( '#'+preloaderId ).addClass( 'hidden' );
    }

}

/*function SlideContent( elId, elWidth )
{
    var elW = 0;
    var elItem = {
        element: document.getElementById( elId ),
        startWidth: elWidth.start,
        endWidth: elWidth.end,
        actWidth: elW,
        direction: 1
    }

    alert(elItem.endWidth);

    this.animate = function()
    {
        animation();
    }

    function animation()
    {
        if ( ( elItem.direction == 1 && elItem.actWidth == elItem.endWidth ) || ( elItem.direction == -1 && elItem.actWidth == elItem.startWidth ) )
        {
            elItem.direction = -1 * elItem.direction;
        }
        else
        {
            alert(elItem.actWidth);
            elItem.actWidth += elItem.direction;
            elItem.element.style.width = elItem.actWidth+'px';
            setTimeout( function(){animation()}, 40 );
        }

    }
    //document.getElementById('detail_search_box').style.width = $('#detail_search_box_form_holder').width()+'px';
}*/





/*function getByCssPath( cssPath )
{
	cssPath = cssPath.trim();
	
	var cssPathArr = cssPath.split(" ");
	
	for ( var i = 0; i < cssPathArr.length; i++ )
	{
		var tag = false;
		var id = false;
		var pathTemp = cssPathArr[i];
		
		if ( cssPathArr[i].search( '#' ) != -1 )
		{
			id = pathTemp.replace( new RegExp( /^[^\#]*([^\.]+).*$/ ), '$1' );
			pathTemp = pathTemp.replace( new RegExp( /^([^\#]*)[^\.]+(.*)$/ ), '$1$2' );
			alert( pathTemp);
		}
		if ( cssPathArr[i].search( new RegExp( /^[a-zA-Z]/ ) ) != -1 )
		{
			tag = pathTemp.replace( new RegExp( /^([a-zA-Z][^.#]+).*$/ ), '$1' );
			alert(tag);
		}
		
		//var id = cssPathArr[i].replace( new RegExp( /^[^#]([^ ]).*$/ ), '$1' );
		//var elParamsArr = cssPathArr[i].split
	}
	//alertEr( cssPathArr );
}*/