/*
 * fckeditor - the text editor for internet - http://www.fckeditor.net
 * copyright (c) 2003-2009 frederico caldeira knabben
 *
 * == begin license ==
 *
 * licensed under the terms of any of the following licenses at your
 * choice:
 *
 *  - gnu general public license version 2 or later (the "gpl")
 *    http://www.gnu.org/licenses/gpl.html
 *
 *  - gnu lesser general public license version 2.1 or later (the "lgpl")
 *    http://www.gnu.org/licenses/lgpl.html
 *
 *  - mozilla public license version 1.1 or later (the "mpl")
 *    http://www.mozilla.org/mpl/mpl-1.1.html
 *
 * == end license ==
 *
 * this is the integration file for javascript.
 *
 * it defines the fckeditor class that can be used to create editor
 * instances in a html page in the client side. for server side
 * operations, use the specific integration system.
 */

// fckeditor class
var fckeditor = function( instancename, width, height, toolbarset, value )
{
	// properties
	this.instancename	= instancename ;
	this.width			= width			|| '100%' ;
	this.height			= height		|| '200' ;
	this.toolbarset		= toolbarset	|| 'default' ;
	this.value			= value			|| '' ;
	this.basepath		= fckeditor.basepath ;
	this.checkbrowser	= true ;
	this.displayerrors	= true ;

	this.config			= new object() ;

	// events
	this.onerror		= null ;	// function( source, errornumber, errordescription )
}

/**
 * this is the default basepath used by all editor instances.
 */
fckeditor.basepath = '/fckeditor/' ;

/**
 * the minimum height used when replacing textareas.
 */
fckeditor.minheight = 200 ;

/**
 * the minimum width used when replacing textareas.
 */
fckeditor.minwidth = 750 ;

fckeditor.prototype.version			= '2.6.4.1' ;
fckeditor.prototype.versionbuild	= '23187' ;

fckeditor.prototype.create = function()
{
	document.write( this.createhtml() ) ;
}

fckeditor.prototype.createhtml = function()
{
	// check for errors
	if ( !this.instancename || this.instancename.length == 0 )
	{
		this._throwerror( 701, 'you must specify an instance name.' ) ;
		return '' ;
	}

	var shtml = '' ;

	if ( !this.checkbrowser || this._iscompatiblebrowser() )
	{
		shtml += '<input type="hidden" id="' + this.instancename + '" name="' + this.instancename + '" value="' + this._htmlencode( this.value ) + '" style="display:none" />' ;
		shtml += this._getconfightml() ;
		shtml += this._getiframehtml() ;
	}
	else
	{
		var swidth  = this.width.tostring().indexof('%')  > 0 ? this.width  : this.width  + 'px' ;
		var sheight = this.height.tostring().indexof('%') > 0 ? this.height : this.height + 'px' ;

		shtml += '<textarea name="' + this.instancename +
			'" rows="4" cols="40" style="width:' + swidth +
			';height:' + sheight ;

		if ( this.tabindex )
			shtml += '" tabindex="' + this.tabindex ;

		shtml += '">' +
			this._htmlencode( this.value ) +
			'<\/textarea>' ;
	}

	return shtml ;
}

fckeditor.prototype.replacetextarea = function()
{
	if ( document.getelementbyid( this.instancename + '___frame' ) )
		return ;
	if ( !this.checkbrowser || this._iscompatiblebrowser() )
	{
		// we must check the elements firstly using the id and then the name.
		var otextarea = document.getelementbyid( this.instancename ) ;
		var colelementsbyname = document.getelementsbyname( this.instancename ) ;
		var i = 0;
		while ( otextarea || i == 0 )
		{
			if ( otextarea && otextarea.tagname.tolowercase() == 'textarea' )
				break ;
			otextarea = colelementsbyname[i++] ;
		}

		if ( !otextarea )
		{
			alert( 'error: the textarea with id or name set to "' + this.instancename + '" was not found' ) ;
			return ;
		}

		otextarea.style.display = 'none' ;

		if ( otextarea.tabindex )
			this.tabindex = otextarea.tabindex ;

		this._inserthtmlbefore( this._getconfightml(), otextarea ) ;
		this._inserthtmlbefore( this._getiframehtml(), otextarea ) ;
	}
}

fckeditor.prototype._inserthtmlbefore = function( html, element )
{
	if ( element.insertadjacenthtml )	// ie
		element.insertadjacenthtml( 'beforebegin', html ) ;
	else								// gecko
	{
		var orange = document.createrange() ;
		orange.setstartbefore( element ) ;
		var ofragment = orange.createcontextualfragment( html );
		element.parentnode.insertbefore( ofragment, element ) ;
	}
}

fckeditor.prototype._getconfightml = function()
{
	var sconfig = '' ;
	for ( var o in this.config )
	{
		if ( sconfig.length > 0 ) sconfig += '&amp;' ;
		sconfig += encodeuricomponent( o ) + '=' + encodeuricomponent( this.config[o] ) ;
	}

	return '<input type="hidden" id="' + this.instancename + '___config" value="' + sconfig + '" style="display:none" />' ;
}

fckeditor.prototype._getiframehtml = function()
{
	var sfile = 'fckeditor.html' ;

	try
	{
		if ( (/fcksource=true/i).test( window.top.location.search ) )
			sfile = 'fckeditor.original.html' ;
	}
	catch (e) { /* ignore it. much probably we are inside a frame where the "top" is in another domain (security error). */ }

	var slink = this.basepath + 'editor/' + sfile + '?instancename=' + encodeuricomponent( this.instancename ) ;
	if (this.toolbarset)
		slink += '&amp;toolbar=' + this.toolbarset ;

	var html = '<iframe id="' + this.instancename +
		'___frame" src="' + slink +
		'" width="' + this.width +
		'" height="' + this.height ;

	if ( this.tabindex )
		html += '" tabindex="' + this.tabindex ;

	html += '" frameborder="0" scrolling="no"></iframe>' ;

	return html ;
}

fckeditor.prototype._iscompatiblebrowser = function()
{
	return fckeditor_iscompatiblebrowser() ;
}

fckeditor.prototype._throwerror = function( errornumber, errordescription )
{
	this.errornumber		= errornumber ;
	this.errordescription	= errordescription ;

	if ( this.displayerrors )
	{
		document.write( '<div style="color: #ff0000">' ) ;
		document.write( '[ fckeditor error ' + this.errornumber + ': ' + this.errordescription + ' ]' ) ;
		document.write( '</div>' ) ;
	}

	if ( typeof( this.onerror ) == 'function' )
		this.onerror( this, errornumber, errordescription ) ;
}

fckeditor.prototype._htmlencode = function( text )
{
	if ( typeof( text ) != "string" )
		text = text.tostring() ;

	text = text.replace(
		/&/g, "&amp;").replace(
		/"/g, "&quot;").replace(
		/</g, "&lt;").replace(
		/>/g, "&gt;") ;

	return text ;
}

;(function()
{
	var textareatoeditor = function( textarea )
	{
		var editor = new fckeditor( textarea.name ) ;

		editor.width = math.max( textarea.offsetwidth, fckeditor.minwidth ) ;
		editor.height = math.max( textarea.offsetheight, fckeditor.minheight ) ;

		return editor ;
	}

	/**
	 * replace all <textarea> elements available in the document with fckeditor
	 * instances.
	 *
	 *	// replace all <textarea> elements in the page.
	 *	fckeditor.replacealltextareas() ;
	 *
	 *	// replace all <textarea class="myclassname"> elements in the page.
	 *	fckeditor.replacealltextareas( 'myclassname' ) ;
	 *
	 *	// selectively replace <textarea> elements, based on custom assertions.
	 *	fckeditor.replacealltextareas( function( textarea, editor )
	 *		{
	 *			// custom code to evaluate the replace, returning false if it
	 *			// must not be done.
	 *			// it also passes the "editor" parameter, so the developer can
	 *			// customize the instance.
	 *		} ) ;
	 */
	fckeditor.replacealltextareas = function()
	{
		var textareas = document.getelementsbytagname( 'textarea' ) ;

		for ( var i = 0 ; i < textareas.length ; i++ )
		{
			var editor = null ;
			var textarea = textareas[i] ;
			var name = textarea.name ;

			// the "name" attribute must exist.
			if ( !name || name.length == 0 )
				continue ;

			if ( typeof arguments[0] == 'string' )
			{
				// the textarea class name could be passed as the function
				// parameter.

				var classregex = new regexp( '(?:^| )' + arguments[0] + '(?:$| )' ) ;

				if ( !classregex.test( textarea.classname ) )
					continue ;
			}
			else if ( typeof arguments[0] == 'function' )
			{
				// an assertion function could be passed as the function parameter.
				// it must explicitly return "false" to ignore a specific <textarea>.
				editor = textareatoeditor( textarea ) ;
				if ( arguments[0]( textarea, editor ) === false )
					continue ;
			}

			if ( !editor )
				editor = textareatoeditor( textarea ) ;

			editor.replacetextarea() ;
		}
	}
})() ;

function fckeditor_iscompatiblebrowser()
{
	var sagent = navigator.useragent.tolowercase() ;

	// internet explorer 5.5+
	if ( /*@cc_on!@*/false && sagent.indexof("mac") == -1 )
	{
		var sbrowserversion = navigator.appversion.match(/msie (.\..)/)[1] ;
		return ( sbrowserversion >= 5.5 ) ;
	}

	// gecko (opera 9 tries to behave like gecko at this point).
	if ( navigator.product == "gecko" && navigator.productsub >= 20030210 && !( typeof(opera) == 'object' && opera.posterror ) )
		return true ;

	// opera 9.50+
	if ( window.opera && window.opera.version && parsefloat( window.opera.version() ) >= 9.5 )
		return true ;

	// adobe air
	// checked before safari because air have the webkit rich text editor
	// features from safari 3.0.4, but the version reported is 420.
	if ( sagent.indexof( ' adobeair/' ) != -1 )
		return ( sagent.match( / adobeair\/(\d+)/ )[1] >= 1 ) ;	// build must be at least v1

	// safari 3+
	if ( sagent.indexof( ' applewebkit/' ) != -1 )
		return ( sagent.match( / applewebkit\/(\d+)/ )[1] >= 522 ) ;	// build must be at least 522 (v3)

	return false ;
}