first commit

stud/FCKeditor/editor/_source/classes/fckcontextmenu.js

@@ -0,0 +1,123 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckcontextmenu.js
+ * 	FCKContextMenu Class: renders an control a context menu.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKContextMenu = function( parentWindow, mouseClickWindow, langDir )
+{
+	var oPanel = this._Panel = new FCKPanel( parentWindow, true ) ;
+	oPanel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ;
+	oPanel.IsContextMenu = true ;
+	
+	var oMenuBlock = this._MenuBlock = new FCKMenuBlock() ;
+	oMenuBlock.Panel = oPanel ;
+	oMenuBlock.OnClick = FCKTools.CreateEventListener( FCKContextMenu_MenuBlock_OnClick, this ) ;
+	
+	this._Redraw = true ;
+	
+	this.SetMouseClickWindow( mouseClickWindow || parentWindow ) ;
+}
+
+
+FCKContextMenu.prototype.SetMouseClickWindow = function( mouseClickWindow )
+{
+	if ( !FCKBrowserInfo.IsIE )
+	{
+		this._Document = mouseClickWindow.document ;
+		this._Document.addEventListener( 'contextmenu', FCKContextMenu_Document_OnContextMenu, false ) ;
+	}
+}
+
+FCKContextMenu.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled )
+{
+	var oItem = this._MenuBlock.AddItem( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled) ;
+	this._Redraw = true ;
+	return oItem ;
+}
+
+FCKContextMenu.prototype.AddSeparator = function()
+{
+	this._MenuBlock.AddSeparator() ;
+	this._Redraw = true ;
+}
+
+FCKContextMenu.prototype.RemoveAllItems = function()
+{
+	this._MenuBlock.RemoveAllItems() ;
+	this._Redraw = true ;
+}
+
+FCKContextMenu.prototype.AttachToElement = function( element )
+{
+	if ( FCKBrowserInfo.IsIE )
+		FCKTools.AddEventListenerEx( element, 'contextmenu', FCKContextMenu_AttachedElement_OnContextMenu, this ) ;
+	else
+		element._FCKContextMenu = this ;
+
+//	element.onmouseup		= FCKContextMenu_AttachedElement_OnMouseUp ;
+}
+
+function FCKContextMenu_Document_OnContextMenu( e )
+{
+	var el = e.target ;
+	
+	while ( el )
+	{
+		if ( el._FCKContextMenu )
+		{
+			FCKTools.CancelEvent( e ) ;
+			FCKContextMenu_AttachedElement_OnContextMenu( e, el._FCKContextMenu, el ) ;
+		}
+		el = el.parentNode ;
+	}
+}
+
+function FCKContextMenu_AttachedElement_OnContextMenu( ev, fckContextMenu, el )
+{
+//	var iButton = e ? e.which - 1 : event.button ;
+
+//	if ( iButton != 2 )
+//		return ;
+
+	var eTarget = el || this ;
+
+	if ( fckContextMenu.OnBeforeOpen )
+		fckContextMenu.OnBeforeOpen.call( fckContextMenu, eTarget ) ;
+
+	if ( fckContextMenu._MenuBlock.Count() == 0 )
+		return false ;
+	
+	if ( fckContextMenu._Redraw )
+	{
+		fckContextMenu._MenuBlock.Create( fckContextMenu._Panel.MainNode ) ;
+		fckContextMenu._Redraw = false ;
+	}
+
+	fckContextMenu._Panel.Show( 
+		ev.pageX || ev.screenX, 
+		ev.pageY || ev.screenY, 
+		ev.currentTarget || null
+	) ;
+	
+	return false ;
+}
+
+function FCKContextMenu_MenuBlock_OnClick( menuItem, contextMenu )
+{
+	contextMenu._Panel.Hide() ;
+	FCKTools.RunFunction( contextMenu.OnItemClick, contextMenu, menuItem ) ;
+}

stud/FCKeditor/editor/_source/classes/fckeditingarea.js

@@ -0,0 +1,190 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckeditingarea.js
+ * 	FCKEditingArea Class: renders an editable area.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+/**
+ * @constructor
+ * @param {String} targetElement The element that will hold the editing area. Any child element present in the target will be deleted.
+ */
+var FCKEditingArea = function( targetElement )
+{
+	this.TargetElement = targetElement ;
+	this.Mode = FCK_EDITMODE_WYSIWYG ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKEditingArea_Cleanup ) ;
+}
+
+
+/**
+ * @param {String} html The complete HTML for the page, including DOCTYPE and the <html> tag.
+ */
+FCKEditingArea.prototype.Start = function( html, secondCall )
+{
+	var eTargetElement	= this.TargetElement ;
+	var oTargetDocument	= FCKTools.GetElementDocument( eTargetElement ) ;
+	
+	// Remove all child nodes from the target.
+	while( eTargetElement.childNodes.length > 0 )
+		eTargetElement.removeChild( eTargetElement.childNodes[0] ) ;
+
+	if ( this.Mode == FCK_EDITMODE_WYSIWYG )
+	{
+		if ( FCKBrowserInfo.IsGecko )
+			html = html.replace( /(<body[^>]*>)\s*(<\/body>)/i, '$1' + GECKO_BOGUS + '$2' ) ;
+	
+		// Create the editing area IFRAME.
+		var oIFrame = this.IFrame = oTargetDocument.createElement( 'iframe' ) ;
+		oIFrame.src = 'javascript:void(0)' ;
+		oIFrame.frameBorder = 0 ;
+		oIFrame.width = oIFrame.height = '100%' ;
+		
+		// Append the new IFRAME to the target.
+		eTargetElement.appendChild( oIFrame ) ;
+		
+		// IE has a bug with the <base> tag... it must have a </base> closer,
+		// otherwise the all sucessive tags will be set as children nodes of the <base>.
+		if ( FCKBrowserInfo.IsIE )
+			html = html.replace( /(<base[^>]*?)\s*\/?>(?!\s*<\/base>)/gi, '$1></base>' ) ;
+
+		// Get the window and document objects used to interact with the newly created IFRAME.
+		this.Window = oIFrame.contentWindow ;
+		
+		// IE: Avoid JavaScript errors thrown by the editing are source (like tags events).
+		// TODO: This error handler is not being fired.
+		// this.Window.onerror = function() { alert( 'Error!' ) ; return true ; }
+
+		var oDoc = this.Document = this.Window.document ;
+		
+		oDoc.open() ;
+		oDoc.write( html ) ;
+		oDoc.close() ;
+		
+		// Firefox 1.0.x is buggy... ohh yes... so let's do it two times and it
+		// will magicaly work.
+		if ( FCKBrowserInfo.IsGecko10 && !secondCall )
+		{
+			this.Start( html, true ) ;
+			return ;
+		}
+		
+		this.Window._FCKEditingArea = this ;
+		
+		// FF 1.0.x is buggy... we must wait a lot to enable editing because
+		// sometimes the content simply disappears, for example when pasting
+		// "bla1!<img src='some_url'>!bla2" in the source and then switching
+		// back to design.
+		if ( FCKBrowserInfo.IsGecko10 )
+			this.Window.setTimeout( FCKEditingArea_CompleteStart, 500 ) ;
+		else
+			FCKEditingArea_CompleteStart.call( this.Window ) ;
+	}
+	else
+	{
+		var eTextarea = this.Textarea = oTargetDocument.createElement( 'textarea' ) ; 
+		eTextarea.className = 'SourceField' ;
+		eTextarea.dir = 'ltr' ;
+		eTextarea.style.width = eTextarea.style.height = '100%' ;
+		eTextarea.style.border = 'none' ;
+		eTargetElement.appendChild( eTextarea ) ;
+
+		eTextarea.value = html  ;
+
+		// Fire the "OnLoad" event.
+		FCKTools.RunFunction( this.OnLoad ) ;
+	}
+}
+
+// "this" here is FCKEditingArea.Window 
+function FCKEditingArea_CompleteStart()
+{
+	// Of Firefox, the DOM takes a little to become available. So we must wait for it in a loop.
+	if ( !this.document.body )
+	{
+		this.setTimeout( FCKEditingArea_CompleteStart, 50 ) ;
+		return ;
+	}
+	
+	var oEditorArea = this._FCKEditingArea ;
+	oEditorArea.MakeEditable() ;
+	
+	// Fire the "OnLoad" event.
+	FCKTools.RunFunction( oEditorArea.OnLoad ) ;
+}
+
+FCKEditingArea.prototype.MakeEditable = function()
+{
+	var oDoc = this.Document ;
+
+	if ( FCKBrowserInfo.IsIE )
+		oDoc.body.contentEditable = true ;
+	else
+	{
+		try
+		{
+			oDoc.designMode = 'on' ;
+
+			// Tell Gecko to use or not the <SPAN> tag for the bold, italic and underline.
+			oDoc.execCommand( 'useCSS', false, !FCKConfig.GeckoUseSPAN ) ;
+
+			// Analysing Firefox 1.5 source code, it seams that there is support for a 
+			// "insertBrOnReturn" command. Applying it gives no error, but it doesn't 
+			// gives the same behavior that you have with IE. It works only if you are
+			// already inside a paragraph and it doesn't render correctly in the first enter.
+			// oDoc.execCommand( 'insertBrOnReturn', false, false ) ;
+
+			// Tell Gecko (Firefox 1.5+) to enable or not live resizing of objects (by Alfonso Martinez)
+			oDoc.execCommand( 'enableObjectResizing', false, !FCKConfig.DisableObjectResizing ) ;
+			
+			// Disable the standard table editing features of Firefox.
+			oDoc.execCommand( 'enableInlineTableEditing', false, !FCKConfig.DisableFFTableHandles ) ;
+		}
+		catch (e) {}
+	}
+}
+
+FCKEditingArea.prototype.Focus = function()
+{
+	try
+	{
+		if ( this.Mode == FCK_EDITMODE_WYSIWYG )
+		{
+			if ( FCKBrowserInfo.IsSafari )
+				this.IFrame.focus() ;
+			else
+				this.Window.focus() ;
+		}
+		else
+			this.Textarea.focus() ;
+	}
+	catch(e) {}
+}
+
+function FCKEditingArea_Cleanup()
+{
+	this.TargetElement = null ;
+	this.IFrame = null ;
+	this.Document = null ;
+	this.Textarea = null ;
+	
+	if ( this.Window )
+	{
+		this.Window._FCKEditingArea = null ;
+		this.Window = null ;
+	}
+}

stud/FCKeditor/editor/_source/classes/fckevents.js

@@ -0,0 +1,51 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckevents.js
+ * 	FCKEvents Class: used to handle events is a advanced way.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKEvents ;
+
+FCKEvents = function( eventsOwner )
+{
+	this.Owner = eventsOwner ;
+	this.RegisteredEvents = new Object() ;
+}
+
+FCKEvents.prototype.AttachEvent = function( eventName, functionPointer )
+{
+	var aTargets ;
+
+	if ( !( aTargets = this.RegisteredEvents[ eventName ] ) ) 
+		this.RegisteredEvents[ eventName ] = [ functionPointer ] ;
+	else
+		aTargets.push( functionPointer ) ;
+}
+
+FCKEvents.prototype.FireEvent = function( eventName, params )
+{
+	var bReturnValue = true ;
+
+	var oCalls = this.RegisteredEvents[ eventName ] ;
+
+	if ( oCalls )
+	{
+		for ( var i = 0 ; i < oCalls.length ; i++ )
+			bReturnValue = ( oCalls[ i ]( this.Owner, params ) && bReturnValue ) ;
+	}
+
+	return bReturnValue ;
+}

stud/FCKeditor/editor/_source/classes/fckicon.js

@@ -0,0 +1,94 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckicon.js
+ * 	FCKIcon Class: renders an icon from a single image, a strip or even a
+ * 	spacer.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKIcon = function( iconPathOrStripInfoArray )
+{
+	var sTypeOf = iconPathOrStripInfoArray ? typeof( iconPathOrStripInfoArray ) : 'undefined' ;
+	switch ( sTypeOf )
+	{
+		case 'number' :
+			this.Path = FCKConfig.SkinPath + 'fck_strip.gif' ;
+			this.Size = 16 ;
+			this.Position = iconPathOrStripInfoArray ;
+			break ;
+		
+		case 'undefined' :
+			this.Path = FCK_SPACER_PATH ;
+			break ;
+		
+		case 'string' :
+			this.Path = iconPathOrStripInfoArray ;
+			break ;
+		
+		default :
+			// It is an array in the format [ StripFilePath, IconSize, IconPosition ]
+			this.Path		= iconPathOrStripInfoArray[0] ;
+			this.Size		= iconPathOrStripInfoArray[1] ;
+			this.Position	= iconPathOrStripInfoArray[2] ;
+	}
+}
+
+FCKIcon.prototype.CreateIconElement = function( document )
+{
+	var eIcon ;
+	
+	if ( this.Position )		// It is using an icons strip image.
+	{
+		var sPos = '-' + ( ( this.Position - 1 ) * this.Size ) + 'px' ;
+	
+		if ( FCKBrowserInfo.IsIE )
+		{
+			// <div class="TB_Button_Image"><img src="strip.gif" style="top:-16px"></div>
+			
+			eIcon = document.createElement( 'DIV' ) ;
+			
+			var eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ;
+			eIconImage.src = this.Path ;
+			eIconImage.style.top = sPos ;
+		}
+		else
+		{
+			// <img class="TB_Button_Image" src="spacer.gif" style="background-position: 0px -16px;background-image: url(strip.gif);">
+			
+			eIcon = document.createElement( 'IMG' ) ;
+			eIcon.src = FCK_SPACER_PATH ;
+			eIcon.style.backgroundPosition	= '0px ' + sPos ;
+			eIcon.style.backgroundImage		= 'url(' + this.Path + ')' ;
+		}
+	}
+	else					// It is using a single icon image.
+	{
+		// This is not working well with IE. See notes bellow.
+		// <img class="TB_Button_Image" src="smiley.gif">
+//		eIcon = document.createElement( 'IMG' ) ;
+//		eIcon.src = this.Path ? this.Path : FCK_SPACER_PATH ;
+
+		// IE makes the button 1px higher if using the <img> directly, so we
+		// are changing to the <div> system to clip the image correctly.
+		eIcon = document.createElement( 'DIV' ) ;
+		
+		var eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ;
+		eIconImage.src = this.Path ? this.Path : FCK_SPACER_PATH ;
+	}
+	
+	eIcon.className = 'TB_Button_Image' ;
+
+	return eIcon ;
+}

stud/FCKeditor/editor/_source/classes/fckiecleanup.js

@@ -0,0 +1,51 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckiecleanup.js
+ * 	FCKIECleanup Class: a generic class used as a tool to remove IE leaks.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+
+var	FCKIECleanup = function( attachWindow )
+{
+
+	this.Items = new Array() ;
+
+	attachWindow._FCKCleanupObj = this ;
+	attachWindow.attachEvent( 'onunload', FCKIECleanup_Cleanup ) ;	
+}
+	
+FCKIECleanup.prototype.AddItem = function( dirtyItem, cleanupFunction )
+{
+	this.Items.push( [ dirtyItem, cleanupFunction ] ) ;
+}
+	
+function FCKIECleanup_Cleanup()
+{
+	var aItems = this._FCKCleanupObj.Items ;
+	var iLenght = aItems.length ;
+
+	for ( var i = 0 ; i < iLenght ; i++ )
+	{
+		var oItem = aItems[i] ;
+		oItem[1].call( oItem[0] ) ;
+		aItems[i] = null ;
+	}
+	
+	this._FCKCleanupObj = null ;
+	
+	if ( CollectGarbage )
+		CollectGarbage() ;
+}

stud/FCKeditor/editor/_source/classes/fckmenublock.js

@@ -0,0 +1,140 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckmenublock.js
+ * 	Renders a list of menu items.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+
+var FCKMenuBlock = function()
+{
+	this._Items	= new Array() ;
+}
+
+
+FCKMenuBlock.prototype.Count = function()
+{
+	return this._Items.length ;
+}
+
+FCKMenuBlock.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled )
+{
+	var oItem = new FCKMenuItem( this, name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) ;
+	
+	oItem.OnClick		= FCKTools.CreateEventListener( FCKMenuBlock_Item_OnClick, this ) ;
+	oItem.OnActivate	= FCKTools.CreateEventListener( FCKMenuBlock_Item_OnActivate, this ) ;
+	
+	this._Items.push( oItem ) ;
+
+	return oItem ;
+}
+
+FCKMenuBlock.prototype.AddSeparator = function()
+{
+	this._Items.push( new FCKMenuSeparator() ) ;
+}
+
+FCKMenuBlock.prototype.RemoveAllItems = function()
+{
+	this._Items = new Array() ;
+	
+	var eItemsTable = this._ItemsTable ;
+	if ( eItemsTable )
+	{
+		while ( eItemsTable.rows.length > 0 )
+			eItemsTable.deleteRow( 0 ) ;
+	}
+}
+
+FCKMenuBlock.prototype.Create = function( parentElement )
+{
+	if ( !this._ItemsTable )
+	{
+		if ( FCK.IECleanup )
+			FCK.IECleanup.AddItem( this, FCKMenuBlock_Cleanup ) ;
+
+		this._Window = FCKTools.GetElementWindow( parentElement ) ;
+
+		var oDoc = FCKTools.GetElementDocument( parentElement ) ;
+
+		var eTable = parentElement.appendChild( oDoc.createElement( 'table' ) ) ;
+		eTable.cellPadding = 0 ;
+		eTable.cellSpacing = 0 ;
+
+		FCKTools.DisableSelection( eTable ) ;
+		
+		var oMainElement = eTable.insertRow(-1).insertCell(-1) ;
+		oMainElement.className = 'MN_Menu' ;
+	
+		var eItemsTable = this._ItemsTable = oMainElement.appendChild( oDoc.createElement( 'table' ) ) ;
+		eItemsTable.cellPadding = 0 ;
+		eItemsTable.cellSpacing = 0 ;		
+	}
+	
+	for ( var i = 0 ; i < this._Items.length ; i++ )
+		this._Items[i].Create( this._ItemsTable ) ;
+}
+
+/* Events */
+
+function FCKMenuBlock_Item_OnClick( clickedItem, menuBlock )
+{
+	FCKTools.RunFunction( menuBlock.OnClick, menuBlock, [ clickedItem ] ) ;
+}
+
+function FCKMenuBlock_Item_OnActivate( menuBlock )
+{
+	var oActiveItem = menuBlock._ActiveItem ;
+	
+	if ( oActiveItem && oActiveItem != this )
+	{
+		// Set the focus to this menu block window (to fire OnBlur on opened panels).
+		if ( !FCKBrowserInfo.IsIE && oActiveItem.HasSubMenu && !this.HasSubMenu )
+			menuBlock._Window.focus() ;
+
+		oActiveItem.Deactivate() ;		
+	}
+
+	menuBlock._ActiveItem = this ;
+}
+
+function FCKMenuBlock_Cleanup()
+{
+	this._Window = null ;
+	this._ItemsTable = null ;
+}
+
+// ################# //
+
+var FCKMenuSeparator = function()
+{}
+
+FCKMenuSeparator.prototype.Create = function( parentTable )
+{
+	var oDoc = FCKTools.GetElementDocument( parentTable ) ;
+
+	var r = parentTable.insertRow(-1) ;
+	
+	var eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Separator MN_Icon' ;
+
+	eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Separator' ;
+	eCell.appendChild( oDoc.createElement( 'DIV' ) ).className = 'MN_Separator_Line' ;
+
+	eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Separator' ;
+	eCell.appendChild( oDoc.createElement( 'DIV' ) ).className = 'MN_Separator_Line' ;
+}

stud/FCKeditor/editor/_source/classes/fckmenublockpanel.js

@@ -0,0 +1,51 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckmenublockpanel.js
+ * 	This class is a menu block that behaves like a panel. It's a mix of the
+ * 	FCKMenuBlock and FCKPanel classes.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+
+var FCKMenuBlockPanel = function()
+{
+	// Call the "base" constructor.
+	FCKMenuBlock.call( this ) ;
+}
+
+FCKMenuBlockPanel.prototype = new FCKMenuBlock() ;
+
+
+// Override the create method.
+FCKMenuBlockPanel.prototype.Create = function()
+{
+	var oPanel = this.Panel = ( this.Parent && this.Parent.Panel ? this.Parent.Panel.CreateChildPanel() : new FCKPanel() ) ;
+	oPanel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ;
+
+	// Call the "base" implementation.
+	FCKMenuBlock.prototype.Create.call( this, oPanel.MainNode ) ;
+}
+
+FCKMenuBlockPanel.prototype.Show = function( x, y, relElement )
+{
+	if ( !this.Panel.CheckIsOpened() )
+		this.Panel.Show( x, y, relElement ) ;
+}
+
+FCKMenuBlockPanel.prototype.Hide = function()
+{
+	if ( this.Panel.CheckIsOpened() )
+		this.Panel.Hide() ;
+}

stud/FCKeditor/editor/_source/classes/fckmenuitem.js

@@ -0,0 +1,157 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckmenuitem.js
+ * 	Defines and renders a menu items in a menu block.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+
+var FCKMenuItem = function( parentMenuBlock, name, label, iconPathOrStripInfoArray, isDisabled )
+{
+	this.Name		= name ;
+	this.Label		= label || name ;
+	this.IsDisabled	= isDisabled ;
+	
+	this.Icon = new FCKIcon( iconPathOrStripInfoArray ) ;
+	
+	this.SubMenu			= new FCKMenuBlockPanel() ;
+	this.SubMenu.Parent		= parentMenuBlock ;
+	this.SubMenu.OnClick	= FCKTools.CreateEventListener( FCKMenuItem_SubMenu_OnClick, this ) ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKMenuItem_Cleanup ) ;
+}
+
+
+FCKMenuItem.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled )
+{
+	this.HasSubMenu = true ;
+	return this.SubMenu.AddItem( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) ;
+}
+
+FCKMenuItem.prototype.AddSeparator = function()
+{
+	this.SubMenu.AddSeparator() ;
+}
+
+FCKMenuItem.prototype.Create = function( parentTable )
+{
+	var bHasSubMenu = this.HasSubMenu ;
+	
+	var oDoc = FCKTools.GetElementDocument( parentTable ) ;
+
+	// Add a row in the table to hold the menu item.
+	var r = this.MainElement = parentTable.insertRow(-1) ;
+	r.className = this.IsDisabled ? 'MN_Item_Disabled' : 'MN_Item' ;
+
+	// Set the row behavior.
+	if ( !this.IsDisabled )
+	{
+		FCKTools.AddEventListenerEx( r, 'mouseover', FCKMenuItem_OnMouseOver, [ this ] ) ;
+		FCKTools.AddEventListenerEx( r, 'click', FCKMenuItem_OnClick, [ this ] ) ;
+
+		if ( !bHasSubMenu )
+			FCKTools.AddEventListenerEx( r, 'mouseout', FCKMenuItem_OnMouseOut, [ this ] ) ;
+	}
+	
+	// Create the icon cell.
+	var eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Icon' ;
+	eCell.appendChild( this.Icon.CreateIconElement( oDoc ) ) ;
+
+	// Create the label cell.
+	eCell = r.insertCell(-1) ;
+	eCell.className = 'MN_Label' ;
+	eCell.noWrap = true ;
+	eCell.appendChild( oDoc.createTextNode( this.Label ) ) ;
+	
+	// Create the arrow cell and setup the sub menu panel (if needed).
+	eCell = r.insertCell(-1) ;
+	if ( bHasSubMenu )
+	{
+		eCell.className = 'MN_Arrow' ;
+
+		// The arrow is a fixed size image.
+		var eArrowImg = eCell.appendChild( oDoc.createElement( 'IMG' ) ) ;
+		eArrowImg.src = FCK_IMAGES_PATH + 'arrow_' + FCKLang.Dir + '.gif' ;
+		eArrowImg.width	 = 4 ;
+		eArrowImg.height = 7 ;
+		
+		this.SubMenu.Create() ;
+		this.SubMenu.Panel.OnHide = FCKTools.CreateEventListener( FCKMenuItem_SubMenu_OnHide, this ) ;
+	}
+}
+
+FCKMenuItem.prototype.Activate = function()
+{
+	this.MainElement.className = 'MN_Item_Over' ;
+
+	if ( this.HasSubMenu )
+	{
+		// Show the child menu block. The ( +2, -2 ) correction is done because
+		// of the padding in the skin. It is not a good solution because one
+		// could change the skin and so the final result would not be accurate.
+		// For now it is ok because we are controlling the skin.
+		this.SubMenu.Show( this.MainElement.offsetWidth + 2, -2, this.MainElement ) ;
+	}
+
+	FCKTools.RunFunction( this.OnActivate, this ) ;
+}
+
+FCKMenuItem.prototype.Deactivate = function()
+{
+	this.MainElement.className = 'MN_Item' ;
+
+	if ( this.HasSubMenu )
+		this.SubMenu.Hide() ;
+}
+
+/* Events */
+
+function FCKMenuItem_SubMenu_OnClick( clickedItem, listeningItem )
+{
+	FCKTools.RunFunction( listeningItem.OnClick, listeningItem, [ clickedItem ] ) ;
+}
+
+function FCKMenuItem_SubMenu_OnHide( menuItem )
+{
+	menuItem.Deactivate() ;
+}
+
+function FCKMenuItem_OnClick( ev, menuItem )
+{
+	if ( menuItem.HasSubMenu )
+		menuItem.Activate() ;
+	else
+	{
+		menuItem.Deactivate() ;
+		FCKTools.RunFunction( menuItem.OnClick, menuItem, [ menuItem ] ) ;
+	}
+}
+
+function FCKMenuItem_OnMouseOver( ev, menuItem )
+{
+	menuItem.Activate() ;
+}
+
+function FCKMenuItem_OnMouseOut( ev, menuItem )
+{
+	menuItem.Deactivate() ;
+}
+
+function FCKMenuItem_Cleanup()
+{
+	this.MainElement = null ;
+}

stud/FCKeditor/editor/_source/classes/fckpanel.js

@@ -0,0 +1,295 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckpanel.js
+ * 	Component that creates floating panels. It is used by many 
+ * 	other components, like the toolbar items, context menu, etc...
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+
+var FCKPanel = function( parentWindow )
+{
+	this.IsRTL			= ( FCKLang.Dir == 'rtl' ) ;
+	this.IsContextMenu	= false ;
+	this._LockCounter	= 0 ;
+	
+	this._Window = parentWindow || window ;
+	
+	var oDocument ;
+	
+	if ( FCKBrowserInfo.IsIE )
+	{
+		// Create the Popup that will hold the panel.
+		this._Popup	= this._Window.createPopup() ;
+		oDocument = this.Document = this._Popup.document ;
+	}
+	else
+	{
+		var oIFrame = this._IFrame = this._Window.document.createElement('iframe') ; 
+		oIFrame.src					= 'javascript:void(0)' ;
+		oIFrame.allowTransparency	= true ;
+		oIFrame.frameBorder			= '0' ;
+		oIFrame.scrolling			= 'no' ;
+		oIFrame.style.position		= 'absolute';
+		oIFrame.style.zIndex		= FCKConfig.FloatingPanelsZIndex ;
+		oIFrame.width = oIFrame.height = 0 ;
+
+		if ( this._Window == window.parent && window.frameElement )
+			window.frameElement.parentNode.insertBefore( oIFrame, window.frameElement ) ;
+		else
+			this._Window.document.body.appendChild( oIFrame ) ;
+		
+		var oIFrameWindow = oIFrame.contentWindow ; 
+		
+		oDocument = this.Document = oIFrameWindow.document ;
+
+		// Initialize the IFRAME document body.
+		oDocument.open() ;
+		oDocument.write( '<html><head></head><body style="margin:0px;padding:0px;"><\/body><\/html>' ) ;
+		oDocument.close() ;
+
+		FCKTools.AddEventListenerEx( oIFrameWindow, 'focus', FCKPanel_Window_OnFocus, this ) ;
+		FCKTools.AddEventListenerEx( oIFrameWindow, 'blur', FCKPanel_Window_OnBlur, this ) ;
+	}
+
+	oDocument.dir = FCKLang.Dir ;
+	
+	oDocument.oncontextmenu = FCKTools.CancelEvent ;
+
+
+	// Create the main DIV that is used as the panel base.
+	this.MainNode = oDocument.body.appendChild( oDocument.createElement('DIV') ) ;
+
+	// The "float" property must be set so Firefox calculates the size correcly.
+	this.MainNode.style.cssFloat = this.IsRTL ? 'right' : 'left' ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKPanel_Cleanup ) ;
+}
+
+
+FCKPanel.prototype.AppendStyleSheet = function( styleSheet )
+{
+	FCKTools.AppendStyleSheet( this.Document, styleSheet ) ;
+}
+
+FCKPanel.prototype.Preload = function( x, y, relElement )
+{
+	// The offsetWidth and offsetHeight properties are not available if the 
+	// element is not visible. So we must "show" the popup with no size to
+	// be able to use that values in the second call (IE only).
+	if ( this._Popup )
+		this._Popup.show( x, y, 0, 0, relElement ) ;
+}
+
+FCKPanel.prototype.Show = function( x, y, relElement, width, height )
+{
+	if ( this._Popup )
+	{
+		// The offsetWidth and offsetHeight properties are not available if the 
+		// element is not visible. So we must "show" the popup with no size to
+		// be able to use that values in the second call.
+		this._Popup.show( x, y, 0, 0, relElement ) ;
+
+		// The following lines must be place after the above "show", otherwise it 
+		// doesn't has the desired effect.
+		this.MainNode.style.width	= width ? width + 'px' : '' ;
+		this.MainNode.style.height	= height ? height + 'px' : '' ;
+		
+		var iMainWidth = this.MainNode.offsetWidth ;
+
+		if ( this.IsRTL )
+		{
+			if ( this.IsContextMenu )
+				x  = x - iMainWidth + 1 ;
+			else if ( relElement )
+				x  = ( x * -1 ) + relElement.offsetWidth - iMainWidth ;
+		}
+	
+		// Second call: Show the Popup at the specified location, with the correct size.
+		this._Popup.show( x, y, iMainWidth, this.MainNode.offsetHeight, relElement ) ;
+		
+		if ( this.OnHide )
+		{
+			if ( this._Timer )
+				CheckPopupOnHide.call( this, true ) ;
+
+			this._Timer = FCKTools.SetInterval( CheckPopupOnHide, 100, this ) ;
+		}
+	}
+	else
+	{
+		// Do not fire OnBlur while the panel is opened.
+		if ( typeof( FCKFocusManager ) != 'undefined' )
+			FCKFocusManager.Lock() ;
+
+		if ( this.ParentPanel )
+			this.ParentPanel.Lock() ;
+
+		this.MainNode.style.width	= width ? width + 'px' : '' ;
+		this.MainNode.style.height	= height ? height + 'px' : '' ;
+
+		var iMainWidth = this.MainNode.offsetWidth ;
+
+		if ( !width )	this._IFrame.width	= 1 ;
+		if ( !height )	this._IFrame.height	= 1 ;
+
+		// This is weird... but with Firefox, we must get the offsetWidth before
+		// setting the _IFrame size (which returns "0"), and then after that,
+		// to return the correct width. Remove the first step and it will not
+		// work when the editor is in RTL.
+		iMainWidth = this.MainNode.offsetWidth ;
+
+		var oPos = FCKTools.GetElementPosition( ( relElement.nodeType == 9 ? relElement.body : relElement), this._Window ) ;
+
+		if ( this.IsRTL && !this.IsContextMenu )
+			x = ( x * -1 ) ;
+
+		x += oPos.X ;
+		y += oPos.Y ;
+
+		if ( this.IsRTL )
+		{
+			if ( this.IsContextMenu )
+				x  = x - iMainWidth + 1 ;
+			else if ( relElement )
+				x  = x + relElement.offsetWidth - iMainWidth ;
+		}
+		else
+		{
+			var oViewPaneSize = FCKTools.GetViewPaneSize( this._Window ) ;
+			var oScrollPosition = FCKTools.GetScrollPosition( this._Window ) ;
+			
+			var iViewPaneHeight	= oViewPaneSize.Height + oScrollPosition.Y ;
+			var iViewPaneWidth	= oViewPaneSize.Width + oScrollPosition.X ;
+
+			if ( ( x + iMainWidth ) > iViewPaneWidth )
+				x -= x + iMainWidth - iViewPaneWidth ;
+
+			if ( ( y + this.MainNode.offsetHeight ) > iViewPaneHeight )
+				y -= y + this.MainNode.offsetHeight - iViewPaneHeight ;
+		}
+		
+		if ( x < 0 )
+			 x = 0 ;
+
+		// Set the context menu DIV in the specified location.
+		this._IFrame.style.left	= x + 'px' ;
+		this._IFrame.style.top	= y + 'px' ;
+		
+		var iWidth	= iMainWidth ;
+		var iHeight	= this.MainNode.offsetHeight ;
+		
+		this._IFrame.width	= iWidth ;
+		this._IFrame.height = iHeight ;
+
+		// Move the focus to the IFRAME so we catch the "onblur".
+		this._IFrame.contentWindow.focus() ;
+	}
+
+	this._IsOpened = true ;
+
+	FCKTools.RunFunction( this.OnShow, this ) ;
+}
+
+FCKPanel.prototype.Hide = function( ignoreOnHide )
+{
+	if ( this._Popup )
+		this._Popup.hide() ;
+	else
+	{
+		if ( !this._IsOpened )
+			return ;
+		
+		// Enable the editor to fire the "OnBlur".
+		if ( typeof( FCKFocusManager ) != 'undefined' )
+			FCKFocusManager.Unlock() ;
+
+		// It is better to set the sizes to 0, otherwise Firefox would have 
+		// rendering problems.
+		this._IFrame.width = this._IFrame.height = 0 ;
+
+		this._IsOpened = false ;
+		
+		if ( this.ParentPanel )
+			this.ParentPanel.Unlock() ;
+
+		if ( !ignoreOnHide )
+			FCKTools.RunFunction( this.OnHide, this ) ;
+	}
+}
+
+FCKPanel.prototype.CheckIsOpened = function()
+{
+	if ( this._Popup )
+		return this._Popup.isOpen ;
+	else
+		return this._IsOpened ;
+}
+
+FCKPanel.prototype.CreateChildPanel = function()
+{
+	var oWindow = this._Popup ? FCKTools.GetParentWindow( this.Document ) : this._Window ;
+
+	var oChildPanel = new FCKPanel( oWindow, true ) ;
+	oChildPanel.ParentPanel = this ;
+	
+	return oChildPanel ;
+}
+
+FCKPanel.prototype.Lock = function()
+{
+	this._LockCounter++ ;
+}
+
+FCKPanel.prototype.Unlock = function()
+{
+	if ( --this._LockCounter == 0 && !this.HasFocus )
+		this.Hide() ;
+}
+
+/* Events */
+
+function FCKPanel_Window_OnFocus( e, panel )
+{
+	panel.HasFocus = true ;
+}
+
+function FCKPanel_Window_OnBlur( e, panel )
+{
+	panel.HasFocus = false ;
+	
+	if ( panel._LockCounter == 0 )
+		FCKTools.RunFunction( panel.Hide, panel ) ;
+}
+
+function CheckPopupOnHide( forceHide )
+{
+	if ( forceHide || !this._Popup.isOpen )
+	{
+		window.clearInterval( this._Timer ) ;
+		this._Timer = null ;
+	
+		FCKTools.RunFunction( this.OnHide, this ) ;
+	}
+}
+
+function FCKPanel_Cleanup()
+{
+	this._Popup = null ;
+	this._Window = null ;
+	this.Document = null ;
+	this.MainNode = null ;
+}

stud/FCKeditor/editor/_source/classes/fckplugin.js

@@ -0,0 +1,52 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckplugin.js
+ * 	FCKPlugin Class: Represents a single plugin.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKPlugin = function( name, availableLangs, basePath )
+{
+	this.Name = name ;
+	this.BasePath = basePath ? basePath : FCKConfig.PluginsPath ;
+	this.Path = this.BasePath + name + '/' ;
+	
+	if ( !availableLangs || availableLangs.length == 0 )
+		this.AvailableLangs = new Array() ;
+	else
+		this.AvailableLangs = availableLangs.split(',') ;
+}
+
+FCKPlugin.prototype.Load = function()
+{
+	// Load the language file, if defined.
+	if ( this.AvailableLangs.length > 0 )
+	{
+		var sLang ;
+		
+		// Check if the plugin has the language file for the active language.
+		if ( this.AvailableLangs.indexOf( FCKLanguageManager.ActiveLanguage.Code ) >= 0 )
+			sLang = FCKLanguageManager.ActiveLanguage.Code ;
+		else
+			// Load the default language file (first one) if the current one is not available.
+			sLang = this.AvailableLangs[0] ;
+		
+		// Add the main plugin script.
+		LoadScript( this.Path + 'lang/' + sLang + '.js' ) ;		
+	}
+		
+	// Add the main plugin script.
+	LoadScript( this.Path + 'fckplugin.js' ) ;
+}

stud/FCKeditor/editor/_source/classes/fckspecialcombo.js

@@ -0,0 +1,351 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckspecialcombo.js
+ * 	FCKSpecialCombo Class: represents a special combo.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKSpecialCombo = function( caption, fieldWidth, panelWidth, panelMaxHeight, parentWindow )
+{
+	// Default properties values.
+	this.FieldWidth		= fieldWidth || 100 ;
+	this.PanelWidth		= panelWidth || 150 ;
+	this.PanelMaxHeight	= panelMaxHeight || 150 ;
+	this.Label			= ' ' ;
+	this.Caption		= caption ;
+	this.Tooltip		= caption ;
+	this.Style			= FCK_TOOLBARITEM_ICONTEXT ;
+
+	this.Enabled = true ;
+	
+	this.Items = new Object() ;
+	
+	this._Panel = new FCKPanel( parentWindow || window, true ) ;
+	this._Panel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ;
+	this._PanelBox = this._Panel.MainNode.appendChild( this._Panel.Document.createElement( 'DIV' ) ) ;
+	this._PanelBox.className = 'SC_Panel' ;
+	this._PanelBox.style.width = this.PanelWidth + 'px' ;
+
+	this._PanelBox.innerHTML = '<table cellpadding="0" cellspacing="0" width="100%" style="TABLE-LAYOUT: fixed"><tr><td nowrap></td></tr></table>' ;
+	
+	this._ItemsHolderEl = this._PanelBox.getElementsByTagName('TD')[0] ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKSpecialCombo_Cleanup ) ;
+
+//	this._Panel.StyleSheet = FCKConfig.SkinPath + 'fck_contextmenu.css' ;
+//	this._Panel.Create() ;
+//	this._Panel.PanelDiv.className += ' SC_Panel' ;
+//	this._Panel.PanelDiv.innerHTML = '<table cellpadding="0" cellspacing="0" width="100%" style="TABLE-LAYOUT: fixed"><tr><td nowrap></td></tr></table>' ;
+//	this._ItemsHolderEl = this._Panel.PanelDiv.getElementsByTagName('TD')[0] ;
+}
+
+function FCKSpecialCombo_ItemOnMouseOver()
+{
+	this.className += ' SC_ItemOver' ;
+}
+
+function FCKSpecialCombo_ItemOnMouseOut()
+{
+	this.className = this.originalClass ;
+}
+
+function FCKSpecialCombo_ItemOnClick()
+{
+	this.className = this.originalClass ;
+
+	this.FCKSpecialCombo._Panel.Hide() ;
+
+	this.FCKSpecialCombo.SetLabel( this.FCKItemLabel ) ;
+
+	if ( typeof( this.FCKSpecialCombo.OnSelect ) == 'function' )
+		this.FCKSpecialCombo.OnSelect( this.FCKItemID, this ) ;
+}
+
+FCKSpecialCombo.prototype.AddItem = function( id, html, label, bgColor )
+{
+	// <div class="SC_Item" onmouseover="this.className='SC_Item SC_ItemOver';" onmouseout="this.className='SC_Item';"><b>Bold 1</b></div>
+	var oDiv = this._ItemsHolderEl.appendChild( this._Panel.Document.createElement( 'DIV' ) ) ;
+	oDiv.className = oDiv.originalClass = 'SC_Item' ;
+	oDiv.innerHTML = html ;
+	oDiv.FCKItemID = id ;
+	oDiv.FCKItemLabel = label || id ;
+	oDiv.FCKSpecialCombo = this ;
+	oDiv.Selected = false ;
+
+	// In IE, the width must be set so the borders are shown correctly when the content overflows.
+	if ( FCKBrowserInfo.IsIE )
+		oDiv.style.width = '100%' ;
+	
+	if ( bgColor )
+		oDiv.style.backgroundColor = bgColor ;
+
+	oDiv.onmouseover	= FCKSpecialCombo_ItemOnMouseOver ;
+	oDiv.onmouseout		= FCKSpecialCombo_ItemOnMouseOut ;
+	oDiv.onclick		= FCKSpecialCombo_ItemOnClick ;
+	
+	this.Items[ id.toString().toLowerCase() ] = oDiv ;
+	
+	return oDiv ;
+}
+
+FCKSpecialCombo.prototype.SelectItem = function( itemId )
+{
+	itemId = itemId ? itemId.toString().toLowerCase() : '' ;
+	
+	var oDiv = this.Items[ itemId ] ;
+	if ( oDiv )
+	{
+		oDiv.className = oDiv.originalClass = 'SC_ItemSelected' ;
+		oDiv.Selected = true ;
+	}
+}
+
+FCKSpecialCombo.prototype.SelectItemByLabel = function( itemLabel, setLabel )
+{
+	for ( var id in this.Items )
+	{
+		var oDiv = this.Items[id] ;
+
+		if ( oDiv.FCKItemLabel == itemLabel )
+		{
+			oDiv.className = oDiv.originalClass = 'SC_ItemSelected' ;
+			oDiv.Selected = true ;
+			
+			if ( setLabel )
+				this.SetLabel( itemLabel ) ;
+		}
+	}
+}
+
+FCKSpecialCombo.prototype.DeselectAll = function( clearLabel )
+{
+	for ( var i in this.Items )
+	{
+		this.Items[i].className = this.Items[i].originalClass = 'SC_Item' ;
+		this.Items[i].Selected = false ;
+	}
+	
+	if ( clearLabel )
+		this.SetLabel( '' ) ;
+}
+
+FCKSpecialCombo.prototype.SetLabelById = function( id )
+{
+	id = id ? id.toString().toLowerCase() : '' ;
+	
+	var oDiv = this.Items[ id ] ;
+	this.SetLabel( oDiv ? oDiv.FCKItemLabel : '' ) ;
+}
+
+FCKSpecialCombo.prototype.SetLabel = function( text )
+{
+	this.Label = text.length == 0 ? '&nbsp;' : text ;
+
+	if ( this._LabelEl )
+		this._LabelEl.innerHTML = this.Label ;
+}
+
+FCKSpecialCombo.prototype.SetEnabled = function( isEnabled )
+{
+	this.Enabled = isEnabled ;
+	
+	this._OuterTable.className = isEnabled ? '' : 'SC_FieldDisabled' ;
+}
+
+FCKSpecialCombo.prototype.Create = function( targetElement )
+{
+	var oDoc = FCKTools.GetElementDocument( targetElement ) ;
+	var eOuterTable = this._OuterTable = targetElement.appendChild( oDoc.createElement( 'TABLE' ) ) ;
+	eOuterTable.cellPadding = 0 ;
+	eOuterTable.cellSpacing = 0 ;
+	
+	eOuterTable.insertRow(-1) ;
+	
+	var sClass ;
+	var bShowLabel ;
+	
+	switch ( this.Style )
+	{
+		case FCK_TOOLBARITEM_ONLYICON :
+			sClass = 'TB_ButtonType_Icon' ;
+			bShowLabel = false;
+			break ;
+		case FCK_TOOLBARITEM_ONLYTEXT :
+			sClass = 'TB_ButtonType_Text' ;
+			bShowLabel = false;
+			break ;
+		case FCK_TOOLBARITEM_ICONTEXT :
+			bShowLabel = true;
+			break ;
+	}
+
+	if ( this.Caption && this.Caption.length > 0 && bShowLabel )
+	{
+		var oCaptionCell = eOuterTable.rows[0].insertCell(-1) ;
+		oCaptionCell.innerHTML = this.Caption ;
+		oCaptionCell.className = 'SC_FieldCaption' ;
+	}
+	
+	// Create the main DIV element.
+	var oField = FCKTools.AppendElement( eOuterTable.rows[0].insertCell(-1), 'div' ) ;
+	if ( bShowLabel )
+	{
+		oField.className = 'SC_Field' ;
+		oField.style.width = this.FieldWidth + 'px' ;
+		oField.innerHTML = '<table width="100%" cellpadding="0" cellspacing="0" style="TABLE-LAYOUT: fixed;"><tbody><tr><td class="SC_FieldLabel"><label>&nbsp;</label></td><td class="SC_FieldButton">&nbsp;</td></tr></tbody></table>' ;
+
+		this._LabelEl = oField.getElementsByTagName('label')[0] ;		// Memory Leak
+		this._LabelEl.innerHTML = this.Label ;
+	}
+	else
+	{
+		oField.className = 'TB_Button_Off' ;
+		//oField.innerHTML = '<span className="SC_FieldCaption">' + this.Caption + '<table cellpadding="0" cellspacing="0" style="TABLE-LAYOUT: fixed;"><tbody><tr><td class="SC_FieldButton" style="border-left: none;">&nbsp;</td></tr></tbody></table>' ;
+		//oField.innerHTML = '<table cellpadding="0" cellspacing="0" style="TABLE-LAYOUT: fixed;"><tbody><tr><td class="SC_FieldButton" style="border-left: none;">&nbsp;</td></tr></tbody></table>' ;
+		
+		// Gets the correct CSS class to use for the specified style (param).
+		oField.innerHTML = '<table title="' + this.Tooltip + '" class="' + sClass + '" cellspacing="0" cellpadding="0" border="0">' +
+				'<tr>' +
+					//'<td class="TB_Icon"><img src="' + FCKConfig.SkinPath + 'toolbar/' + this.Command.Name.toLowerCase() + '.gif" width="21" height="21"></td>' +
+					'<td><img class="TB_Button_Padding" src="' + FCK_SPACER_PATH + '" /></td>' +
+					'<td class="TB_Text">' + this.Caption + '</td>' +
+					'<td><img class="TB_Button_Padding" src="' + FCK_SPACER_PATH + '" /></td>' +
+					'<td class="TB_ButtonArrow"><img src="' + FCKConfig.SkinPath + 'images/toolbar.buttonarrow.gif" width="5" height="3"></td>' +
+					'<td><img class="TB_Button_Padding" src="' + FCK_SPACER_PATH + '" /></td>' +
+				'</tr>' +
+			'</table>' ;
+	}
+
+
+	// Events Handlers
+
+	oField.SpecialCombo = this ;
+	
+	oField.onmouseover	= FCKSpecialCombo_OnMouseOver ;
+	oField.onmouseout	= FCKSpecialCombo_OnMouseOut ;
+	oField.onclick		= FCKSpecialCombo_OnClick ;
+	
+	FCKTools.DisableSelection( this._Panel.Document.body ) ;
+}
+
+function FCKSpecialCombo_Cleanup()
+{
+	this._LabelEl = null ;
+	this._OuterTable = null ;
+	this._ItemsHolderEl = null ;
+	this._PanelBox = null ;
+	
+	if ( this.Items )
+	{
+		for ( var key in this.Items )
+			this.Items[key] = null ;
+	}
+}	
+
+function FCKSpecialCombo_OnMouseOver()
+{
+	if ( this.SpecialCombo.Enabled )
+	{
+		switch ( this.SpecialCombo.Style )
+		{
+		case FCK_TOOLBARITEM_ONLYICON :
+			this.className = 'TB_Button_On_Over';
+			break ;
+		case FCK_TOOLBARITEM_ONLYTEXT :
+			this.className = 'TB_Button_On_Over';
+			break ;
+		case FCK_TOOLBARITEM_ICONTEXT :
+			this.className = 'SC_Field SC_FieldOver' ;
+			break ;
+		}
+	}
+}
+	
+function FCKSpecialCombo_OnMouseOut()
+{
+	switch ( this.SpecialCombo.Style )
+	{
+		case FCK_TOOLBARITEM_ONLYICON :
+			this.className = 'TB_Button_Off';
+			break ;
+		case FCK_TOOLBARITEM_ONLYTEXT :
+			this.className = 'TB_Button_Off';
+			break ;
+		case FCK_TOOLBARITEM_ICONTEXT :
+			this.className='SC_Field' ;
+			break ;
+	}
+}
+	
+function FCKSpecialCombo_OnClick( e )
+{
+	// For Mozilla we must stop the event propagation to avoid it hiding 
+	// the panel because of a click outside of it.
+//	if ( e )
+//	{
+//		e.stopPropagation() ;
+//		FCKPanelEventHandlers.OnDocumentClick( e ) ;
+//	}
+	
+	var oSpecialCombo = this.SpecialCombo ;
+
+	if ( oSpecialCombo.Enabled )
+	{
+		var oPanel			= oSpecialCombo._Panel ;
+		var oPanelBox		= oSpecialCombo._PanelBox ;
+		var oItemsHolder	= oSpecialCombo._ItemsHolderEl ;
+		var iMaxHeight		= oSpecialCombo.PanelMaxHeight ;
+		
+		if ( oSpecialCombo.OnBeforeClick )
+			oSpecialCombo.OnBeforeClick( oSpecialCombo ) ;
+
+		// This is a tricky thing. We must call the "Load" function, otherwise
+		// it will not be possible to retrieve "oItemsHolder.offsetHeight" (IE only).
+		if ( FCKBrowserInfo.IsIE )
+			oPanel.Preload( 0, this.offsetHeight, this ) ;
+
+		if ( oItemsHolder.offsetHeight > iMaxHeight )
+//		{
+			oPanelBox.style.height = iMaxHeight + 'px' ;
+
+//			if ( FCKBrowserInfo.IsGecko )
+//				oPanelBox.style.overflow = '-moz-scrollbars-vertical' ;
+//		}
+		else
+			oPanelBox.style.height = '' ;
+			
+//		oPanel.PanelDiv.style.width = oSpecialCombo.PanelWidth + 'px' ;
+
+		oPanel.Show( 0, this.offsetHeight, this ) ;
+	}
+
+//	return false ;
+}
+
+/* 
+Sample Combo Field HTML output:
+
+<div class="SC_Field" style="width: 80px;">
+	<table width="100%" cellpadding="0" cellspacing="0" style="table-layout: fixed;">
+		<tbody>
+			<tr>
+				<td class="SC_FieldLabel"><label>&nbsp;</label></td>
+				<td class="SC_FieldButton">&nbsp;</td>
+			</tr>
+		</tbody>
+	</table>
+</div>
+*/

stud/FCKeditor/editor/_source/classes/fckstyledef.js

@@ -0,0 +1,55 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckstyledef.js
+ * 	FCKStyleDef Class: represents a single style definition.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKStyleDef = function( name, element )
+{
+	this.Name = name ;
+	this.Element = element.toUpperCase() ;
+	this.IsObjectElement = FCKRegexLib.ObjectElements.test( this.Element ) ;
+	this.Attributes = new Object() ;
+}
+
+FCKStyleDef.prototype.AddAttribute = function( name, value )
+{
+	this.Attributes[ name ] = value ;
+}
+
+FCKStyleDef.prototype.GetOpenerTag = function()
+{
+	var s = '<' + this.Element ;
+	
+	for ( var a in this.Attributes )
+		s += ' ' + a + '="' + this.Attributes[a] + '"' ;
+	
+	return s + '>' ;
+}
+
+FCKStyleDef.prototype.GetCloserTag = function()
+{
+	return '</' + this.Element + '>' ;
+}
+
+
+FCKStyleDef.prototype.RemoveFromSelection = function()
+{
+	if ( FCKSelection.GetType() == 'Control' )
+		this._RemoveMe( FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ) ;
+	else
+		this._RemoveMe( FCK.ToolbarSet.CurrentInstance.Selection.GetParentElement() ) ;
+}

stud/FCKeditor/editor/_source/classes/fckstyledef_gecko.js

@@ -0,0 +1,116 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckstyledef_gecko.js
+ * 	FCKStyleDef Class: represents a single stylke definition. (Gecko specific)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKStyleDef.prototype.ApplyToSelection = function()
+{
+	if ( FCKSelection.GetType() == 'Text' && !this.IsObjectElement )
+	{
+		var oSelection = FCK.ToolbarSet.CurrentInstance.EditorWindow.getSelection() ;
+		
+		// Create the main element.
+		var e = FCK.ToolbarSet.CurrentInstance.EditorDocument.createElement( this.Element ) ;
+		
+		for ( var i = 0 ; i < oSelection.rangeCount ; i++ )
+		{
+			e.appendChild( oSelection.getRangeAt(i).extractContents() ) ;
+		}
+		
+		// Set the attributes.
+		this._AddAttributes( e ) ;
+		
+		// Remove the duplicated elements.
+		this._RemoveDuplicates( e ) ;
+
+		var oRange = oSelection.getRangeAt(0) ;		
+		oRange.insertNode( e ) ;
+	}
+	else
+	{
+		var oControl = FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ;
+		if ( oControl.tagName == this.Element )
+			this._AddAttributes( oControl ) ;
+	}
+}
+
+FCKStyleDef.prototype._AddAttributes = function( targetElement )
+{
+	for ( var a in this.Attributes )
+	{
+		switch ( a.toLowerCase() )
+		{
+			case 'src' :
+				targetElement.setAttribute( '_fcksavedurl', this.Attributes[a], 0 ) ;
+			
+			default :
+				targetElement.setAttribute( a, this.Attributes[a], 0 ) ;
+		}
+	}
+}
+
+FCKStyleDef.prototype._RemoveDuplicates = function( parent )
+{
+	for ( var i = 0 ; i < parent.childNodes.length ; i++ )
+	{
+		var oChild = parent.childNodes[i] ;
+		
+		if ( oChild.nodeType != 1 )
+			continue ;
+		
+		this._RemoveDuplicates( oChild ) ;
+		
+		if ( this.IsEqual( oChild ) )
+			FCKTools.RemoveOuterTags( oChild ) ;
+	}
+}
+
+FCKStyleDef.prototype.IsEqual = function( e )
+{
+	if ( e.tagName != this.Element )
+		return false ;
+	
+	for ( var a in this.Attributes )
+	{
+		if ( e.getAttribute( a ) != this.Attributes[a] )
+			return false ;
+	}
+	
+	return true ;
+}
+
+FCKStyleDef.prototype._RemoveMe = function( elementToCheck )
+{
+	if ( ! elementToCheck )
+		return ;
+
+	var oParent = elementToCheck.parentNode ;
+
+	if ( elementToCheck.nodeType == 1 && this.IsEqual( elementToCheck ) )
+	{
+		if ( this.IsObjectElement )
+		{
+			for ( var a in this.Attributes )
+				elementToCheck.removeAttribute( a, 0 ) ;
+			return ;
+		}
+		else
+			FCKTools.RemoveOuterTags( elementToCheck ) ;
+	}
+	
+	this._RemoveMe( oParent ) ;
+}

stud/FCKeditor/editor/_source/classes/fckstyledef_ie.js

@@ -0,0 +1,139 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckstyledef_ie.js
+ * 	FCKStyleDef Class: represents a single stylke definition. (IE specific)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKStyleDef.prototype.ApplyToSelection = function()
+{
+	var oSelection = FCK.ToolbarSet.CurrentInstance.EditorDocument.selection ;
+	
+	if ( oSelection.type == 'Text' )
+	{
+		var oRange = oSelection.createRange() ;
+		
+		// Create the main element.
+		var e = document.createElement( this.Element ) ;
+		e.innerHTML = oRange.htmlText ;
+		
+		// Set the attributes.
+		this._AddAttributes( e ) ;
+		
+		// Remove the duplicated elements.
+		this._RemoveDuplicates( e ) ;
+		
+		// Replace the selection with the resulting HTML.
+		oRange.pasteHTML( e.outerHTML ) ;
+	}
+	else if ( oSelection.type == 'Control' )
+	{
+		var oControl = FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ;
+		if ( oControl.tagName == this.Element )
+			this._AddAttributes( oControl ) ;
+	}
+}
+
+FCKStyleDef.prototype._AddAttributes = function( targetElement )
+{
+	for ( var a in this.Attributes )
+	{
+		switch ( a.toLowerCase() )
+		{
+			case 'style' :
+				targetElement.style.cssText = this.Attributes[a] ;
+				break ;
+
+			case 'class' :
+				targetElement.setAttribute( 'className', this.Attributes[a], 0 ) ;
+				break ;
+
+			case 'src' :
+				targetElement.setAttribute( '_fcksavedurl', this.Attributes[a], 0 ) ;
+
+			default :
+				targetElement.setAttribute( a, this.Attributes[a], 0 ) ;
+		}
+	}
+}
+
+FCKStyleDef.prototype._RemoveDuplicates = function( parent )
+{
+	for ( var i = 0 ; i < parent.children.length ; i++ )
+	{
+		var oChild = parent.children[i] ;
+		this._RemoveDuplicates( oChild ) ;
+		
+		if ( this.IsEqual( oChild ) )
+			FCKTools.RemoveOuterTags( oChild ) ;
+	}
+}
+
+FCKStyleDef.prototype.IsEqual = function( e )
+{
+	if ( e.tagName != this.Element )
+		return false ;
+	
+	for ( var a in this.Attributes )
+	{
+		switch ( a.toLowerCase() )
+		{
+			case 'style' :
+				if ( e.style.cssText.toLowerCase() != this.Attributes[a].toLowerCase() )
+					return false ;
+				break ;
+			case 'class' :
+				if ( e.getAttribute( 'className', 0 ) != this.Attributes[a] )
+					return false ;
+				break ;
+			default :
+				if ( e.getAttribute( a, 0 ) != this.Attributes[a] )
+					return false ;
+		}
+	}
+	
+	return true ;
+}
+
+FCKStyleDef.prototype._RemoveMe = function( elementToCheck )
+{
+	if ( ! elementToCheck )
+		return ;
+
+	var oParent = elementToCheck.parentElement ;
+
+	if ( this.IsEqual( elementToCheck ) )
+	{
+		if ( this.IsObjectElement )
+		{
+			for ( var a in this.Attributes )
+			{
+				switch ( a.toLowerCase() )
+				{
+					case 'class' :
+						elementToCheck.removeAttribute( 'className', 0 ) ;
+						break ;
+					default :
+						elementToCheck.removeAttribute( a, 0 ) ;
+				}
+			}
+			return ;
+		}
+		else
+			FCKTools.RemoveOuterTags( elementToCheck ) ;
+	}
+	
+	this._RemoveMe( oParent ) ;
+}

stud/FCKeditor/editor/_source/classes/fckstylesloader.js

@@ -0,0 +1,84 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckstylesloader.js
+ * 	FCKStylesLoader Class: this class define objects that are responsible
+ * 	for loading the styles defined in the XML file.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKStylesLoader = function()
+{
+	this.Styles = new Object() ;
+	this.StyleGroups = new Object() ;
+	this.Loaded = false ;
+	this.HasObjectElements = false ;
+}
+
+FCKStylesLoader.prototype.Load = function( stylesXmlUrl )
+{
+	// Load the XML file into a FCKXml object.
+	var oXml = new FCKXml() ;
+	oXml.LoadUrl( stylesXmlUrl ) ;
+	
+	// Get the "Style" nodes defined in the XML file.
+	var aStyleNodes = oXml.SelectNodes( 'Styles/Style' ) ;
+	
+	// Add each style to our "Styles" collection.
+	for ( var i = 0 ; i < aStyleNodes.length ; i++ )
+	{
+		var sElement = aStyleNodes[i].attributes.getNamedItem('element').value.toUpperCase() ;
+	
+		// Create the style definition object.
+		var oStyleDef = new FCKStyleDef( aStyleNodes[i].attributes.getNamedItem('name').value, sElement ) ;
+		
+		if ( oStyleDef.IsObjectElement )
+			this.HasObjectElements = true ;
+		
+		// Get the attributes defined for the style (if any).
+		var aAttNodes = oXml.SelectNodes( 'Attribute', aStyleNodes[i] ) ;
+		
+		// Add the attributes to the style definition object.
+		for ( var j = 0 ; j < aAttNodes.length ; j++ )
+		{
+			var sAttName	= aAttNodes[j].attributes.getNamedItem('name').value ;
+			var sAttValue	= aAttNodes[j].attributes.getNamedItem('value').value ;
+
+			// IE changes the "style" attribute value when applied to an element
+			// so we must get the final resulting value (for comparision issues).
+			if ( sAttName.toLowerCase() == 'style' )
+			{
+				var oTempE = document.createElement( 'SPAN' ) ;
+				oTempE.style.cssText = sAttValue ;
+				sAttValue = oTempE.style.cssText ;
+			}
+			
+			oStyleDef.AddAttribute( sAttName, sAttValue ) ;
+		}
+
+		// Add the style to the "Styles" collection using it's name as the key.
+		this.Styles[ oStyleDef.Name ] = oStyleDef ;
+		
+		// Add the style to the "StyleGroups" collection.
+		var aGroup = this.StyleGroups[sElement] ;
+		if ( aGroup == null )
+		{
+			this.StyleGroups[sElement] = new Array() ;
+			aGroup = this.StyleGroups[sElement] ;
+		}
+		aGroup[aGroup.length] = oStyleDef ;
+	}
+	
+	this.Loaded = true ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbar.js

@@ -0,0 +1,116 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbar.js
+ * 	FCKToolbar Class: represents a toolbar in the toolbarset. It is a group of
+ * 	toolbar items.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbar = function()
+{
+	this.Items = new Array() ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKToolbar_Cleanup ) ;
+}
+
+FCKToolbar.prototype.AddItem = function( item )
+{
+	return this.Items[ this.Items.length ] = item ;
+}
+
+FCKToolbar.prototype.AddButton = function( name, label, tooltip, iconPathOrStripInfoArrayOrIndex, style, state )
+{
+	if ( typeof( iconPathOrStripInfoArrayOrIndex ) == 'number' )
+		 iconPathOrStripInfoArrayOrIndex = [ this.DefaultIconsStrip, this.DefaultIconSize, iconPathOrStripInfoArrayOrIndex ] ;
+
+	var oButton = new FCKToolbarButtonUI( name, label, tooltip, iconPathOrStripInfoArrayOrIndex, style, state ) ;
+	oButton._FCKToolbar = this ;
+	oButton.OnClick = FCKToolbar_OnItemClick ;
+	
+	return this.AddItem( oButton ) ;
+}
+
+function FCKToolbar_OnItemClick( item )
+{
+	var oToolbar = item._FCKToolbar ;
+	
+	if ( oToolbar.OnItemClick )
+		oToolbar.OnItemClick( oToolbar, item ) ;
+}
+
+FCKToolbar.prototype.AddSeparator = function()
+{
+	this.AddItem( new FCKToolbarSeparator() ) ;
+}
+
+FCKToolbar.prototype.Create = function( parentElement )
+{
+	if ( this.MainElement )
+	{
+//		this._Cleanup() ;
+		if ( this.MainElement.parentNode )
+			this.MainElement.parentNode.removeChild( this.MainElement ) ;
+		this.MainElement = null ;
+	}
+
+	var oDoc = FCKTools.GetElementDocument( parentElement ) ;
+
+	var e = this.MainElement = oDoc.createElement( 'table' ) ;
+	e.className = 'TB_Toolbar' ;
+	e.style.styleFloat = e.style.cssFloat = ( FCKLang.Dir == 'ltr' ? 'left' : 'right' ) ;
+	e.dir = FCKLang.Dir ;
+	e.cellPadding = 0 ;
+	e.cellSpacing = 0 ;
+	
+	this.RowElement = e.insertRow(-1) ;
+	
+	// Insert the start cell.
+	var eCell ;
+	
+	if ( !this.HideStart )
+	{
+		eCell = this.RowElement.insertCell(-1) ;
+		eCell.appendChild( oDoc.createElement( 'div' ) ).className = 'TB_Start' ;
+	}
+	
+	for ( var i = 0 ; i < this.Items.length ; i++ )
+	{
+		this.Items[i].Create( this.RowElement.insertCell(-1) ) ;
+	}
+	
+	// Insert the ending cell.
+	if ( !this.HideEnd )
+	{
+		eCell = this.RowElement.insertCell(-1) ;
+		eCell.appendChild( oDoc.createElement( 'div' ) ).className = 'TB_End' ;
+	}
+
+	parentElement.appendChild( e ) ;
+}
+
+function FCKToolbar_Cleanup()
+{
+	this.MainElement = null ;
+	this.RowElement = null ;
+}
+
+var FCKToolbarSeparator = function()
+{}
+
+FCKToolbarSeparator.prototype.Create = function( parentElement )
+{
+	FCKTools.AppendElement( parentElement, 'div' ).className = 'TB_Separator' ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarbreak_gecko.js

@@ -0,0 +1,32 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarbreak_gecko.js
+ * 	FCKToolbarBreak Class: breaks the toolbars.
+ * 	It makes it possible to force the toolbar to break to a new line.
+ * 	This is the Gecko specific implementation.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarBreak = function()
+{}
+
+FCKToolbarBreak.prototype.Create = function( targetElement )
+{
+	var oBreakDiv = targetElement.ownerDocument.createElement( 'div' ) ;
+	
+	oBreakDiv.style.clear = oBreakDiv.style.cssFloat = FCKLang.Dir == 'rtl' ? 'right' : 'left' ;
+	
+	targetElement.appendChild( oBreakDiv ) ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarbreak_ie.js

@@ -0,0 +1,34 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarbreak_ie.js
+ * 	FCKToolbarBreak Class: breaks the toolbars.
+ * 	It makes it possible to force the toolbar to brak to a new line.
+ * 	This is the IE specific implementation.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarBreak = function()
+{}
+
+FCKToolbarBreak.prototype.Create = function( targetElement )
+{
+	var oBreakDiv = FCKTools.GetElementDocument( targetElement ).createElement( 'div' ) ;
+	
+	oBreakDiv.className = 'TB_Break' ;
+	
+	oBreakDiv.style.clear = FCKLang.Dir == 'rtl' ? 'left' : 'right' ;
+	
+	targetElement.appendChild( oBreakDiv ) ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarbutton.js

@@ -0,0 +1,70 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarbutton.js
+ * 	FCKToolbarButton Class: represents a button in the toolbar.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarButton = function( commandName, label, tooltip, style, sourceView, contextSensitive, icon )
+{
+	this.CommandName		= commandName ;
+	this.Label				= label ;
+	this.Tooltip			= tooltip ;
+	this.Style				= style ;
+	this.SourceView			= sourceView ? true : false ;
+	this.ContextSensitive	= contextSensitive ? true : false ;	
+
+	if ( icon == null )
+		this.IconPath = FCKConfig.SkinPath + 'toolbar/' + commandName.toLowerCase() + '.gif' ;
+	else if ( typeof( icon ) == 'number' )
+		this.IconPath = [ FCKConfig.SkinPath + 'fck_strip.gif', 16, icon ] ;
+}
+
+FCKToolbarButton.prototype.Create = function( targetElement )
+{
+	this._UIButton = new FCKToolbarButtonUI( this.CommandName, this.Label, this.Tooltip, this.IconPath, this.Style ) ;
+	this._UIButton.OnClick = this.Click ;
+	this._UIButton._ToolbarButton = this ;	
+	this._UIButton.Create( targetElement ) ;
+}
+
+FCKToolbarButton.prototype.RefreshState = function()
+{
+	// Gets the actual state.
+	var eState = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetState() ;
+	
+	// If there are no state changes than do nothing and return.
+	if ( eState == this._UIButton.State ) return ;
+	
+	// Sets the actual state.
+	this._UIButton.ChangeState( eState ) ;
+}
+
+FCKToolbarButton.prototype.Click = function()
+{
+	var oToolbarButton = this._ToolbarButton || this ;
+	FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( oToolbarButton.CommandName ).Execute() ;
+}
+
+FCKToolbarButton.prototype.Enable = function()
+{
+	this.RefreshState() ;
+}
+
+FCKToolbarButton.prototype.Disable = function()
+{
+	// Sets the actual state.
+	this._UIButton.ChangeState( FCK_TRISTATE_DISABLED ) ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarbuttonui.js

@@ -0,0 +1,218 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarbuttonui.js
+ * 	FCKToolbarButtonUI Class: interface representation of a toolbar button.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarButtonUI = function( name, label, tooltip, iconPathOrStripInfoArray, style, state )
+{
+	this.Name		= name ;
+	this.Label		= label || name ;
+	this.Tooltip	= tooltip || this.Label ;
+	this.Style		= style || FCK_TOOLBARITEM_ONLYICON ;
+	this.State		= state || FCK_TRISTATE_OFF ;
+	
+	this.Icon = new FCKIcon( iconPathOrStripInfoArray ) ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKToolbarButtonUI_Cleanup ) ;
+}
+
+
+FCKToolbarButtonUI.prototype._CreatePaddingElement = function( document )
+{
+	var oImg = document.createElement( 'IMG' ) ;
+	oImg.className = 'TB_Button_Padding' ;
+	oImg.src = FCK_SPACER_PATH ;
+	return oImg ;
+}
+
+FCKToolbarButtonUI.prototype.Create = function( parentElement )
+{
+	var oMainElement = this.MainElement ;
+	
+	if ( oMainElement )
+	{
+		FCKToolbarButtonUI_Cleanup.call(this) ;
+		
+		if ( oMainElement.parentNode )
+			oMainElement.parentNode.removeChild( oMainElement ) ;
+		oMainElement = this.MainElement = null ;
+	}
+
+	var oDoc = FCKTools.GetElementDocument( parentElement ) ;
+	
+	// Create the Main Element.
+	oMainElement = this.MainElement = oDoc.createElement( 'DIV' ) ;
+	oMainElement._FCKButton = this ;		// IE Memory Leak (Circular reference).
+	oMainElement.title		= this.Tooltip ;
+
+	// The following will prevent the button from catching the focus.
+	if ( FCKBrowserInfo.IsGecko )
+		 oMainElement.onmousedown	= FCKTools.CancelEvent ;
+
+	this.ChangeState( this.State, true ) ;
+
+	if ( this.Style == FCK_TOOLBARITEM_ONLYICON && !this.ShowArrow )
+	{
+		// <td><div class="TB_Button_On" title="Smiley">{Image}</div></td>
+		
+		oMainElement.appendChild( this.Icon.CreateIconElement( oDoc ) ) ;
+	}
+	else
+	{
+		// <td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td>{Image}</td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td>
+		// <td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td><img class="TB_Button_Padding"></td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td>
+		
+		var oTable = oMainElement.appendChild( oDoc.createElement( 'TABLE' ) ) ;
+		oTable.cellPadding = 0 ;
+		oTable.cellSpacing = 0 ;
+
+		var oRow = oTable.insertRow(-1) ;
+		
+		// The Image cell (icon or padding).
+		var oCell = oRow.insertCell(-1) ;
+		
+		if ( this.Style == FCK_TOOLBARITEM_ONLYICON || this.Style == FCK_TOOLBARITEM_ICONTEXT )
+			oCell.appendChild( this.Icon.CreateIconElement( oDoc ) ) ;
+		else
+			oCell.appendChild( this._CreatePaddingElement( oDoc ) ) ;
+		
+		if ( this.Style == FCK_TOOLBARITEM_ONLYTEXT || this.Style == FCK_TOOLBARITEM_ICONTEXT )
+		{
+			// The Text cell.
+			oCell = oRow.insertCell(-1) ;
+			oCell.className = 'TB_Button_Text' ;
+			oCell.noWrap = true ;
+			oCell.appendChild( oDoc.createTextNode( this.Label ) ) ;
+		}
+		
+		if ( this.ShowArrow )
+		{
+			if ( this.Style != FCK_TOOLBARITEM_ONLYICON )
+			{	
+				// A padding cell.
+				oRow.insertCell(-1).appendChild( this._CreatePaddingElement( oDoc ) ) ;
+			}
+			
+			oCell = oRow.insertCell(-1) ;
+			var eImg = oCell.appendChild( oDoc.createElement( 'IMG' ) ) ;
+			eImg.src	= FCKConfig.SkinPath + 'images/toolbar.buttonarrow.gif' ;
+			eImg.width	= 5 ;
+			eImg.height	= 3 ;
+		}
+
+		// The last padding cell.
+		oCell = oRow.insertCell(-1) ;
+		oCell.appendChild( this._CreatePaddingElement( oDoc ) ) ;
+	}
+	
+	parentElement.appendChild( oMainElement ) ;
+}
+
+FCKToolbarButtonUI.prototype.ChangeState = function( newState, force )
+{
+	if ( !force && this.State == newState )
+		return ;
+
+	var e = this.MainElement ;
+
+	switch ( parseInt( newState ) )
+	{
+		case FCK_TRISTATE_OFF :
+			e.className		= 'TB_Button_Off' ;
+			e.onmouseover	= FCKToolbarButton_OnMouseOverOff ;
+			e.onmouseout	= FCKToolbarButton_OnMouseOutOff ;
+			e.onclick		= FCKToolbarButton_OnClick ;
+			
+			break ;
+			
+		case FCK_TRISTATE_ON :
+			e.className		= 'TB_Button_On' ;
+			e.onmouseover	= FCKToolbarButton_OnMouseOverOn ;
+			e.onmouseout	= FCKToolbarButton_OnMouseOutOn ;
+			e.onclick		= FCKToolbarButton_OnClick ;
+			
+			break ;
+
+		case FCK_TRISTATE_DISABLED :
+			e.className		= 'TB_Button_Disabled' ;
+			e.onmouseover	= null ;
+			e.onmouseout	= null ;
+			e.onclick		= null ;
+			bEnableEvents = false ;
+			break ;
+	}
+
+	this.State = newState ;
+}
+
+function FCKToolbarButtonUI_Cleanup()
+{
+	if ( this.MainElement )
+	{
+		this.MainElement._FCKButton = null ;
+		this.MainElement = null ;
+	}
+}	
+
+// Event Handlers.
+
+function FCKToolbarButton_OnMouseOverOn()
+{
+	this.className = 'TB_Button_On_Over' ;
+}
+
+function FCKToolbarButton_OnMouseOutOn()
+{
+	this.className = 'TB_Button_On' ;
+}
+
+function FCKToolbarButton_OnMouseOverOff()
+{
+	this.className = 'TB_Button_Off_Over' ;
+}
+
+function FCKToolbarButton_OnMouseOutOff()
+{
+	this.className = 'TB_Button_Off' ;
+}
+
+function FCKToolbarButton_OnClick( e )
+{
+	if ( this._FCKButton.OnClick )
+		this._FCKButton.OnClick( this._FCKButton ) ;
+}
+
+/* 
+	Sample outputs:
+
+	This is the base structure. The variation is the image that is marked as {Image}:
+		<td><div class="TB_Button_On" title="Smiley">{Image}</div></td>
+		<td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td>{Image}</td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td>
+		<td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td><img class="TB_Button_Padding"></td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td>
+
+	These are samples of possible {Image} values:
+		
+		Strip - IE version:
+			<div class="TB_Button_Image"><img src="strip.gif" style="top:-16px"></div>
+		
+		Strip : Firefox, Safari and Opera version
+			<img class="TB_Button_Image" style="background-position: 0px -16px;background-image: url(strip.gif);">
+		
+		No-Strip : Browser independent:
+			<img class="TB_Button_Image" src="smiley.gif">
+*/

stud/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js

@@ -0,0 +1,102 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarfontformatcombo.js
+ * 	FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarFontFormatCombo = function( tooltip, style )
+{
+	this.CommandName = 'FontFormat' ;
+	this.Label		= this.GetLabel() ;
+	this.Tooltip	= tooltip ? tooltip : this.Label ;
+	this.Style		= style ? style : FCK_TOOLBARITEM_ICONTEXT ;
+	
+	this.NormalLabel = 'Normal' ;
+	
+	this.PanelWidth = 190 ;
+}
+
+// Inherit from FCKToolbarSpecialCombo.
+FCKToolbarFontFormatCombo.prototype = new FCKToolbarSpecialCombo ;
+
+
+FCKToolbarFontFormatCombo.prototype.GetLabel = function()
+{
+	return FCKLang.FontFormat ;
+}
+
+FCKToolbarFontFormatCombo.prototype.CreateItems = function( targetSpecialCombo )
+{
+	// Add the Editor Area CSS to the panel to create a realistic preview.
+	FCKTools.AppendStyleSheet( targetSpecialCombo._Panel.Document, FCKConfig.ToolbarComboPreviewCSS ) ;
+
+	// Get the format names from the language file.
+	var aNames = FCKLang['FontFormats'].split(';') ;
+	var oNames = {
+		p		: aNames[0],
+		pre		: aNames[1],
+		address	: aNames[2],
+		h1		: aNames[3],
+		h2		: aNames[4],
+		h3		: aNames[5],
+		h4		: aNames[6],
+		h5		: aNames[7],
+		h6		: aNames[8],
+		div		: aNames[9]
+	} ;
+
+	// Get the available formats from the configuration file.
+	var aTags = FCKConfig.FontFormats.split(';') ;
+	
+	for ( var i = 0 ; i < aTags.length ; i++ )
+	{
+		// Support for DIV in Firefox has been reintroduced on version 2.2.
+//		if ( aTags[i] == 'div' && FCKBrowserInfo.IsGecko )
+//			continue ;
+		
+		var sTag	= aTags[i] ;
+		var sLabel	= oNames[sTag] ;
+		
+		if ( sTag == 'p' )
+			this.NormalLabel = sLabel ;
+		
+		this._Combo.AddItem( sTag, '<div class="BaseFont"><' + sTag + '>' + sLabel + '</' + sTag + '></div>', sLabel ) ;
+	}
+}
+
+if ( FCKBrowserInfo.IsIE )
+{
+	FCKToolbarFontFormatCombo.prototype.RefreshActiveItems = function( combo, value )
+	{
+//		FCKDebug.Output( 'FCKToolbarFontFormatCombo Value: ' + value ) ;
+
+		// IE returns normal for DIV and P, so to avoid confusion, we will not show it if normal.
+		if ( value == this.NormalLabel )
+		{
+			if ( combo.Label != '&nbsp;' )
+				combo.DeselectAll(true) ;
+		}
+		else
+		{
+			if ( this._LastValue == value )
+				return ;
+
+			combo.SelectItemByLabel( value, true ) ;
+		}
+
+		this._LastValue = value ;
+	}
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarfontscombo.js

@@ -0,0 +1,43 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarfontscombo.js
+ * 	FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarFontsCombo = function( tooltip, style )
+{
+	this.CommandName	= 'FontName' ;
+	this.Label		= this.GetLabel() ;
+	this.Tooltip	= tooltip ? tooltip : this.Label ;
+	this.Style		= style ? style : FCK_TOOLBARITEM_ICONTEXT ;
+}
+
+// Inherit from FCKToolbarSpecialCombo.
+FCKToolbarFontsCombo.prototype = new FCKToolbarSpecialCombo ;
+
+
+FCKToolbarFontsCombo.prototype.GetLabel = function()
+{
+	return FCKLang.Font ;
+}
+
+FCKToolbarFontsCombo.prototype.CreateItems = function( targetSpecialCombo )
+{
+	var aFonts = FCKConfig.FontNames.split(';') ;
+	
+	for ( var i = 0 ; i < aFonts.length ; i++ )
+		this._Combo.AddItem( aFonts[i], '<font face="' + aFonts[i] + '" style="font-size: 12px">' + aFonts[i] + '</font>' ) ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarfontsizecombo.js

@@ -0,0 +1,48 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarfontsizecombo.js
+ * 	FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarFontSizeCombo = function( tooltip, style )
+{
+	this.CommandName	= 'FontSize' ;
+	this.Label		= this.GetLabel() ;
+	this.Tooltip	= tooltip ? tooltip : this.Label ;
+	this.Style		= style ? style : FCK_TOOLBARITEM_ICONTEXT ;
+}
+
+// Inherit from FCKToolbarSpecialCombo.
+FCKToolbarFontSizeCombo.prototype = new FCKToolbarSpecialCombo ;
+
+
+FCKToolbarFontSizeCombo.prototype.GetLabel = function()
+{
+	return FCKLang.FontSize ;
+}
+
+FCKToolbarFontSizeCombo.prototype.CreateItems = function( targetSpecialCombo )
+{
+	targetSpecialCombo.FieldWidth = 70 ;
+	
+	var aSizes = FCKConfig.FontSizes.split(';') ;
+	
+	for ( var i = 0 ; i < aSizes.length ; i++ )
+	{
+		var aSizeParts = aSizes[i].split('/') ;
+		this._Combo.AddItem( aSizeParts[0], '<font size="' + aSizeParts[0] + '">' + aSizeParts[1] + '</font>', aSizeParts[1] ) ;
+	}
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarpanelbutton.js

@@ -0,0 +1,87 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarpanelbutton.js
+ * 	FCKToolbarPanelButton Class: represents a special button in the toolbar
+ * 	that shows a panel when pressed.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarPanelButton = function( commandName, label, tooltip, style, icon )
+{
+	this.CommandName = commandName ;
+
+	var oIcon ;
+	
+	if ( icon == null )
+		oIcon = FCKConfig.SkinPath + 'toolbar/' + commandName.toLowerCase() + '.gif' ;
+	else if ( typeof( icon ) == 'number' )
+		oIcon = [ FCKConfig.SkinPath + 'fck_strip.gif', 16, icon ] ;
+	
+	var oUIButton = this._UIButton = new FCKToolbarButtonUI( commandName, label, tooltip, oIcon, style ) ;
+	oUIButton._FCKToolbarPanelButton = this ;
+	oUIButton.ShowArrow = true ;
+	oUIButton.OnClick = FCKToolbarPanelButton_OnButtonClick ;
+}
+
+FCKToolbarPanelButton.prototype.TypeName = 'FCKToolbarPanelButton' ;
+
+FCKToolbarPanelButton.prototype.Create = function( parentElement )
+{
+	parentElement.className += 'Menu' ;
+
+	this._UIButton.Create( parentElement ) ;
+	
+	var oPanel = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName )._Panel ;
+	oPanel._FCKToolbarPanelButton = this ;
+	
+	var eLineDiv = oPanel.Document.body.appendChild( oPanel.Document.createElement( 'div' ) ) ;
+	eLineDiv.style.position = 'absolute' ;
+	eLineDiv.style.top = '0px' ;
+	
+	var eLine = this.LineImg = eLineDiv.appendChild( oPanel.Document.createElement( 'IMG' ) ) ;
+	eLine.className = 'TB_ConnectionLine' ;
+//	eLine.style.backgroundColor = 'Red' ;
+	eLine.src = FCK_SPACER_PATH ;
+
+	oPanel.OnHide = FCKToolbarPanelButton_OnPanelHide ;
+}
+
+/*
+	Events
+*/
+
+function FCKToolbarPanelButton_OnButtonClick( toolbarButton )
+{
+	var oButton = this._FCKToolbarPanelButton ;
+	var e = oButton._UIButton.MainElement ;
+	
+	oButton._UIButton.ChangeState( FCK_TRISTATE_ON ) ;
+	
+	oButton.LineImg.style.width = ( e.offsetWidth - 2 ) + 'px' ;
+
+	FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( oButton.CommandName ).Execute( 0, e.offsetHeight - 1, e ) ; // -1 to be over the border
+}
+
+function FCKToolbarPanelButton_OnPanelHide()
+{
+	var oMenuButton = this._FCKToolbarPanelButton ;
+	oMenuButton._UIButton.ChangeState( FCK_TRISTATE_OFF ) ;
+}
+
+// The Panel Button works like a normal button so the refresh state functions
+// defined for the normal button can be reused here.
+FCKToolbarPanelButton.prototype.RefreshState	= FCKToolbarButton.prototype.RefreshState ;
+FCKToolbarPanelButton.prototype.Enable			= FCKToolbarButton.prototype.Enable ;
+FCKToolbarPanelButton.prototype.Disable			= FCKToolbarButton.prototype.Disable ;

stud/FCKeditor/editor/_source/classes/fcktoolbarspecialcombo.js

@@ -0,0 +1,129 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarspecialcombo.js
+ * 	FCKToolbarSpecialCombo Class: This is a "abstract" base class to be used
+ * 	by the special combo toolbar elements like font name, font size, paragraph format, etc...
+ * 	
+ * 	The following properties and methods must be implemented when inheriting from
+ * 	this class:
+ * 		- Property:	CommandName							[ The command name to be executed ]
+ * 		- Method:	GetLabel()							[ Returns the label ]
+ * 		-			CreateItems( targetSpecialCombo )	[ Add all items in the special combo ]
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarSpecialCombo = function()
+{
+	this.SourceView			= false ;
+	this.ContextSensitive	= true ;
+}
+
+
+function FCKToolbarSpecialCombo_OnSelect( itemId, item )
+{
+	FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).Execute( itemId, item ) ;
+}
+
+FCKToolbarSpecialCombo.prototype.Create = function( targetElement )
+{
+	this._Combo = new FCKSpecialCombo( this.GetLabel(), this.FieldWidth, this.PanelWidth, this.PanelMaxHeight, FCKBrowserInfo.IsIE ? window : FCKTools.GetElementWindow( targetElement ).parent ) ;
+	
+	/*
+	this._Combo.FieldWidth		= this.FieldWidth		!= null ? this.FieldWidth		: 100 ;
+	this._Combo.PanelWidth		= this.PanelWidth		!= null ? this.PanelWidth		: 150 ;
+	this._Combo.PanelMaxHeight	= this.PanelMaxHeight	!= null ? this.PanelMaxHeight	: 150 ;
+	*/
+	
+	//this._Combo.Command.Name = this.Command.Name;
+//	this._Combo.Label	= this.Label ;
+	this._Combo.Tooltip	= this.Tooltip ;
+	this._Combo.Style	= this.Style ;
+	
+	this.CreateItems( this._Combo ) ;
+
+	this._Combo.Create( targetElement ) ;
+
+	this._Combo.CommandName = this.CommandName ;
+	
+	this._Combo.OnSelect = FCKToolbarSpecialCombo_OnSelect ;
+}
+
+function FCKToolbarSpecialCombo_RefreshActiveItems( combo, value )
+{
+	combo.DeselectAll() ;
+	combo.SelectItem( value ) ;
+	combo.SetLabelById( value ) ;
+}
+
+FCKToolbarSpecialCombo.prototype.RefreshState = function()
+{
+	// Gets the actual state.
+	var eState ;
+	
+//	if ( FCK.EditMode == FCK_EDITMODE_SOURCE && ! this.SourceView )
+//		eState = FCK_TRISTATE_DISABLED ;
+//	else
+//	{
+		var sValue = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetState() ;
+
+//		FCKDebug.Output( 'RefreshState of Special Combo "' + this.TypeOf + '" - State: ' + sValue ) ;
+
+		if ( sValue != FCK_TRISTATE_DISABLED )
+		{
+			eState = FCK_TRISTATE_ON ;
+			
+			if ( this.RefreshActiveItems )
+				this.RefreshActiveItems( this._Combo, sValue ) ;
+			else
+			{
+				if ( this._LastValue != sValue )
+				{
+					this._LastValue = sValue ;
+					FCKToolbarSpecialCombo_RefreshActiveItems( this._Combo, sValue ) ;
+				}
+			}
+		}
+		else
+			eState = FCK_TRISTATE_DISABLED ;
+//	}
+	
+	// If there are no state changes then do nothing and return.
+	if ( eState == this.State ) return ;
+	
+	if ( eState == FCK_TRISTATE_DISABLED )
+	{
+		this._Combo.DeselectAll() ;
+		this._Combo.SetLabel( '' ) ;
+	}
+
+	// Sets the actual state.
+	this.State = eState ;
+
+	// Updates the graphical state.
+	this._Combo.SetEnabled( eState != FCK_TRISTATE_DISABLED ) ;
+}
+
+FCKToolbarSpecialCombo.prototype.Enable = function()
+{
+	this.RefreshState() ;
+}
+
+FCKToolbarSpecialCombo.prototype.Disable = function()
+{
+	this.State = FCK_TRISTATE_DISABLED ;
+	this._Combo.DeselectAll() ;
+	this._Combo.SetLabel( '' ) ;
+	this._Combo.SetEnabled( false ) ;
+}

stud/FCKeditor/editor/_source/classes/fcktoolbarstylecombo.js

@@ -0,0 +1,99 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarstylecombo.js
+ * 	FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarStyleCombo = function( tooltip, style )
+{
+	this.CommandName = 'Style' ;
+	this.Label		= this.GetLabel() ;
+	this.Tooltip	= tooltip ? tooltip : this.Label ;
+	this.Style		= style ? style : FCK_TOOLBARITEM_ICONTEXT ;
+}
+
+// Inherit from FCKToolbarSpecialCombo.
+FCKToolbarStyleCombo.prototype = new FCKToolbarSpecialCombo ;
+
+
+FCKToolbarStyleCombo.prototype.GetLabel = function()
+{
+	return FCKLang.Style ;
+}
+
+FCKToolbarStyleCombo.prototype.CreateItems = function( targetSpecialCombo )
+{
+	var oTargetDoc = targetSpecialCombo._Panel.Document ;
+	
+	// Add the Editor Area CSS to the panel so the style classes are previewed correctly.
+	FCKTools.AppendStyleSheet( oTargetDoc, FCKConfig.ToolbarComboPreviewCSS ) ;
+	oTargetDoc.body.className += ' ForceBaseFont' ;
+
+	// For some reason Gecko is blocking inside the "RefreshVisibleItems" function.
+	if ( ! FCKBrowserInfo.IsGecko )
+		targetSpecialCombo.OnBeforeClick = this.RefreshVisibleItems ;
+
+	// Add the styles to the special combo.
+	var aCommandStyles = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).Styles ;
+	for ( var s in aCommandStyles )
+	{
+		var oStyle = aCommandStyles[s] ;
+		var oItem ;
+		
+		if ( oStyle.IsObjectElement )
+			oItem = targetSpecialCombo.AddItem( s, s ) ;
+		else
+			oItem = targetSpecialCombo.AddItem( s, oStyle.GetOpenerTag() + s + oStyle.GetCloserTag() ) ;
+			
+		oItem.Style = oStyle ;
+	}
+}
+
+FCKToolbarStyleCombo.prototype.RefreshActiveItems = function( targetSpecialCombo )
+{
+	// Clear the actual selection.
+	targetSpecialCombo.DeselectAll() ;
+	
+	// Get the active styles.
+	var aStyles = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetActiveStyles() ;
+	
+	if ( aStyles.length > 0 )
+	{
+		// Select the active styles in the combo.
+		for ( var i = 0 ; i < aStyles.length ; i++ )
+			targetSpecialCombo.SelectItem( aStyles[i].Name ) ;
+
+		// Set the combo label to the first style in the collection.
+		targetSpecialCombo.SetLabelById( aStyles[0].Name ) ;
+	}
+	else
+		targetSpecialCombo.SetLabel('') ;
+}
+
+FCKToolbarStyleCombo.prototype.RefreshVisibleItems = function( targetSpecialCombo )
+{
+	if ( FCKSelection.GetType() == 'Control' )
+		var sTagName = FCKSelection.GetSelectedElement().tagName ;
+
+	for ( var i in targetSpecialCombo.Items )
+	{
+		var oItem = targetSpecialCombo.Items[i] ;
+		if ( ( sTagName && oItem.Style.Element == sTagName ) || ( ! sTagName && ! oItem.Style.IsObjectElement ) )
+			oItem.style.display = '' ;
+		else
+			oItem.style.display = 'none' ;	// For some reason Gecko is blocking here.
+	}
+}

stud/FCKeditor/editor/_source/classes/fckxml_gecko.js

@@ -0,0 +1,66 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckxml_gecko.js
+ * 	FCKXml Class: class to load and manipulate XML files.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKXml = function()
+{}
+
+FCKXml.prototype.LoadUrl = function( urlToCall )
+{
+	var oFCKXml = this ;
+
+	var oXmlHttp = FCKTools.CreateXmlObject( 'XmlHttp' ) ;
+	oXmlHttp.open( "GET", urlToCall, false ) ;
+	oXmlHttp.send( null ) ;
+	
+	if ( oXmlHttp.status == 200 || oXmlHttp.status == 304 )
+		this.DOMDocument = oXmlHttp.responseXML ;
+	else if ( oXmlHttp.status == 0 && oXmlHttp.readyState == 4 )
+		this.DOMDocument = oXmlHttp.responseXML ;
+	else
+		alert( 'Error loading "' + urlToCall + '"' ) ;
+}
+
+FCKXml.prototype.SelectNodes = function( xpath, contextNode )
+{
+	var aNodeArray = new Array();
+
+	var xPathResult = this.DOMDocument.evaluate( xpath, contextNode ? contextNode : this.DOMDocument, 
+			this.DOMDocument.createNSResolver(this.DOMDocument.documentElement), XPathResult.ORDERED_NODE_ITERATOR_TYPE, null) ;
+	if ( xPathResult ) 
+	{
+		var oNode = xPathResult.iterateNext() ;
+		while( oNode )
+		{
+			aNodeArray[aNodeArray.length] = oNode ;
+			oNode = xPathResult.iterateNext();
+		}
+	} 
+	return aNodeArray ;
+}
+
+FCKXml.prototype.SelectSingleNode = function( xpath, contextNode ) 
+{
+	var xPathResult = this.DOMDocument.evaluate( xpath, contextNode ? contextNode : this.DOMDocument,
+			this.DOMDocument.createNSResolver(this.DOMDocument.documentElement), 9, null);
+
+	if ( xPathResult && xPathResult.singleNodeValue )
+		return xPathResult.singleNodeValue ;
+	else	
+		return null ;
+}

stud/FCKeditor/editor/_source/classes/fckxml_ie.js

@@ -0,0 +1,78 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckxml_ie.js
+ * 	FCKXml Class: class to load and manipulate XML files.
+ * 	(IE specific implementation)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKXml = function()
+{
+	this.Error = false ;
+}
+
+FCKXml.prototype.LoadUrl = function( urlToCall )
+{
+	this.Error = false ;
+
+	var oXmlHttp = FCKTools.CreateXmlObject( 'XmlHttp' ) ;
+
+	if ( !oXmlHttp )
+	{
+		this.Error = true ;
+		return ;
+	}
+
+	oXmlHttp.open( "GET", urlToCall, false ) ;
+	
+	oXmlHttp.send( null ) ;
+	
+	if ( oXmlHttp.status == 200 || oXmlHttp.status == 304 )
+		this.DOMDocument = oXmlHttp.responseXML ;
+	else if ( oXmlHttp.status == 0 && oXmlHttp.readyState == 4 )
+	{
+		this.DOMDocument = FCKTools.CreateXmlObject( 'DOMDocument' ) ;
+		this.DOMDocument.async = false ;
+		this.DOMDocument.resolveExternals = false ;
+		this.DOMDocument.loadXML( oXmlHttp.responseText ) ;
+	}
+	else
+	{
+		this.Error = true ;
+		alert( 'Error loading "' + urlToCall + '"' ) ;
+	}
+}
+
+FCKXml.prototype.SelectNodes = function( xpath, contextNode )
+{
+	if ( this.Error )
+		return new Array() ;
+
+	if ( contextNode )
+		return contextNode.selectNodes( xpath ) ;
+	else
+		return this.DOMDocument.selectNodes( xpath ) ;
+}
+
+FCKXml.prototype.SelectSingleNode = function( xpath, contextNode ) 
+{
+	if ( this.Error )
+		return ;
+		
+	if ( contextNode )
+		return contextNode.selectSingleNode( xpath ) ;
+	else
+		return this.DOMDocument.selectSingleNode( xpath ) ;
+}

stud/FCKeditor/editor/_source/commandclasses/fck_othercommands.js

@@ -0,0 +1,309 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_othercommands.js
+ * 	Definition of other commands that are not available internaly in the
+ * 	browser (see FCKNamedCommand).
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// ### General Dialog Box Commands.
+var FCKDialogCommand = function( name, title, url, width, height, getStateFunction, getStateParam )
+{
+	this.Name	= name ;
+	this.Title	= title ;
+	this.Url	= url ;
+	this.Width	= width ;
+	this.Height	= height ;
+
+	this.GetStateFunction	= getStateFunction ;
+	this.GetStateParam		= getStateParam ;
+}
+
+FCKDialogCommand.prototype.Execute = function()
+{
+	FCKDialog.OpenDialog( 'FCKDialog_' + this.Name , this.Title, this.Url, this.Width, this.Height ) ;
+}
+
+FCKDialogCommand.prototype.GetState = function()
+{
+	if ( this.GetStateFunction )
+		return this.GetStateFunction( this.GetStateParam ) ;
+	else
+		return FCK_TRISTATE_OFF ;
+}
+
+// Generic Undefined command (usually used when a command is under development).
+var FCKUndefinedCommand = function()
+{
+	this.Name = 'Undefined' ;
+}
+
+FCKUndefinedCommand.prototype.Execute = function()
+{
+	alert( FCKLang.NotImplemented ) ;
+}
+
+FCKUndefinedCommand.prototype.GetState = function()
+{
+	return FCK_TRISTATE_OFF ;
+}
+
+// ### FontName
+var FCKFontNameCommand = function()
+{
+	this.Name = 'FontName' ;
+}
+
+FCKFontNameCommand.prototype.Execute = function( fontName )
+{
+	if (fontName == null || fontName == "")
+	{
+		// TODO: Remove font name attribute.
+	}
+	else
+		FCK.ExecuteNamedCommand( 'FontName', fontName ) ;
+}
+
+FCKFontNameCommand.prototype.GetState = function()
+{
+	return FCK.GetNamedCommandValue( 'FontName' ) ;
+}
+
+// ### FontSize
+var FCKFontSizeCommand = function()
+{
+	this.Name = 'FontSize' ;
+}
+
+FCKFontSizeCommand.prototype.Execute = function( fontSize )
+{
+	if ( typeof( fontSize ) == 'string' ) fontSize = parseInt(fontSize) ;
+
+	if ( fontSize == null || fontSize == '' )
+	{
+		// TODO: Remove font size attribute (Now it works with size 3. Will it work forever?)
+		FCK.ExecuteNamedCommand( 'FontSize', 3 ) ;
+	}
+	else
+		FCK.ExecuteNamedCommand( 'FontSize', fontSize ) ;
+}
+
+FCKFontSizeCommand.prototype.GetState = function()
+{
+	return FCK.GetNamedCommandValue( 'FontSize' ) ;
+}
+
+// ### FormatBlock
+var FCKFormatBlockCommand = function()
+{
+	this.Name = 'FormatBlock' ;
+}
+
+FCKFormatBlockCommand.prototype.Execute = function( formatName )
+{
+	if ( formatName == null || formatName == '' )
+		FCK.ExecuteNamedCommand( 'FormatBlock', '<P>' ) ;
+	else if ( formatName == 'div' && FCKBrowserInfo.IsGecko )
+		FCK.ExecuteNamedCommand( 'FormatBlock', 'div' ) ;
+	else
+		FCK.ExecuteNamedCommand( 'FormatBlock', '<' + formatName + '>' ) ;
+}
+
+FCKFormatBlockCommand.prototype.GetState = function()
+{
+	return FCK.GetNamedCommandValue( 'FormatBlock' ) ;
+}
+
+// ### Preview
+var FCKPreviewCommand = function()
+{
+	this.Name = 'Preview' ;
+}
+
+FCKPreviewCommand.prototype.Execute = function()
+{
+     FCK.Preview() ;
+}
+
+FCKPreviewCommand.prototype.GetState = function()
+{
+	return FCK_TRISTATE_OFF ;
+}
+
+// ### Save
+var FCKSaveCommand = function()
+{
+	this.Name = 'Save' ;
+}
+
+FCKSaveCommand.prototype.Execute = function()
+{
+	// Get the linked field form.
+	var oForm = FCK.LinkedField.form ;
+
+	if ( typeof( oForm.onsubmit ) == 'function' )
+	{
+		var bRet = oForm.onsubmit() ;
+		if ( bRet != null && bRet === false )
+			return ;
+	}
+
+	// Submit the form.
+	oForm.submit() ;
+}
+
+FCKSaveCommand.prototype.GetState = function()
+{
+	return FCK_TRISTATE_OFF ;
+}
+
+// ### NewPage
+var FCKNewPageCommand = function()
+{
+	this.Name = 'NewPage' ;
+}
+
+FCKNewPageCommand.prototype.Execute = function()
+{
+	FCKUndo.SaveUndoStep() ;
+	FCK.SetHTML( '' ) ;
+	FCKUndo.Typing = true ;
+//	FCK.SetHTML( FCKBrowserInfo.IsGecko ? '&nbsp;' : '' ) ;
+//	FCK.SetHTML( FCKBrowserInfo.IsGecko ? GECKO_BOGUS : '' ) ;
+}
+
+FCKNewPageCommand.prototype.GetState = function()
+{
+	return FCK_TRISTATE_OFF ;
+}
+
+// ### Source button
+var FCKSourceCommand = function()
+{
+	this.Name = 'Source' ;
+}
+
+FCKSourceCommand.prototype.Execute = function()
+{
+	if ( FCKConfig.SourcePopup )	// Until v2.2, it was mandatory for FCKBrowserInfo.IsGecko.
+	{
+		var iWidth	= FCKConfig.ScreenWidth * 0.65 ;
+		var iHeight	= FCKConfig.ScreenHeight * 0.65 ;
+		FCKDialog.OpenDialog( 'FCKDialog_Source', FCKLang.Source, 'dialog/fck_source.html', iWidth, iHeight, null, null, true ) ;
+	}
+	else
+	    FCK.SwitchEditMode() ;
+}
+
+FCKSourceCommand.prototype.GetState = function()
+{
+	return ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ? FCK_TRISTATE_OFF : FCK_TRISTATE_ON ) ;
+}
+
+// ### Undo
+var FCKUndoCommand = function()
+{
+	this.Name = 'Undo' ;
+}
+
+FCKUndoCommand.prototype.Execute = function()
+{
+	if ( FCKBrowserInfo.IsIE )
+		FCKUndo.Undo() ;
+	else
+		FCK.ExecuteNamedCommand( 'Undo' ) ;
+}
+
+FCKUndoCommand.prototype.GetState = function()
+{
+	if ( FCKBrowserInfo.IsIE )
+		return ( FCKUndo.CheckUndoState() ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ) ;
+	else
+		return FCK.GetNamedCommandState( 'Undo' ) ;
+}
+
+// ### Redo
+var FCKRedoCommand = function()
+{
+	this.Name = 'Redo' ;
+}
+
+FCKRedoCommand.prototype.Execute = function()
+{
+	if ( FCKBrowserInfo.IsIE )
+		FCKUndo.Redo() ;
+	else
+		FCK.ExecuteNamedCommand( 'Redo' ) ;
+}
+
+FCKRedoCommand.prototype.GetState = function()
+{
+	if ( FCKBrowserInfo.IsIE )
+		return ( FCKUndo.CheckRedoState() ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ) ;
+	else
+		return FCK.GetNamedCommandState( 'Redo' ) ;
+}
+
+// ### Page Break
+var FCKPageBreakCommand = function()
+{
+	this.Name = 'PageBreak' ;
+}
+
+FCKPageBreakCommand.prototype.Execute = function()
+{
+//	var e = FCK.EditorDocument.createElement( 'CENTER' ) ;
+//	e.style.pageBreakAfter = 'always' ;
+
+	// Tidy was removing the empty CENTER tags, so the following solution has 
+	// been found. It also validates correctly as XHTML 1.0 Strict.
+	var e = FCK.EditorDocument.createElement( 'DIV' ) ;
+	e.style.pageBreakAfter = 'always' ;
+	e.innerHTML = '<span style="DISPLAY:none">&nbsp;</span>' ;
+	
+	var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', e ) ;
+	oFakeImage	= FCK.InsertElement( oFakeImage ) ;
+}
+
+FCKPageBreakCommand.prototype.GetState = function()
+{
+	return 0 ; // FCK_TRISTATE_OFF
+}
+
+// FCKUnlinkCommand - by Johnny Egeland (johnny@coretrek.com)
+var FCKUnlinkCommand = function()
+{
+	this.Name = 'Unlink' ;
+}
+
+FCKUnlinkCommand.prototype.Execute = function()
+{
+	if ( FCKBrowserInfo.IsGecko )
+	{
+		var oLink = FCK.Selection.MoveToAncestorNode( 'A' ) ;
+		if ( oLink ) 
+			FCK.Selection.SelectNode( oLink ) ;
+	}
+	
+	FCK.ExecuteNamedCommand( this.Name ) ;
+
+	if ( FCKBrowserInfo.IsGecko )
+		FCK.Selection.Collapse( true ) ;
+}
+
+FCKUnlinkCommand.prototype.GetState = function()
+{
+	return FCK.GetNamedCommandState( this.Name ) ;
+}

stud/FCKeditor/editor/_source/commandclasses/fckfitwindow.js

@@ -0,0 +1,164 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckfitwindow.js
+ * 	Stretch the editor to full window size and back.
+ * 
+ * File Authors:
+ * 		Paul Moers (mail@saulmade.nl)
+ * 		Thanks to Christian Fecteau (webmaster@christianfecteau.com)
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKFitWindow = function()
+{
+	this.Name = 'FitWindow' ;
+}
+
+FCKFitWindow.prototype.Execute = function()
+{
+	var eEditorFrame		= window.frameElement ;
+	var eEditorFrameStyle	= eEditorFrame.style ;
+
+	var eMainWindow			= parent ;
+	var eDocEl				= eMainWindow.document.documentElement ;
+	var eBody				= eMainWindow.document.body ;
+	var eBodyStyle			= eBody.style ;
+
+	// No original style properties known? Go fullscreen.
+	if ( !this.IsMaximized )
+	{
+		// Registering an event handler when the window gets resized.
+		if( FCKBrowserInfo.IsIE )
+			eMainWindow.attachEvent( 'onresize', FCKFitWindow_Resize ) ;
+		else
+			eMainWindow.addEventListener( 'resize', FCKFitWindow_Resize, true ) ;
+
+		// Save the scrollbars position.
+		this._ScrollPos = FCKTools.GetScrollPosition( eMainWindow ) ;
+		
+		// Save and reset the styles for the entire node tree. They could interfere in the result.
+		var eParent = eEditorFrame ;
+		while( eParent = eParent.parentNode )
+		{
+			if ( eParent.nodeType == 1 )
+				eParent._fckSavedStyles = FCKTools.SaveStyles( eParent ) ;
+		}		
+
+		// Hide IE scrollbars (in strict mode).
+		if ( FCKBrowserInfo.IsIE )
+		{
+			this.documentElementOverflow = eDocEl.style.overflow ;
+			eDocEl.style.overflow	= 'hidden' ;
+			eBodyStyle.overflow		= 'hidden' ;
+		}
+		else
+		{
+			// Hide the scroolbars in Firefox.
+			eBodyStyle.overflow = 'hidden' ;
+			eBodyStyle.width = '0px' ;
+			eBodyStyle.height = '0px' ;
+		}
+		
+		// Save the IFRAME styles.
+		this._EditorFrameStyles = FCKTools.SaveStyles( eEditorFrame ) ;
+		
+		// Resize.
+		var oViewPaneSize = FCKTools.GetViewPaneSize( eMainWindow ) ;
+
+		eEditorFrameStyle.position	= "absolute";
+		eEditorFrameStyle.zIndex	= FCKConfig.FloatingPanelsZIndex - 1;
+		eEditorFrameStyle.left		= "0px";
+		eEditorFrameStyle.top		= "0px";
+		eEditorFrameStyle.width		= oViewPaneSize.Width + "px";
+		eEditorFrameStyle.height	= oViewPaneSize.Height + "px";
+		
+		// Giving the frame some (huge) borders on his right and bottom
+		// side to hide the background that would otherwise show when the
+		// editor is in fullsize mode and the window is increased in size
+		// not for IE, because IE immediately adapts the editor on resize, 
+		// without showing any of the background oddly in firefox, the
+		// editor seems not to fill the whole frame, so just setting the
+		// background of it to white to cover the page laying behind it anyway.
+		if ( !FCKBrowserInfo.IsIE )
+		{
+			eEditorFrameStyle.borderRight = eEditorFrameStyle.borderBottom = "9999px solid white" ;
+			eEditorFrameStyle.backgroundColor		= "white";
+		}
+
+		// Scroll to top left.
+		eMainWindow.scrollTo(0, 0);
+
+		this.IsMaximized = true ;
+	}
+	else	// Resize to original size.
+	{
+		// Remove the event handler of window resizing.
+		if( FCKBrowserInfo.IsIE )
+			eMainWindow.detachEvent( "onresize", FCKFitWindow_Resize ) ;
+		else
+			eMainWindow.removeEventListener( "resize", FCKFitWindow_Resize, true ) ;
+
+		// Restore the CSS position for the entire node tree.
+		var eParent = eEditorFrame ;
+		while( eParent = eParent.parentNode )
+		{
+			if ( eParent._fckSavedStyles )
+			{
+				FCKTools.RestoreStyles( eParent, eParent._fckSavedStyles ) ;
+				eParent._fckSavedStyles = null ;
+			}
+		}
+		
+		// Restore IE scrollbars
+		if ( FCKBrowserInfo.IsIE )
+			eDocEl.style.overflow = this.documentElementOverflow ;
+
+		// Restore original size
+		FCKTools.RestoreStyles( eEditorFrame, this._EditorFrameStyles ) ;
+		
+		// Restore the window scroll position.
+		eMainWindow.scrollTo( this._ScrollPos.X, this._ScrollPos.Y ) ;
+
+		this.IsMaximized = false ;
+	}
+	
+	FCKToolbarItems.GetItem('FitWindow').RefreshState() ;
+
+	// It seams that Firefox restarts the editing area when making this changes.
+	// On FF 1.0.x, the area is not anymore editable. On FF 1.5+, the special 
+	//configuration, like DisableFFTableHandles and DisableObjectResizing get 
+	//lost, so we must reset it. Also, the cursor position and selection are 
+	//also lost, even if you comment the following line (MakeEditable).
+	// if ( FCKBrowserInfo.IsGecko10 )	// Initially I thought it was a FF 1.0 only problem.
+	FCK.EditingArea.MakeEditable() ;
+	
+	FCK.Focus() ;
+}
+
+FCKFitWindow.prototype.GetState = function()
+{
+	if ( FCKConfig.ToolbarLocation != 'In' )
+		return FCK_TRISTATE_DISABLED ;
+	else
+		return ( this.IsMaximized ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF );
+}
+
+function FCKFitWindow_Resize()
+{
+	var oViewPaneSize = FCKTools.GetViewPaneSize( parent ) ;
+
+	var eEditorFrameStyle = window.frameElement.style ;
+
+	eEditorFrameStyle.width		= oViewPaneSize.Width + 'px' ;
+	eEditorFrameStyle.height	= oViewPaneSize.Height + 'px' ;
+}

stud/FCKeditor/editor/_source/commandclasses/fcknamedcommand.js

@@ -0,0 +1,33 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcknamedcommand.js
+ * 	FCKNamedCommand Class: represents an internal browser command.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKNamedCommand = function( commandName )
+{
+	this.Name = commandName ;
+}
+
+FCKNamedCommand.prototype.Execute = function()
+{
+	FCK.ExecuteNamedCommand( this.Name ) ;
+}
+
+FCKNamedCommand.prototype.GetState = function()
+{
+	return FCK.GetNamedCommandState( this.Name ) ;
+}

stud/FCKeditor/editor/_source/commandclasses/fckpasteplaintextcommand.js

@@ -0,0 +1,34 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckpasteplaintextcommand.js
+ * 	FCKPastePlainTextCommand Class: represents the 
+ * 	"Paste as Plain Text" command.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKPastePlainTextCommand = function() 
+{
+	this.Name = 'PasteText' ;
+}
+
+FCKPastePlainTextCommand.prototype.Execute = function()
+{
+	FCK.PasteAsPlainText() ;
+}
+
+FCKPastePlainTextCommand.prototype.GetState = function()
+{
+	return FCK.GetNamedCommandState( 'Paste' ) ;
+}

stud/FCKeditor/editor/_source/commandclasses/fckpastewordcommand.js

@@ -0,0 +1,36 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckpastewordcommand.js
+ * 	FCKPasteWordCommand Class: represents the "Paste from Word" command.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKPasteWordCommand = function() 
+{
+	this.Name = 'PasteWord' ;
+}
+
+FCKPasteWordCommand.prototype.Execute = function()
+{
+	FCK.PasteFromWord() ;
+}
+
+FCKPasteWordCommand.prototype.GetState = function()
+{
+	if ( FCKConfig.ForcePasteAsPlainText )
+		return FCK_TRISTATE_DISABLED ;
+	else
+		return FCK.GetNamedCommandState( 'Paste' ) ;
+}

stud/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_gecko.js

@@ -0,0 +1,35 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckspellcheckcommand_gecko.js
+ * 	FCKStyleCommand Class: represents the "Spell Check" command.
+ * 	(Gecko specific implementation)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKSpellCheckCommand = function()
+{
+	this.Name = 'SpellCheck' ;
+	this.IsEnabled = ( FCKConfig.SpellChecker == 'SpellerPages' ) ;
+}
+
+FCKSpellCheckCommand.prototype.Execute = function()
+{
+	FCKDialog.OpenDialog( 'FCKDialog_SpellCheck', 'Spell Check', 'dialog/fck_spellerpages.html', 440, 480 ) ;
+}
+
+FCKSpellCheckCommand.prototype.GetState = function()
+{
+	return this.IsEnabled ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+}

stud/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_ie.js

@@ -0,0 +1,63 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckspellcheckcommand_ie.js
+ * 	FCKStyleCommand Class: represents the "Spell Check" command.
+ * 	(IE specific implementation)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKSpellCheckCommand = function()
+{
+	this.Name = 'SpellCheck' ;
+	this.IsEnabled = ( FCKConfig.SpellChecker == 'ieSpell' || FCKConfig.SpellChecker == 'SpellerPages' ) ;
+}
+
+FCKSpellCheckCommand.prototype.Execute = function()
+{
+	switch ( FCKConfig.SpellChecker )
+	{
+		case 'ieSpell' :
+			this._RunIeSpell() ;
+			break ;
+		
+		case 'SpellerPages' :
+			FCKDialog.OpenDialog( 'FCKDialog_SpellCheck', 'Spell Check', 'dialog/fck_spellerpages.html', 440, 480 ) ;
+			break ;
+	}
+}
+
+FCKSpellCheckCommand.prototype._RunIeSpell = function()
+{
+	try
+	{
+		var oIeSpell = new ActiveXObject( "ieSpell.ieSpellExtension" ) ;
+		oIeSpell.CheckAllLinkedDocuments( FCK.EditorDocument ) ;
+	}
+	catch( e )
+	{
+		if( e.number == -2146827859 )
+		{
+			if ( confirm( FCKLang.IeSpellDownload ) )
+				window.open( FCKConfig.IeSpellDownloadUrl , 'IeSpellDownload' ) ;
+		}
+		else
+			alert( 'Error Loading ieSpell: ' + e.message + ' (' + e.number + ')' ) ;
+	}
+}
+
+FCKSpellCheckCommand.prototype.GetState = function()
+{
+	return this.IsEnabled ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+}

stud/FCKeditor/editor/_source/commandclasses/fckstylecommand.js

@@ -0,0 +1,95 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckstylecommand.js
+ * 	FCKStyleCommand Class: represents the "Style" command.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKStyleCommand = function()
+{
+	this.Name = 'Style' ;
+
+	// Load the Styles defined in the XML file.
+	this.StylesLoader = new FCKStylesLoader() ;
+	this.StylesLoader.Load( FCKConfig.StylesXmlPath ) ;
+	this.Styles = this.StylesLoader.Styles ;
+}
+
+FCKStyleCommand.prototype.Execute = function( styleName, styleComboItem )
+{
+	FCKUndo.SaveUndoStep() ;
+
+	if ( styleComboItem.Selected )
+		styleComboItem.Style.RemoveFromSelection() ;
+	else
+		styleComboItem.Style.ApplyToSelection() ;
+
+	FCKUndo.SaveUndoStep() ;
+
+	FCK.Focus() ;
+	
+	FCK.Events.FireEvent( "OnSelectionChange" ) ;
+}
+
+FCKStyleCommand.prototype.GetState = function()
+{
+	if ( !FCK.EditorDocument )
+		return FCK_TRISTATE_DISABLED ;
+
+	var oSelection = FCK.EditorDocument.selection ;
+	
+	if ( FCKSelection.GetType() == 'Control' )
+	{
+		var e = FCKSelection.GetSelectedElement() ;
+		if ( e )
+			return this.StylesLoader.StyleGroups[ e.tagName ] ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+	}
+
+	return FCK_TRISTATE_OFF ;
+}
+
+FCKStyleCommand.prototype.GetActiveStyles = function()
+{
+	var aActiveStyles = new Array() ;
+	
+	if ( FCKSelection.GetType() == 'Control' )
+		this._CheckStyle( FCKSelection.GetSelectedElement(), aActiveStyles, false ) ;
+	else
+		this._CheckStyle( FCKSelection.GetParentElement(), aActiveStyles, true ) ;
+		
+	return aActiveStyles ;
+}
+
+FCKStyleCommand.prototype._CheckStyle = function( element, targetArray, checkParent )
+{
+	if ( ! element )
+		return ;
+
+	if ( element.nodeType == 1 )
+	{
+		var aStyleGroup = this.StylesLoader.StyleGroups[ element.tagName ] ;
+		if ( aStyleGroup )
+		{
+			for ( var i = 0 ; i < aStyleGroup.length ; i++ )
+			{
+				if ( aStyleGroup[i].IsEqual( element ) )
+					targetArray[ targetArray.length ] = aStyleGroup[i] ;
+			}		
+		}
+	}
+	
+	if ( checkParent )
+		this._CheckStyle( element.parentNode, targetArray, checkParent ) ;
+}

stud/FCKeditor/editor/_source/commandclasses/fcktablecommand.js

@@ -0,0 +1,67 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktablecommand.js
+ * 	FCKPastePlainTextCommand Class: represents the 
+ * 	"Paste as Plain Text" command.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKTableCommand = function( command )
+{
+	this.Name = command ;
+}
+
+FCKTableCommand.prototype.Execute = function()
+{
+	FCKUndo.SaveUndoStep() ;
+	
+	switch ( this.Name )
+	{
+		case 'TableInsertRow' :
+			FCKTableHandler.InsertRow() ;
+			break ;
+		case 'TableDeleteRows' :
+			FCKTableHandler.DeleteRows() ;
+			break ;
+		case 'TableInsertColumn' :
+			FCKTableHandler.InsertColumn() ;
+			break ;
+		case 'TableDeleteColumns' :
+			FCKTableHandler.DeleteColumns() ;
+			break ;
+		case 'TableInsertCell' :
+			FCKTableHandler.InsertCell() ;
+			break ;
+		case 'TableDeleteCells' :
+			FCKTableHandler.DeleteCells() ;
+			break ;
+		case 'TableMergeCells' :
+			FCKTableHandler.MergeCells() ;
+			break ;
+		case 'TableSplitCell' :
+			FCKTableHandler.SplitCell() ;
+			break ;
+		case 'TableDelete' :
+			FCKTableHandler.DeleteTable() ;
+			break ;
+		default :
+			alert( FCKLang.UnknownCommand.replace( /%1/g, this.Name ) ) ;
+	}
+}
+
+FCKTableCommand.prototype.GetState = function()
+{
+	return FCK_TRISTATE_OFF ;
+}

stud/FCKeditor/editor/_source/commandclasses/fcktextcolorcommand.js

@@ -0,0 +1,171 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktextcolorcommand.js
+ * 	FCKTextColorCommand Class: represents the text color comand. It shows the
+ * 	color selection panel.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// FCKTextColorCommand Contructor
+//		type: can be 'ForeColor' or 'BackColor'.
+var FCKTextColorCommand = function( type )
+{
+	this.Name = type == 'ForeColor' ? 'TextColor' : 'BGColor' ;
+	this.Type = type ;
+
+	var oWindow ;
+	
+	if ( FCKBrowserInfo.IsIE )
+		oWindow = window ;
+	else if ( FCK.ToolbarSet._IFrame )
+		oWindow = FCKTools.GetElementWindow( FCK.ToolbarSet._IFrame ) ;
+	else
+		oWindow = window.parent ;
+
+	this._Panel = new FCKPanel( oWindow, true ) ;
+	this._Panel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ;
+	this._Panel.MainNode.className = 'FCK_Panel' ;
+	this._CreatePanelBody( this._Panel.Document, this._Panel.MainNode ) ;
+	
+	FCKTools.DisableSelection( this._Panel.Document.body ) ;
+}
+
+FCKTextColorCommand.prototype.Execute = function( panelX, panelY, relElement )
+{
+	// We must "cache" the actual panel type to be used in the SetColor method.
+	FCK._ActiveColorPanelType = this.Type ;
+
+	// Show the Color Panel at the desired position.
+	this._Panel.Show( panelX, panelY, relElement ) ;
+}
+
+FCKTextColorCommand.prototype.SetColor = function( color )
+{
+	if ( FCK._ActiveColorPanelType == 'ForeColor' )
+		FCK.ExecuteNamedCommand( 'ForeColor', color ) ;
+	else if ( FCKBrowserInfo.IsGeckoLike )
+	{
+		if ( FCKBrowserInfo.IsGecko && !FCKConfig.GeckoUseSPAN )
+			FCK.EditorDocument.execCommand( 'useCSS', false, false ) ;
+			
+		FCK.ExecuteNamedCommand( 'hilitecolor', color ) ;
+
+		if ( FCKBrowserInfo.IsGecko && !FCKConfig.GeckoUseSPAN )
+			FCK.EditorDocument.execCommand( 'useCSS', false, true ) ;
+	}
+	else
+		FCK.ExecuteNamedCommand( 'BackColor', color ) ;
+	
+	// Delete the "cached" active panel type.
+	delete FCK._ActiveColorPanelType ;
+}
+
+FCKTextColorCommand.prototype.GetState = function()
+{
+	return FCK_TRISTATE_OFF ;
+}
+
+function FCKTextColorCommand_OnMouseOver()	{ this.className='ColorSelected' ; }
+
+function FCKTextColorCommand_OnMouseOut()	{ this.className='ColorDeselected' ; }
+
+function FCKTextColorCommand_OnClick()
+{
+	this.className = 'ColorDeselected' ;
+	this.Command.SetColor( '#' + this.Color ) ;
+	this.Command._Panel.Hide() ;
+}
+
+function FCKTextColorCommand_AutoOnClick()
+{
+	this.className = 'ColorDeselected' ;
+	this.Command.SetColor( '' ) ;
+	this.Command._Panel.Hide() ;
+}
+
+function FCKTextColorCommand_MoreOnClick()
+{
+	this.className = 'ColorDeselected' ;
+	this.Command._Panel.Hide() ;
+	FCKDialog.OpenDialog( 'FCKDialog_Color', FCKLang.DlgColorTitle, 'dialog/fck_colorselector.html', 400, 330, this.Command.SetColor ) ;
+}
+
+FCKTextColorCommand.prototype._CreatePanelBody = function( targetDocument, targetDiv )
+{
+	function CreateSelectionDiv()
+	{
+		var oDiv = targetDocument.createElement( "DIV" ) ;
+		oDiv.className		= 'ColorDeselected' ;
+		oDiv.onmouseover	= FCKTextColorCommand_OnMouseOver ;
+		oDiv.onmouseout		= FCKTextColorCommand_OnMouseOut ;
+		
+		return oDiv ;
+	}
+
+	// Create the Table that will hold all colors.
+	var oTable = targetDiv.appendChild( targetDocument.createElement( "TABLE" ) ) ;
+	oTable.className = 'ForceBaseFont' ;		// Firefox 1.5 Bug.
+	oTable.style.tableLayout = 'fixed' ;
+	oTable.cellPadding = 0 ;
+	oTable.cellSpacing = 0 ;
+	oTable.border = 0 ;
+	oTable.width = 150 ;
+
+	var oCell = oTable.insertRow(-1).insertCell(-1) ;
+	oCell.colSpan = 8 ;
+
+	// Create the Button for the "Automatic" color selection.
+	var oDiv = oCell.appendChild( CreateSelectionDiv() ) ;
+	oDiv.innerHTML = 
+		'<table cellspacing="0" cellpadding="0" width="100%" border="0">\
+			<tr>\
+				<td><div class="ColorBoxBorder"><div class="ColorBox" style="background-color: #000000"></div></div></td>\
+				<td nowrap width="100%" align="center">' + FCKLang.ColorAutomatic + '</td>\
+			</tr>\
+		</table>' ;
+
+	oDiv.Command = this ;
+	oDiv.onclick = FCKTextColorCommand_AutoOnClick ;
+
+	// Create an array of colors based on the configuration file.
+	var aColors = FCKConfig.FontColors.toString().split(',') ;
+
+	// Create the colors table based on the array.
+	var iCounter = 0 ;
+	while ( iCounter < aColors.length )
+	{
+		var oRow = oTable.insertRow(-1) ;
+		
+		for ( var i = 0 ; i < 8 && iCounter < aColors.length ; i++, iCounter++ )
+		{
+			oDiv = oRow.insertCell(-1).appendChild( CreateSelectionDiv() ) ;
+			oDiv.Color = aColors[iCounter] ;
+			oDiv.innerHTML = '<div class="ColorBoxBorder"><div class="ColorBox" style="background-color: #' + aColors[iCounter] + '"></div></div>' ;
+
+			oDiv.Command = this ;
+			oDiv.onclick = FCKTextColorCommand_OnClick ;
+		}
+	}
+
+	// Create the Row and the Cell for the "More Colors..." button.
+	oCell = oTable.insertRow(-1).insertCell(-1) ;
+	oCell.colSpan = 8 ;
+
+	oDiv = oCell.appendChild( CreateSelectionDiv() ) ;
+	oDiv.innerHTML = '<table width="100%" cellpadding="0" cellspacing="0" border="0"><tr><td nowrap align="center">' + FCKLang.ColorMoreColors + '</td></tr></table>' ;
+
+	oDiv.Command = this ;
+	oDiv.onclick = FCKTextColorCommand_MoreOnClick ;
+}

stud/FCKeditor/editor/_source/fckconstants.js

@@ -0,0 +1,44 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckconstants.js
+ * 	Defines some constants used by the editor. These constants are also 
+ * 	globally available in the page where the editor is placed.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Editor Instance Status.
+var FCK_STATUS_NOTLOADED	= window.parent.FCK_STATUS_NOTLOADED	= 0 ;
+var FCK_STATUS_ACTIVE		= window.parent.FCK_STATUS_ACTIVE		= 1 ;
+var FCK_STATUS_COMPLETE		= window.parent.FCK_STATUS_COMPLETE		= 2 ;
+
+// Tristate Operations.
+var FCK_TRISTATE_OFF		= window.parent.FCK_TRISTATE_OFF		= 0 ;
+var FCK_TRISTATE_ON			= window.parent.FCK_TRISTATE_ON			= 1 ;
+var FCK_TRISTATE_DISABLED	= window.parent.FCK_TRISTATE_DISABLED	= -1 ;
+
+// For unknown values.
+var FCK_UNKNOWN				= window.parent.FCK_UNKNOWN				= -9 ;
+
+// Toolbar Items Style.
+var FCK_TOOLBARITEM_ONLYICON	= window.parent.FCK_TOOLBARITEM_ONLYICON	= 0 ;
+var FCK_TOOLBARITEM_ONLYTEXT	= window.parent.FCK_TOOLBARITEM_ONLYTEXT	= 1 ;
+var FCK_TOOLBARITEM_ICONTEXT	= window.parent.FCK_TOOLBARITEM_ICONTEXT	= 2 ;
+
+// Edit Mode
+var FCK_EDITMODE_WYSIWYG	= window.parent.FCK_EDITMODE_WYSIWYG	= 0 ;
+var FCK_EDITMODE_SOURCE		= window.parent.FCK_EDITMODE_SOURCE		= 1 ;
+
+var FCK_IMAGES_PATH = 'images/' ;		// Check usage.
+var FCK_SPACER_PATH = 'images/spacer.gif' ;

stud/FCKeditor/editor/_source/fckeditorapi.js

@@ -0,0 +1,104 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckeditorapi.js
+ * 	Create the FCKeditorAPI object that is available as a global object in
+ * 	the page where the editor is placed in.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKeditorAPI ;
+
+function InitializeAPI()
+{
+	if ( !( FCKeditorAPI = window.parent.FCKeditorAPI ) )
+	{
+		// Make the FCKeditorAPI object available in the parent window. Use 
+		// eval so it is independent from this window and so it will still be 
+		// available if the editor instance is removed ("Can't execute code
+		// from a freed script" error).
+		var sScript = '\
+			var FCKeditorAPI = {\
+				Version			: \'2.3.2\',\
+				VersionBuild	: \'1082\',\
+				__Instances		: new Object(),\
+				GetInstance		: function( instanceName )\
+				{\
+					return this.__Instances[ instanceName ] ;\
+				},\
+				_FunctionQueue	: {\
+					Functions	: new Array(),\
+					IsRunning	: false,\
+					Add			: function( functionToAdd )\
+					{\
+						this.Functions.push( functionToAdd ) ;\
+						if ( !this.IsRunning )\
+							this.StartNext() ;\
+					},\
+					StartNext	: function()\
+					{\
+						var aQueue = this.Functions ;\
+						if ( aQueue.length > 0 )\
+						{\
+							this.IsRunning = true ;\
+							aQueue[0].call() ;\
+						}\
+						else\
+							this.IsRunning = false ;\
+					},\
+					Remove		: function( func )\
+					{\
+						var aQueue = this.Functions ;\
+						var i = 0, fFunc ;\
+						while( fFunc = aQueue[ i ] )\
+						{\
+							if ( fFunc == func )\
+								aQueue.splice( i,1 ) ;\
+							i++ ;\
+						}\
+						this.StartNext() ;\
+					}\
+				}\
+			}' ;
+		
+		// In IE, the "eval" function is not always available (it works with
+		// the JavaScript samples, but not with the ASP ones, for example).
+		// So, let's use the execScript instead.
+		if ( window.parent.execScript )
+			window.parent.execScript( sScript, 'JavaScript' ) ;
+		else
+		{
+			if ( FCKBrowserInfo.IsGecko10 )
+			{
+				// FF 1.0.4 gives an error with the above request. The
+				// following seams to work well. It could become to official
+				// implementation for all browsers, but we need to check it.
+				eval.call( window.parent, sScript ) ;
+			}
+			else
+				window.parent.eval( sScript ) ;
+		}
+		
+		FCKeditorAPI = window.parent.FCKeditorAPI ;
+	}
+
+	// Add the current instance to the FCKeditorAPI's instances collection.
+	FCKeditorAPI.__Instances[ FCK.Name ] = FCK ;
+}
+
+function FCKeditorAPI_Cleanup()
+{
+	FCKeditorAPI.__Instances[ FCK.Name ] = null ;
+}
+FCKTools.AddEventListener( window, 'unload', FCKeditorAPI_Cleanup ) ;	

stud/FCKeditor/editor/_source/fckjscoreextensions.js

@@ -0,0 +1,120 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckjscoreextensions.js
+ * 	Extensions to the JavaScript Core.
+ * 
+ * 	All custom extentions functions are PascalCased to differ from the standard
+ * 	camelCased ones.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+String.prototype.Contains = function( textToCheck )
+{
+	return ( this.indexOf( textToCheck ) > -1 ) ;
+}
+
+String.prototype.Equals = function()
+{
+	for ( var i = 0 ; i < arguments.length ; i++ )
+		if ( this == arguments[i] )
+			return true ;
+	
+	return false ;
+}
+
+String.prototype.ReplaceAll = function( searchArray, replaceArray )
+{
+	var replaced = this ;
+	
+	for ( var i = 0 ; i < searchArray.length ; i++ )
+	{
+		replaced = replaced.replace( searchArray[i], replaceArray[i] ) ;
+	}
+	
+	return replaced ;
+}
+
+Array.prototype.AddItem = function( item )
+{
+	var i = this.length ;
+	this[ i ] = item ;
+	return i ;
+}
+
+Array.prototype.indexOf = function( value )
+{
+	for ( var i = 0 ; i < this.length ; i++ )
+	{
+		if ( this[i] == value )
+			return i ;
+	}
+	return -1 ;
+}
+
+String.prototype.startsWith = function( value )
+{
+	return ( this.substr( 0, value.length ) == value ) ;
+}
+
+// Extends the String object, creating a "endsWith" method on it.
+String.prototype.endsWith = function( value, ignoreCase )
+{
+	var L1 = this.length ;
+	var L2 = value.length ;
+	
+	if ( L2 > L1 )
+		return false ;
+
+	if ( ignoreCase )
+	{
+		var oRegex = new RegExp( value + '$' , 'i' ) ;
+		return oRegex.test( this ) ;
+	}
+	else
+		return ( L2 == 0 || this.substr( L1 - L2, L2 ) == value ) ;
+}
+
+String.prototype.remove = function( start, length )
+{
+	var s = '' ;
+	
+	if ( start > 0 )
+		s = this.substring( 0, start ) ;
+	
+	if ( start + length < this.length )
+		s += this.substring( start + length , this.length ) ;
+		
+	return s ;
+}
+
+String.prototype.trim = function()
+{
+	return this.replace( /(^\s*)|(\s*$)/g, '' ) ;
+}
+
+String.prototype.ltrim = function()
+{
+	return this.replace( /^\s*/g, '' ) ;
+}
+
+String.prototype.rtrim = function()
+{
+	return this.replace( /\s*$/g, '' ) ;
+}
+
+String.prototype.replaceNewLineChars = function( replacement )
+{
+	return this.replace( /\n/g, replacement ) ;
+}

stud/FCKeditor/editor/_source/internals/fck.js

@@ -0,0 +1,77 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck.js
+ * 	Creation and initialization of the "FCK" object. This is the main object
+ * 	that represents an editor instance.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// FCK represents the active editor instance
+var FCK = new Object() ;
+FCK.Name			= FCKURLParams[ 'InstanceName' ] ;
+
+FCK.Status			= FCK_STATUS_NOTLOADED ;
+FCK.EditMode		= FCK_EDITMODE_WYSIWYG ;
+
+FCK.LoadLinkedFile = function()
+{
+	// There is a bug on IE... getElementById returns any META tag that has the
+	// name set to the ID you are looking for. So the best way in to get the array
+	// by names and look for the correct one.
+	// As ASP.Net generates a ID that is different from the Name, we must also
+	// look for the field based on the ID (the first one is the ID).
+	
+	var oDocument = window.parent.document ;
+
+	var eLinkedField		= oDocument.getElementById( FCK.Name ) ;
+	var colElementsByName	= oDocument.getElementsByName( FCK.Name ) ;
+
+	var i = 0;
+	while ( eLinkedField || i == 0 )
+	{
+		if ( eLinkedField && ( eLinkedField.tagName.toLowerCase() == 'input' || eLinkedField.tagName.toLowerCase() == 'textarea' ) )
+		{
+			FCK.LinkedField = eLinkedField ;
+			break ;
+		}
+		eLinkedField = colElementsByName[i++] ;
+	}
+}
+FCK.LoadLinkedFile() ;
+
+var FCKTempBin = new Object() ;
+FCKTempBin.Elements = new Array() ;
+
+FCKTempBin.AddElement = function( element )
+{
+	var iIndex = this.Elements.length ;
+	this.Elements[ iIndex ] = element ;
+	return iIndex ;
+}
+
+FCKTempBin.RemoveElement = function( index )
+{
+	var e = this.Elements[ index ] ;
+	this.Elements[ index ] = null ;
+	return e ;
+}
+
+FCKTempBin.Reset = function()
+{
+	var i = 0 ;
+	while ( i < this.Elements.length )
+		this.Elements[ i++ ] == null ;
+	this.Elements.length = 0 ;
+}

stud/FCKeditor/editor/_source/internals/fck_1.js

@@ -0,0 +1,410 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_1.js
+ * 	This is the first part of the "FCK" object creation. This is the main
+ * 	object that represents an editor instance.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCK_StartupValue ;
+
+FCK.Events	= new FCKEvents( FCK ) ;
+FCK.Toolbar	= null ;
+FCK.HasFocus = false ;
+
+FCK.StartEditor = function()
+{
+	FCK.TempBaseTag = FCKConfig.BaseHref.length > 0 ? '<base href="' + FCKConfig.BaseHref + '" _fcktemp="true"></base>' : '' ;
+
+	FCK.EditingArea = new FCKEditingArea( document.getElementById( 'xEditingArea' ) ) ;
+
+	// Set the editor's startup contents
+	this.SetHTML( FCKTools.GetLinkedFieldValue() ) ;
+}
+
+FCK.Focus = function()
+{
+	FCK.EditingArea.Focus() ;
+}
+
+FCK.SetStatus = function( newStatus )
+{
+	this.Status = newStatus ;
+
+	if ( newStatus == FCK_STATUS_ACTIVE )
+	{
+		FCKFocusManager.AddWindow( window, true ) ;
+		
+		if ( FCKBrowserInfo.IsIE )
+			FCKFocusManager.AddWindow( window.frameElement, true ) ;
+
+		// Force the focus in the editor.
+		if ( FCKConfig.StartupFocus )
+			FCK.Focus() ;
+	}
+
+	this.Events.FireEvent( 'OnStatusChange', newStatus ) ;
+}
+
+// GetHTML is Deprecated : returns the same value as GetXHTML.
+FCK.GetHTML = FCK.GetXHTML = function( format )
+{
+	// We assume that if the user is in source editing, the editor value must
+	// represent the exact contents of the source, as the user wanted it to be.
+	if ( FCK.EditMode == FCK_EDITMODE_SOURCE )
+			return FCK.EditingArea.Textarea.value ;
+
+	var sXHTML ;
+	var oDoc = FCK.EditorDocument ;
+
+	if ( FCKConfig.FullPage )
+		sXHTML = FCKXHtml.GetXHTML( oDoc.getElementsByTagName( 'html' )[0], true, format ) ;
+	else
+	{
+		if ( FCKConfig.IgnoreEmptyParagraphValue && oDoc.body.innerHTML == '<P>&nbsp;</P>' )
+			sXHTML = '' ;
+		else
+			sXHTML = FCKXHtml.GetXHTML( oDoc.body, false, format ) ;
+	}
+	
+	// Restore protected attributes.
+	sXHTML = FCK.ProtectEventsRestore( sXHTML ) ;
+
+	if ( FCKBrowserInfo.IsIE )
+		sXHTML = sXHTML.replace( FCKRegexLib.ToReplace, '$1' ) ;
+
+	if ( FCK.DocTypeDeclaration && FCK.DocTypeDeclaration.length > 0 )
+		sXHTML = FCK.DocTypeDeclaration + '\n' + sXHTML ;
+
+	if ( FCK.XmlDeclaration && FCK.XmlDeclaration.length > 0 )
+		sXHTML = FCK.XmlDeclaration + '\n' + sXHTML ;
+
+	return FCKConfig.ProtectedSource.Revert( sXHTML ) ;
+}
+
+FCK.UpdateLinkedField = function()
+{
+	FCK.LinkedField.value = FCK.GetXHTML( FCKConfig.FormatOutput ) ;
+	FCK.Events.FireEvent( 'OnAfterLinkedFieldUpdate' ) ;
+}
+
+FCK.RegisteredDoubleClickHandlers = new Object() ;
+
+FCK.OnDoubleClick = function( element )
+{
+	var oHandler = FCK.RegisteredDoubleClickHandlers[ element.tagName ] ;
+	if ( oHandler )
+		oHandler( element ) ;
+}
+
+// Register objects that can handle double click operations.
+FCK.RegisterDoubleClickHandler = function( handlerFunction, tag )
+{
+	FCK.RegisteredDoubleClickHandlers[ tag.toUpperCase() ] = handlerFunction ;
+}
+
+FCK.OnAfterSetHTML = function()
+{
+	FCKDocumentProcessor.Process( FCK.EditorDocument ) ;	
+	FCKUndo.SaveUndoStep() ;
+	FCK.Events.FireEvent( 'OnSelectionChange' ) ;
+	FCK.Events.FireEvent( 'OnAfterSetHTML' ) ;
+}
+
+// Saves URLs on links and images on special attributes, so they don't change when 
+// moving around.
+FCK.ProtectUrls = function( html )
+{
+	// <A> href
+	html = html.replace( FCKRegexLib.ProtectUrlsA	, '$1$4$2$3$5$2 _fcksavedurl=$2$3$5$2' ) ;
+
+	// <IMG> src
+	html = html.replace( FCKRegexLib.ProtectUrlsImg	, '$1$4$2$3$5$2 _fcksavedurl=$2$3$5$2' ) ;
+	
+	return html ;
+}
+
+// Saves event attributes (like onclick) so they don't get executed while
+// editing.
+FCK.ProtectEvents = function( html )
+{
+	return html.replace( FCKRegexLib.TagsWithEvent, _FCK_ProtectEvents_ReplaceTags ) ;
+}
+
+// Replace all events attributes (like onclick).
+function _FCK_ProtectEvents_ReplaceTags( tagMatch )
+{
+	return tagMatch.replace( FCKRegexLib.EventAttributes, _FCK_ProtectEvents_ReplaceEvents ) ;
+}
+
+// Replace an event attribute with its respective __fckprotectedatt attribute.
+// The original event markup will be encoded and saved as the value of the new
+// attribute.
+function _FCK_ProtectEvents_ReplaceEvents( eventMatch, attName )
+{
+	return ' ' + attName + '_fckprotectedatt="' + eventMatch.ReplaceAll( [/&/g,/'/g,/"/g,/=/g,/</g,/>/g,/\r/g,/\n/g], ['&apos;','&#39;','&quot;','&#61;','&lt;','&gt;','&#10;','&#13;'] ) + '"' ;
+}
+
+FCK.ProtectEventsRestore = function( html )
+{
+	return html.replace( FCKRegexLib.ProtectedEvents, _FCK_ProtectEvents_RestoreEvents ) ;
+}
+
+function _FCK_ProtectEvents_RestoreEvents( match, encodedOriginal )
+{
+	return encodedOriginal.ReplaceAll( [/&#39;/g,/&quot;/g,/&#61;/g,/&lt;/g,/&gt;/g,/&#10;/g,/&#13;/g,/&apos;/g], ["'",'"','=','<','>','\r','\n','&'] ) ;
+}
+
+FCK.IsDirty = function()
+{
+	return ( FCK_StartupValue != FCK.EditorDocument.body.innerHTML ) ;
+}
+
+FCK.ResetIsDirty = function()
+{
+	if ( FCK.EditorDocument.body )
+		FCK_StartupValue = FCK.EditorDocument.body.innerHTML ;
+}
+
+FCK.SetHTML = function( html )
+{
+	this.EditingArea.Mode = FCK.EditMode ;
+
+	if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG )
+	{	
+		html = FCKConfig.ProtectedSource.Protect( html ) ;
+		html = FCK.ProtectEvents( html ) ;
+		html = FCK.ProtectUrls( html ) ;
+
+		// Firefox can't handle correctly the editing of the STRONG and EM tags. 
+		// We must replace them with B and I.
+		if ( FCKBrowserInfo.IsGecko )
+		{
+			html = html.replace( FCKRegexLib.StrongOpener, '<b$1' ) ;
+			html = html.replace( FCKRegexLib.StrongCloser, '<\/b>' ) ;
+			html = html.replace( FCKRegexLib.EmOpener, '<i$1' ) ;
+			html = html.replace( FCKRegexLib.EmCloser, '<\/i>' ) ;
+		}
+		else if ( FCKBrowserInfo.IsIE )
+		{
+			// IE doesn't support <abbr> and it breaks it. Let's protect it.
+			html = html.replace( FCKRegexLib.AbbrOpener, '<FCK:abbr$1' ) ;
+			html = html.replace( FCKRegexLib.AbbrCloser, '<\/FCK:abbr>' ) ;
+		}
+
+		var sHtml = '' ;
+
+		if ( FCKConfig.FullPage )
+		{
+			// The HTML must be fixed if the <head> is not available.
+			if ( !FCKRegexLib.HeadOpener.test( html ) )
+			{
+				// Check if the <html> is available.
+				if ( !FCKRegexLib.HtmlOpener.test( html ) )
+					html = '<html dir="' + FCKConfig.ContentLangDirection + '">' + html + '</html>' ;
+				
+				// Add the <head>.
+				html = html.replace( FCKRegexLib.HtmlOpener, '$&<head></head>' ) ;
+			}
+			
+			// Save the DOCTYPE.
+			FCK.DocTypeDeclaration = html.match( FCKRegexLib.DocTypeTag ) ;
+			
+			if ( FCKBrowserInfo.IsIE )
+				sHtml = FCK._GetBehaviorsStyle() ;
+			else if ( FCKConfig.ShowBorders ) 
+				sHtml = '<link href="' + FCKConfig.FullBasePath + 'css/fck_showtableborders_gecko.css" rel="stylesheet" type="text/css" _fcktemp="true" />' ;
+
+			sHtml += '<link href="' + FCKConfig.FullBasePath + 'css/fck_internal.css' + '" rel="stylesheet" type="text/css" _fcktemp="true" />' ;
+
+			sHtml = html.replace( FCKRegexLib.HeadCloser, sHtml + '$&' ) ;
+
+			// Insert the base tag (FCKConfig.BaseHref), if not exists in the source.
+			if ( FCK.TempBaseTag.length > 0 && !FCKRegexLib.HasBaseTag.test( html ) )
+				sHtml = sHtml.replace( FCKRegexLib.HeadOpener, '$&' + FCK.TempBaseTag ) ;
+		}
+		else
+		{
+			sHtml =
+				FCKConfig.DocType +
+				'<html dir="' + FCKConfig.ContentLangDirection + '"' ;
+			
+			// On IE, if you are use a DOCTYPE differenft of HTML 4 (like
+			// XHTML), you must force the vertical scroll to show, otherwise
+			// the horizontal one may appear when the page needs vertical scrolling.
+			if ( FCKBrowserInfo.IsIE && !FCKRegexLib.Html4DocType.test( FCKConfig.DocType ) )
+				sHtml += ' style="overflow-y: scroll"' ;
+			
+			sHtml +=
+				'><head><title></title>' +
+				this._GetEditorAreaStyleTags() +
+				'<link href="' + FCKConfig.FullBasePath + 'css/fck_internal.css' + '" rel="stylesheet" type="text/css" _fcktemp="true" />' ;
+
+			if ( FCKBrowserInfo.IsIE )
+				sHtml += FCK._GetBehaviorsStyle() ;
+			else if ( FCKConfig.ShowBorders ) 
+				sHtml += '<link href="' + FCKConfig.FullBasePath + 'css/fck_showtableborders_gecko.css" rel="stylesheet" type="text/css" _fcktemp="true" />' ;
+
+			sHtml += FCK.TempBaseTag ;
+			sHtml += '</head><body>' ;
+			
+			if ( FCKBrowserInfo.IsGecko && ( html.length == 0 || FCKRegexLib.EmptyParagraph.test( html ) ) )
+				sHtml += GECKO_BOGUS ;
+			else
+				sHtml += html ;
+			
+			sHtml += '</body></html>' ;
+		}
+
+		this.EditingArea.OnLoad = FCK_EditingArea_OnLoad ;
+		this.EditingArea.Start( sHtml ) ;
+	}
+	else
+	{
+		this.EditingArea.OnLoad = null ;
+		this.EditingArea.Start( html ) ;
+		
+		// Enables the context menu in the textarea.
+		this.EditingArea.Textarea._FCKShowContextMenu = true ;
+	}
+
+	if ( FCKBrowserInfo.IsGecko )
+		window.onresize() ;
+}
+
+function FCK_EditingArea_OnLoad()
+{
+	// Get the editor's window and document (DOM)
+	FCK.EditorWindow	= FCK.EditingArea.Window ;
+	FCK.EditorDocument	= FCK.EditingArea.Document ;
+
+	FCK.InitializeBehaviors() ;
+
+	FCK.OnAfterSetHTML() ;
+
+	// Check if it is not a startup call, otherwise complete the startup.
+	if ( FCK.Status != FCK_STATUS_NOTLOADED )
+		return ;
+
+	// Save the startup value for the "IsDirty()" check.
+	FCK.ResetIsDirty() ;
+
+	// Attach the editor to the form onsubmit event
+	FCKTools.AttachToLinkedFieldFormSubmit( FCK.UpdateLinkedField ) ;
+
+	FCK.SetStatus( FCK_STATUS_ACTIVE ) ;
+}
+
+FCK._GetEditorAreaStyleTags = function()
+{
+	var sTags = '' ;
+	var aCSSs = FCKConfig.EditorAreaCSS ;
+	
+	for ( var i = 0 ; i < aCSSs.length ; i++ )
+		sTags += '<link href="' + aCSSs[i] + '" rel="stylesheet" type="text/css" />' ;
+	
+	return sTags ;
+}
+
+// # Focus Manager: Manages the focus in the editor.
+var FCKFocusManager = FCK.FocusManager = new Object() ;
+FCKFocusManager.IsLocked = false ;
+FCK.HasFocus = false ;
+
+FCKFocusManager.AddWindow = function( win, sendToEditingArea )
+{
+	var oTarget ;
+	
+	if ( FCKBrowserInfo.IsIE )
+		oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ;
+	else
+		oTarget = win.document ;
+	
+	FCKTools.AddEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ;
+	FCKTools.AddEventListener( oTarget, 'focus', sendToEditingArea ? FCKFocusManager_Win_OnFocus_Area : FCKFocusManager_Win_OnFocus ) ;
+}
+
+FCKFocusManager.RemoveWindow = function( win )
+{
+	if ( FCKBrowserInfo.IsIE )
+		oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ;
+	else
+		oTarget = win.document ;
+
+	FCKTools.RemoveEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ;
+	FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus_Area ) ;
+	FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus ) ;
+}
+
+FCKFocusManager.Lock = function()
+{
+	this.IsLocked = true ;
+}
+
+FCKFocusManager.Unlock = function()
+{
+	if ( this._HasPendingBlur )
+		FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ;
+		
+	this.IsLocked = false ;
+}
+
+FCKFocusManager._ResetTimer = function()
+{
+	this._HasPendingBlur = false ;
+
+	if ( this._Timer )
+	{
+		window.clearTimeout( this._Timer ) ;
+		delete this._Timer ; 
+	}
+}
+
+function FCKFocusManager_Win_OnBlur()
+{
+	if ( typeof(FCK) != 'undefined' && FCK.HasFocus )
+	{
+		FCKFocusManager._ResetTimer() ;
+		FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ;
+	}
+}
+
+function FCKFocusManager_FireOnBlur()
+{
+	if ( FCKFocusManager.IsLocked )
+		FCKFocusManager._HasPendingBlur = true ;
+	else
+	{
+		FCK.HasFocus = false ;
+		FCK.Events.FireEvent( "OnBlur" ) ;
+	}
+}
+
+function FCKFocusManager_Win_OnFocus_Area()
+{
+	FCKFocusManager_Win_OnFocus() ;
+	FCK.Focus() ;
+}
+
+function FCKFocusManager_Win_OnFocus()
+{
+	FCKFocusManager._ResetTimer() ;
+
+	if ( !FCK.HasFocus && !FCKFocusManager.IsLocked )
+	{
+		FCK.HasFocus = true ;
+		FCK.Events.FireEvent( "OnFocus" ) ;
+	}
+}

stud/FCKeditor/editor/_source/internals/fck_1_gecko.js

@@ -0,0 +1,112 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_1_gecko.js
+ * 	This is the first part of the "FCK" object creation. This is the main
+ * 	object that represents an editor instance.
+ * 	(Gecko specific implementations)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCK.Description = "FCKeditor for Gecko Browsers" ;
+
+FCK.InitializeBehaviors = function()
+{
+	// When calling "SetHTML", the editing area IFRAME gets a fixed height. So we must recaulculate it.
+	Window_OnResize() ;
+
+	FCKFocusManager.AddWindow( this.EditorWindow ) ;
+
+	// Handle pasting operations.
+	var oOnKeyDown = function( e )
+	{
+
+		var bPrevent ;
+
+		if ( e.ctrlKey && !e.shiftKey && !e.altKey )
+		{
+			switch ( e.which ) 
+			{
+				case 66 :	// B
+				case 98 :	// b
+					FCK.ExecuteNamedCommand( 'bold' ) ; bPrevent = true ;
+					break;
+				case 105 :	// i
+				case 73 :	// I
+					FCK.ExecuteNamedCommand( 'italic' ) ; bPrevent = true ;
+					break;
+				case 117 :	// u
+				case 85 :	// U
+					FCK.ExecuteNamedCommand( 'underline' ) ; bPrevent = true ;
+					break;
+				case 86 :	// V
+				case 118 :	// v
+					bPrevent = ( FCK.Status != FCK_STATUS_COMPLETE || !FCK.Events.FireEvent( "OnPaste" ) ) ;
+					break ;
+			}
+		}
+		else if ( e.shiftKey && !e.ctrlKey && !e.altKey && e.keyCode == 45 )	// SHIFT + <INS>
+			bPrevent = ( FCK.Status != FCK_STATUS_COMPLETE || !FCK.Events.FireEvent( "OnPaste" ) ) ;
+		
+		if ( bPrevent ) 
+		{
+			e.preventDefault() ;
+			e.stopPropagation() ;
+		}
+	}
+	this.EditorDocument.addEventListener( 'keypress', oOnKeyDown, true ) ;
+
+	this.ExecOnSelectionChange = function()
+	{
+		FCK.Events.FireEvent( "OnSelectionChange" ) ;
+	}
+
+	this.ExecOnSelectionChangeTimer = function()
+	{
+		if ( FCK.LastOnChangeTimer )
+			window.clearTimeout( FCK.LastOnChangeTimer ) ;
+
+		FCK.LastOnChangeTimer = window.setTimeout( FCK.ExecOnSelectionChange, 100 ) ;
+	}
+
+	this.EditorDocument.addEventListener( 'mouseup', this.ExecOnSelectionChange, false ) ;
+
+	// On Gecko, firing the "OnSelectionChange" event on every key press started to be too much
+	// slow. So, a timer has been implemented to solve performance issues when tipying to quickly.
+	this.EditorDocument.addEventListener( 'keyup', this.ExecOnSelectionChangeTimer, false ) ;
+
+	this._DblClickListener = function( e )
+	{
+		FCK.OnDoubleClick( e.target ) ;
+		e.stopPropagation() ;
+	}
+	this.EditorDocument.addEventListener( 'dblclick', this._DblClickListener, true ) ;
+
+	// Reset the context menu.
+	FCK.ContextMenu._InnerContextMenu.SetMouseClickWindow( FCK.EditorWindow ) ;
+	FCK.ContextMenu._InnerContextMenu.AttachToElement( FCK.EditorDocument ) ;
+}
+
+FCK.MakeEditable = function()
+{
+	this.EditingArea.MakeEditable() ;
+}
+
+// Disable the context menu in the editor (outside the editing area).
+function Document_OnContextMenu( e )
+{
+	if ( !e.target._FCKShowContextMenu )
+		e.preventDefault() ;
+}
+document.oncontextmenu = Document_OnContextMenu ;

stud/FCKeditor/editor/_source/internals/fck_1_ie.js

@@ -0,0 +1,294 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_1_ie.js
+ * 	This is the first part of the "FCK" object creation. This is the main
+ * 	object that represents an editor instance.
+ * 	(IE specific implementations)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCK.Description = "FCKeditor for Internet Explorer 5.5+" ;
+
+FCK._GetBehaviorsStyle = function()
+{
+	if ( !FCK._BehaviorsStyle )
+	{
+		var sBasePath = FCKConfig.FullBasePath ;
+		var sTableBehavior = '' ;
+		var sStyle ;
+		
+		// The behaviors should be pointed using the FullBasePath to avoid security
+		// errors when using a differente BaseHref.
+		sStyle =
+			'<style type="text/css" _fcktemp="true">' +
+			'INPUT { behavior: url(' + sBasePath + 'css/behaviors/hiddenfield.htc) ; }' ;
+
+		if ( FCKConfig.ShowBorders )
+			sTableBehavior = 'url(' + sBasePath + 'css/behaviors/showtableborders.htc)' ;
+
+		// Disable resize handlers.
+		sStyle += 'INPUT,TEXTAREA,SELECT,.FCK__Anchor,.FCK__PageBreak' ;
+
+		if ( FCKConfig.DisableObjectResizing )
+		{
+			sStyle += ',IMG' ;
+			sTableBehavior += ' url(' + sBasePath + 'css/behaviors/disablehandles.htc)' ;
+		}
+		
+		sStyle += ' { behavior: url(' + sBasePath + 'css/behaviors/disablehandles.htc) ; }' ;
+
+		if ( sTableBehavior.length > 0 )
+			sStyle += 'TABLE { behavior: ' + sTableBehavior + ' ; }' ;
+
+		sStyle += '</style>' ;
+		FCK._BehaviorsStyle = sStyle ;
+	}
+	
+	return FCK._BehaviorsStyle ;
+}
+
+function Doc_OnMouseUp()
+{
+	if ( FCK.EditorWindow.event.srcElement.tagName == 'HTML' )
+	{
+		FCK.Focus() ;
+		FCK.EditorWindow.event.cancelBubble	= true ;
+		FCK.EditorWindow.event.returnValue	= false ;
+	}
+}
+
+function Doc_OnPaste()
+{
+	if ( FCK.Status == FCK_STATUS_COMPLETE )
+		FCK.Events.FireEvent( "OnPaste" ) ;
+
+	return false ;
+}
+
+/*
+function Doc_OnContextMenu()
+{
+	var e = FCK.EditorWindow.event ;
+	
+	FCK.ShowContextMenu( e.screenX, e.screenY ) ;
+	return false ;
+}
+*/
+
+function Doc_OnKeyDown()
+{
+	var e = FCK.EditorWindow.event ;
+
+
+	switch ( e.keyCode )
+	{
+		case 13 :	// ENTER
+			if ( FCKConfig.UseBROnCarriageReturn && !(e.ctrlKey || e.altKey || e.shiftKey) )
+			{
+				Doc_OnKeyDownUndo() ;
+				
+				// We must ignore it if we are inside a List.
+				if ( FCK.EditorDocument.queryCommandState( 'InsertOrderedList' ) || FCK.EditorDocument.queryCommandState( 'InsertUnorderedList' ) )
+					return true ;
+
+				// Insert the <BR> (The &nbsp; must be also inserted to make it work)
+				FCK.InsertHtml( '<br>&nbsp;' ) ;
+
+				// Remove the &nbsp;
+				var oRange = FCK.EditorDocument.selection.createRange() ;
+				oRange.moveStart( 'character', -1 ) ;
+				oRange.select() ;
+				FCK.EditorDocument.selection.clear() ;
+
+				return false ;
+			}
+			break ;
+		
+		case 8 :	// BACKSPACE
+			// We must delete a control selection by code and cancels the 
+			// keystroke, otherwise IE will execute the browser's "back" button.
+			if ( FCKSelection.GetType() == 'Control' )
+			{
+				FCKSelection.Delete() ;
+				return false ;
+			}
+			break ;
+		
+		case 9 :	// TAB
+			if ( FCKConfig.TabSpaces > 0 && !(e.ctrlKey || e.altKey || e.shiftKey) )
+			{
+				Doc_OnKeyDownUndo() ;
+				
+				FCK.InsertHtml( window.FCKTabHTML ) ;
+				return false ;
+			}
+			break ;
+		case 90 :	// Z
+			if ( e.ctrlKey && !(e.altKey || e.shiftKey) )
+			{
+				FCKUndo.Undo() ;
+				return false ;
+			}
+			break ;
+		case 89 :	// Y
+			if ( e.ctrlKey && !(e.altKey || e.shiftKey) )
+			{
+				FCKUndo.Redo() ;
+				return false ;
+			}
+			break ;
+	}
+	
+	if ( !( e.keyCode >=16 && e.keyCode <= 18 ) )
+		Doc_OnKeyDownUndo() ;
+	return true ;
+}
+
+function Doc_OnKeyDownUndo()
+{
+	if ( !FCKUndo.Typing )
+	{
+		FCKUndo.SaveUndoStep() ;
+		FCKUndo.Typing = true ;
+		FCK.Events.FireEvent( "OnSelectionChange" ) ;
+	}
+	
+	FCKUndo.TypesCount++ ;
+
+	if ( FCKUndo.TypesCount > FCKUndo.MaxTypes )
+	{
+		FCKUndo.TypesCount = 0 ;
+		FCKUndo.SaveUndoStep() ;
+	}
+}
+
+function Doc_OnDblClick()
+{
+	FCK.OnDoubleClick( FCK.EditorWindow.event.srcElement ) ;
+	FCK.EditorWindow.event.cancelBubble = true ;
+}
+
+function Doc_OnSelectionChange()
+{
+	FCK.Events.FireEvent( "OnSelectionChange" ) ;
+}
+
+FCK.InitializeBehaviors = function( dontReturn )
+{
+	// Set the focus to the editable area when clicking in the document area.
+	// TODO: The cursor must be positioned at the end.
+	this.EditorDocument.attachEvent( 'onmouseup', Doc_OnMouseUp ) ;
+
+	// Intercept pasting operations
+	this.EditorDocument.body.attachEvent( 'onpaste', Doc_OnPaste ) ;
+
+	// Reset the context menu.
+	FCK.ContextMenu._InnerContextMenu.AttachToElement( FCK.EditorDocument.body ) ;
+
+	// Build the "TAB" key replacement (if necessary).
+	if ( FCKConfig.TabSpaces > 0 )
+	{
+		window.FCKTabHTML = '' ;
+		for ( i = 0 ; i < FCKConfig.TabSpaces ; i++ )
+			window.FCKTabHTML += "&nbsp;" ;
+	}
+	this.EditorDocument.attachEvent("onkeydown", Doc_OnKeyDown ) ;
+
+	this.EditorDocument.attachEvent("ondblclick", Doc_OnDblClick ) ;
+
+	// Catch cursor movements
+	this.EditorDocument.attachEvent("onselectionchange", Doc_OnSelectionChange ) ;
+
+	//Enable editing
+//	this.EditorDocument.body.contentEditable = true ;
+}
+
+FCK.InsertHtml = function( html )
+{
+	html = FCKConfig.ProtectedSource.Protect( html ) ;
+	html = FCK.ProtectUrls( html ) ;
+
+	FCK.Focus() ;
+
+	FCKUndo.SaveUndoStep() ;
+
+	// Gets the actual selection.
+	var oSel = FCK.EditorDocument.selection ;
+
+	// Deletes the actual selection contents.
+	if ( oSel.type.toLowerCase() == 'control' )
+		oSel.clear() ;
+
+	// Insert the HTML.
+	oSel.createRange().pasteHTML( html ) ;
+	
+	FCKDocumentProcessor.Process( FCK.EditorDocument ) ;
+}
+
+FCK.SetInnerHtml = function( html )		// IE Only
+{
+	var oDoc = FCK.EditorDocument ;
+	// Using the following trick, any comment in the begining of the HTML will
+	// be preserved.
+	oDoc.body.innerHTML = '<div id="__fakeFCKRemove__">&nbsp;</div>' + html ;
+	oDoc.getElementById('__fakeFCKRemove__').removeNode( true ) ;
+}
+
+var FCK_PreloadImages_Count = 0 ;
+var FCK_PreloadImages_Images = new Array() ;
+
+function FCK_PreloadImages()
+{
+	// Get the images to preload.
+	var aImages = FCKConfig.PreloadImages || [] ;
+	
+	if ( typeof( aImages ) == 'string' )
+		aImages = aImages.split( ';' ) ;
+
+	// Add the skin icons strip.
+	aImages.push( FCKConfig.SkinPath + 'fck_strip.gif' ) ;
+	
+	FCK_PreloadImages_Count = aImages.length ;
+
+	var aImageElements = new Array() ;
+	
+	for ( var i = 0 ; i < aImages.length ; i++ )
+	{
+		var eImg = document.createElement( 'img' ) ;
+		eImg.onload = eImg.onerror = FCK_PreloadImages_OnImage ;
+		eImg.src = aImages[i] ;
+		
+		FCK_PreloadImages_Images[i] = eImg ;
+	}
+}
+
+function FCK_PreloadImages_OnImage()
+{
+	if ( (--FCK_PreloadImages_Count) == 0 )
+		FCKTools.RunFunction( LoadToolbarSetup ) ;
+}
+
+// Disable the context menu in the editor (outside the editing area).
+function Document_OnContextMenu()
+{
+	return ( event.srcElement._FCKShowContextMenu == true ) ;
+}
+document.oncontextmenu = Document_OnContextMenu ;
+
+function FCK_Cleanup()
+{
+	this.EditorWindow = null ;
+	this.EditorDocument = null ;
+}

stud/FCKeditor/editor/_source/internals/fck_2.js

@@ -0,0 +1,162 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_2.js
+ * 	This is the second part of the "FCK" object creation. This is the main
+ * 	object that represents an editor instance.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// This collection is used by the browser specific implementations to tell
+// wich named commands must be handled separately.
+FCK.RedirectNamedCommands = new Object() ;
+
+FCK.ExecuteNamedCommand = function( commandName, commandParameter, noRedirect )
+{
+	FCKUndo.SaveUndoStep() ;
+
+	if ( !noRedirect && FCK.RedirectNamedCommands[ commandName ] != null )
+		FCK.ExecuteRedirectedNamedCommand( commandName, commandParameter ) ;
+	else
+	{
+		FCK.Focus() ;
+		FCK.EditorDocument.execCommand( commandName, false, commandParameter ) ; 
+		FCK.Events.FireEvent( 'OnSelectionChange' ) ;
+	}
+	
+	FCKUndo.SaveUndoStep() ;
+}
+
+FCK.GetNamedCommandState = function( commandName )
+{
+	try
+	{
+		if ( !FCK.EditorDocument.queryCommandEnabled( commandName ) )
+			return FCK_TRISTATE_DISABLED ;
+		else
+			return FCK.EditorDocument.queryCommandState( commandName ) ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF ;
+	}
+	catch ( e )
+	{
+		return FCK_TRISTATE_OFF ;
+	}
+}
+
+FCK.GetNamedCommandValue = function( commandName )
+{
+	var sValue = '' ;
+	var eState = FCK.GetNamedCommandState( commandName ) ;
+	
+	if ( eState == FCK_TRISTATE_DISABLED ) 
+		return null ;
+	
+	try
+	{
+		sValue = this.EditorDocument.queryCommandValue( commandName ) ;
+	}
+	catch(e) {}
+	
+	return sValue ? sValue : '' ;
+}
+
+FCK.PasteFromWord = function()
+{
+	FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word' ) ;
+}
+
+FCK.Preview = function()
+{
+	var iWidth	= FCKConfig.ScreenWidth * 0.8 ;
+	var iHeight	= FCKConfig.ScreenHeight * 0.7 ;
+	var iLeft	= ( FCKConfig.ScreenWidth - iWidth ) / 2 ;
+	var oWindow = window.open( '', null, 'toolbar=yes,location=no,status=yes,menubar=yes,scrollbars=yes,resizable=yes,width=' + iWidth + ',height=' + iHeight + ',left=' + iLeft ) ;
+	
+	var sHTML ;
+	
+	if ( FCKConfig.FullPage )
+	{
+		if ( FCK.TempBaseTag.length > 0 )
+			sHTML = FCK.TempBaseTag + FCK.GetXHTML() ;
+		else
+			sHTML = FCK.GetXHTML() ;
+	}
+	else
+	{
+		sHTML = 
+			FCKConfig.DocType +
+			'<html dir="' + FCKConfig.ContentLangDirection + '">' +
+			'<head>' +
+			FCK.TempBaseTag +
+			'<title>' + FCKLang.Preview + '</title>' +
+			FCK._GetEditorAreaStyleTags() +
+			'</head><body>' + 
+			FCK.GetXHTML() + 
+			'</body></html>' ;
+	}
+	
+	oWindow.document.write( sHTML );
+	oWindow.document.close();
+}
+
+FCK.SwitchEditMode = function( noUndo )
+{
+	var bIsWysiwyg = ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) ;
+	var sHtml ;
+	
+	// Update the HTML in the view output to show.
+	if ( bIsWysiwyg )
+	{
+		if ( !noUndo && FCKBrowserInfo.IsIE )
+			FCKUndo.SaveUndoStep() ;
+
+		sHtml = FCK.GetXHTML( FCKConfig.FormatSource ) ;
+	}
+	else
+		sHtml = this.EditingArea.Textarea.value ;
+
+	FCK.EditMode = bIsWysiwyg ? FCK_EDITMODE_SOURCE : FCK_EDITMODE_WYSIWYG ;
+
+	FCK.SetHTML( sHtml ) ;
+
+	// Set the Focus.
+	FCK.Focus() ;
+
+	// Update the toolbar (Running it directly causes IE to fail).
+	FCKTools.RunFunction( FCK.ToolbarSet.RefreshModeState, FCK.ToolbarSet ) ;
+}
+
+FCK.CreateElement = function( tag )
+{
+	var e = FCK.EditorDocument.createElement( tag ) ;
+	return FCK.InsertElementAndGetIt( e ) ;
+}
+
+FCK.InsertElementAndGetIt = function( e )
+{
+	e.setAttribute( 'FCKTempLabel', 'true' ) ;
+	
+	this.InsertElement( e ) ;
+	
+	var aEls = FCK.EditorDocument.getElementsByTagName( e.tagName ) ;
+	
+	for ( var i = 0 ; i < aEls.length ; i++ )
+	{
+		if ( aEls[i].getAttribute( 'FCKTempLabel' ) )
+		{
+			aEls[i].removeAttribute( 'FCKTempLabel' ) ;
+			return aEls[i] ;
+		}
+	}
+	return null ;
+}

stud/FCKeditor/editor/_source/internals/fck_2_gecko.js

@@ -0,0 +1,196 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_2_gecko.js
+ * 	This is the second part of the "FCK" object creation. This is the main
+ * 	object that represents an editor instance.
+ * 	(Gecko specific implementations)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// GetNamedCommandState overload for Gecko.
+FCK._BaseGetNamedCommandState = FCK.GetNamedCommandState ;
+FCK.GetNamedCommandState = function( commandName )
+{
+	switch ( commandName )
+	{
+		case 'Unlink' :
+			return FCKSelection.HasAncestorNode('A') ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+		default :
+			return FCK._BaseGetNamedCommandState( commandName ) ;
+	}
+}
+
+// Named commands to be handled by this browsers specific implementation.
+FCK.RedirectNamedCommands = 
+{
+	Print	: true,
+	Paste	: true,
+	Cut		: true,
+	Copy	: true
+}
+
+// ExecuteNamedCommand overload for Gecko.
+FCK.ExecuteRedirectedNamedCommand = function( commandName, commandParameter )
+{
+	switch ( commandName )
+	{
+		case 'Print' :
+			FCK.EditorWindow.print() ;
+			break ;
+		case 'Paste' :
+			try			{ if ( FCK.Paste() ) FCK.ExecuteNamedCommand( 'Paste', null, true ) ; }
+			catch (e)	{ alert(FCKLang.PasteErrorPaste) ; }
+			break ;
+		case 'Cut' :
+			try			{ FCK.ExecuteNamedCommand( 'Cut', null, true ) ; }
+			catch (e)	{ alert(FCKLang.PasteErrorCut) ; }
+			break ;
+		case 'Copy' :
+			try			{ FCK.ExecuteNamedCommand( 'Copy', null, true ) ; }
+			catch (e)	{ alert(FCKLang.PasteErrorCopy) ; }
+			break ;			
+		default :
+			FCK.ExecuteNamedCommand( commandName, commandParameter ) ;
+	}
+}
+
+FCK.AttachToOnSelectionChange = function( functionPointer )
+{
+	this.Events.AttachEvent( 'OnSelectionChange', functionPointer ) ;
+}
+
+FCK.Paste = function()
+{
+	if ( FCKConfig.ForcePasteAsPlainText )
+	{
+		FCK.PasteAsPlainText() ;	
+		return false ;
+	}
+/* For now, the AutoDetectPasteFromWord feature is IE only.
+	else if ( FCKConfig.AutoDetectPasteFromWord )
+	{
+		var sHTML = FCK.GetClipboardHTML() ;
+		var re = /<\w[^>]* class="?MsoNormal"?/gi ;
+		if ( re.test( sHTML ) )
+		{
+			if ( confirm( FCKLang["PasteWordConfirm"] ) )
+			{
+				FCK.PasteFromWord() ;
+				return false ;
+			}
+		}
+	}
+*/
+	else
+		return true ;
+}
+
+//**
+// FCK.InsertHtml: Inserts HTML at the current cursor location. Deletes the
+// selected content if any.
+FCK.InsertHtml = function( html )
+{
+	html = FCKConfig.ProtectedSource.Protect( html ) ;
+	html = FCK.ProtectUrls( html ) ;
+
+	// Delete the actual selection.
+	var oSel = FCKSelection.Delete() ;
+	
+	// Get the first available range.
+	var oRange = oSel.getRangeAt(0) ;
+	
+	// Create a fragment with the input HTML.
+	var oFragment = oRange.createContextualFragment( html ) ;
+	
+	// Get the last available node.
+	var oLastNode = oFragment.lastChild ;
+
+	// Insert the fragment in the range.
+	oRange.insertNode(oFragment) ;
+	
+	// Set the cursor after the inserted fragment.
+	FCKSelection.SelectNode( oLastNode ) ;
+	FCKSelection.Collapse( false ) ;
+	
+	this.Focus() ;
+}
+
+FCK.InsertElement = function( element )
+{
+	// Deletes the actual selection.
+	var oSel = FCKSelection.Delete() ;
+	
+	// Gets the first available range.
+	var oRange = oSel.getRangeAt(0) ;
+	
+	// Inserts the element in the range.
+	oRange.insertNode( element ) ;
+	
+	// Set the cursor after the inserted fragment.
+	FCKSelection.SelectNode( element ) ;
+	FCKSelection.Collapse( false ) ;
+
+	this.Focus() ;
+}
+
+FCK.PasteAsPlainText = function()
+{
+	// TODO: Implement the "Paste as Plain Text" code.
+	
+	FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteAsText, 'dialog/fck_paste.html', 400, 330, 'PlainText' ) ;
+	
+/*
+	var sText = FCKTools.HTMLEncode( clipboardData.getData("Text") ) ;
+	sText = sText.replace( /\n/g, '<BR>' ) ;
+	this.InsertHtml( sText ) ;	
+*/
+}
+/*
+FCK.PasteFromWord = function()
+{
+	// TODO: Implement the "Paste as Plain Text" code.
+	
+	FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word' ) ;
+
+//	FCK.CleanAndPaste( FCK.GetClipboardHTML() ) ;
+}
+*/
+FCK.GetClipboardHTML = function()
+{
+	return '' ;
+}
+
+FCK.CreateLink = function( url )
+{	
+	FCK.ExecuteNamedCommand( 'Unlink' ) ;
+	
+	if ( url.length > 0 )
+	{
+		// Generate a temporary name for the link.
+		var sTempUrl = 'javascript:void(0);/*' + ( new Date().getTime() ) + '*/' ;
+		
+		// Use the internal "CreateLink" command to create the link.
+		FCK.ExecuteNamedCommand( 'CreateLink', sTempUrl ) ;
+
+		// Retrieve the just created link using XPath.
+		var oLink = document.evaluate("//a[@href='" + sTempUrl + "']", this.EditorDocument.body, null, 9, null).singleNodeValue ;
+		
+		if ( oLink )
+		{
+			oLink.href = url ;
+			return oLink ;
+		}
+	}
+}

stud/FCKeditor/editor/_source/internals/fck_2_ie.js

@@ -0,0 +1,164 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_2_ie.js
+ * 	This is the second part of the "FCK" object creation. This is the main
+ * 	object that represents an editor instance.
+ * 	(IE specific implementations)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+/*
+if ( FCKConfig.UseBROnCarriageReturn ) 
+{
+	// Named commands to be handled by this browsers specific implementation.
+	FCK.RedirectNamedCommands = 
+	{
+		InsertOrderedList	: true,
+		InsertUnorderedList	: true
+	}
+
+	FCK.ExecuteRedirectedNamedCommand = function( commandName, commandParameter )
+	{
+		if ( commandName == 'InsertOrderedList' || commandName == 'InsertUnorderedList' )
+		{
+			if ( !(FCK.EditorDocument.queryCommandState( 'InsertOrderedList' ) || FCK.EditorDocument.queryCommandState( 'InsertUnorderedList' )) )
+			{
+			}				
+		}
+
+		FCK.ExecuteNamedCommand( commandName, commandParameter ) ;
+	}
+}
+*/
+
+FCK.Paste = function()
+{
+	if ( FCKConfig.ForcePasteAsPlainText )
+	{
+		FCK.PasteAsPlainText() ;	
+		return ;
+	}
+
+	var sHTML = FCK.GetClipboardHTML() ;
+
+	if ( FCKConfig.AutoDetectPasteFromWord )
+	{
+		var re = /<\w[^>]*(( class="?MsoNormal"?)|(="mso-))/gi ;
+		if ( re.test( sHTML ) )
+		{
+			if ( confirm( FCKLang["PasteWordConfirm"] ) )
+			{
+				FCK.PasteFromWord() ;
+				return ;
+			}
+		}
+	}
+
+	FCK.InsertHtml( sHTML ) ;	
+}
+
+FCK.PasteAsPlainText = function()
+{
+	// Get the data available in the clipboard and encodes it in HTML.
+	var sText = FCKTools.HTMLEncode( clipboardData.getData("Text") ) ;
+
+	// Replace the carriage returns with <BR>
+	sText = sText.replace( /\n/g, '<BR>' ) ;
+	
+	// Insert the resulting data in the editor.
+	this.InsertHtml( sText ) ;	
+}
+/*
+FCK.PasteFromWord = function()
+{
+	FCK.CleanAndPaste( FCK.GetClipboardHTML() ) ;
+}
+*/
+FCK.InsertElement = function( element )
+{
+	FCK.InsertHtml( element.outerHTML ) ;
+}
+
+FCK.GetClipboardHTML = function()
+{
+	var oDiv = document.getElementById( '___FCKHiddenDiv' ) ;
+	
+	if ( !oDiv )
+	{
+		var oDiv = document.createElement( 'DIV' ) ;
+		oDiv.id = '___FCKHiddenDiv' ;
+		oDiv.style.visibility	= 'hidden' ;
+		oDiv.style.overflow		= 'hidden' ;
+		oDiv.style.position		= 'absolute' ;
+		oDiv.style.width		= 1 ;
+		oDiv.style.height		= 1 ;
+	
+		document.body.appendChild( oDiv ) ;
+	}
+	
+	oDiv.innerHTML = '' ;
+	
+	var oTextRange = document.body.createTextRange() ;
+	oTextRange.moveToElementText( oDiv ) ;
+	oTextRange.execCommand( 'Paste' ) ;
+	
+	var sData = oDiv.innerHTML ;
+	oDiv.innerHTML = '' ;
+	
+	return sData ;
+}
+
+FCK.AttachToOnSelectionChange = function( functionPointer )
+{
+	this.Events.AttachEvent( 'OnSelectionChange', functionPointer ) ;
+}
+
+/*
+FCK.AttachToOnSelectionChange = function( functionPointer )
+{
+	FCK.EditorDocument.attachEvent( 'onselectionchange', functionPointer ) ;
+}
+*/
+
+FCK.CreateLink = function( url )
+{
+	// Remove any existing link in the selection.
+	FCK.ExecuteNamedCommand( 'Unlink' ) ;
+
+	if ( url.length > 0 )
+	{
+		// Generate a temporary name for the link.
+		var sTempUrl = 'javascript:void(0);/*' + ( new Date().getTime() ) + '*/' ;
+		
+		// Use the internal "CreateLink" command to create the link.
+		FCK.ExecuteNamedCommand( 'CreateLink', sTempUrl ) ;
+
+		// Look for the just create link.
+		var oLinks = this.EditorDocument.links ;
+
+		for ( i = 0 ; i < oLinks.length ; i++ )
+		{
+			var oLink = oLinks[i] ;
+			
+			if ( oLink.href == sTempUrl )
+			{
+				var sInnerHtml = oLink.innerHTML ;	// Save the innerHTML (IE changes it if it is like an URL).
+				oLink.href = url ;
+				oLink.innerHTML = sInnerHtml ;		// Restore the innerHTML.
+				return oLink ;
+			}
+		}
+	}
+}

stud/FCKeditor/editor/_source/internals/fck_contextmenu.js

@@ -0,0 +1,290 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fck_contextmenu.js
+ * 	Defines the FCK.ContextMenu object that is responsible for all
+ * 	Context Menu operations in the editing area.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCK.ContextMenu = new Object() ;
+FCK.ContextMenu.Listeners = new Array() ;
+
+FCK.ContextMenu.RegisterListener = function( listener )
+{
+	if ( listener )
+		this.Listeners.push( listener ) ;
+}
+
+function FCK_ContextMenu_Init()
+{
+	var oInnerContextMenu = FCK.ContextMenu._InnerContextMenu = new FCKContextMenu( FCKBrowserInfo.IsIE ? window : window.parent, FCK.EditorWindow, FCKLang.Dir ) ;
+	oInnerContextMenu.OnBeforeOpen	= FCK_ContextMenu_OnBeforeOpen ;
+	oInnerContextMenu.OnItemClick	= FCK_ContextMenu_OnItemClick ;
+
+	// Get the registering function.
+	var oMenu = FCK.ContextMenu ;
+
+	// Register all configured context menu listeners.
+	for ( var i = 0 ; i < FCKConfig.ContextMenu.length ; i++ )
+		oMenu.RegisterListener( FCK_ContextMenu_GetListener( FCKConfig.ContextMenu[i] ) ) ;
+}
+
+function FCK_ContextMenu_GetListener( listenerName )
+{
+	switch ( listenerName )
+	{
+		case 'Generic' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				menu.AddItem( 'Cut'		, FCKLang.Cut	, 7, FCKCommands.GetCommand( 'Cut' ).GetState() == FCK_TRISTATE_DISABLED ) ;
+				menu.AddItem( 'Copy'	, FCKLang.Copy	, 8, FCKCommands.GetCommand( 'Copy' ).GetState() == FCK_TRISTATE_DISABLED ) ;
+				menu.AddItem( 'Paste'	, FCKLang.Paste	, 9, FCKCommands.GetCommand( 'Paste' ).GetState() == FCK_TRISTATE_DISABLED ) ;
+			}} ;
+
+		case 'Table' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				var bIsTable	= ( tagName == 'TABLE' ) ;
+				var bIsCell		= ( !bIsTable && FCKSelection.HasAncestorNode( 'TABLE' ) ) ;
+				
+				if ( bIsCell )
+				{
+					menu.AddSeparator() ;
+					var oItem = menu.AddItem( 'Cell'	, FCKLang.CellCM ) ;
+					oItem.AddItem( 'TableInsertCell'	, FCKLang.InsertCell, 58 ) ;
+					oItem.AddItem( 'TableDeleteCells'	, FCKLang.DeleteCells, 59 ) ;
+					oItem.AddItem( 'TableMergeCells'	, FCKLang.MergeCells, 60 ) ;
+					oItem.AddItem( 'TableSplitCell'		, FCKLang.SplitCell, 61 ) ;
+					oItem.AddSeparator() ;
+					oItem.AddItem( 'TableCellProp'		, FCKLang.CellProperties, 57 ) ;
+
+					menu.AddSeparator() ;
+					oItem = menu.AddItem( 'Row'			, FCKLang.RowCM ) ;
+					oItem.AddItem( 'TableInsertRow'		, FCKLang.InsertRow, 62 ) ;
+					oItem.AddItem( 'TableDeleteRows'	, FCKLang.DeleteRows, 63 ) ;
+					
+					menu.AddSeparator() ;
+					oItem = menu.AddItem( 'Column'		, FCKLang.ColumnCM ) ;
+					oItem.AddItem( 'TableInsertColumn'	, FCKLang.InsertColumn, 64 ) ;
+					oItem.AddItem( 'TableDeleteColumns'	, FCKLang.DeleteColumns, 65 ) ;
+				}
+
+				if ( bIsTable || bIsCell )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'TableDelete'			, FCKLang.TableDelete ) ;
+					menu.AddItem( 'TableProp'			, FCKLang.TableProperties, 39 ) ;
+				}
+			}} ;
+
+		case 'Link' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				var bInsideLink = ( tagName == 'A' || FCKSelection.HasAncestorNode( 'A' ) ) ;
+
+				if ( bInsideLink || FCK.GetNamedCommandState( 'Unlink' ) != FCK_TRISTATE_DISABLED )
+				{
+					menu.AddSeparator() ;
+					if ( bInsideLink )
+						menu.AddItem( 'Link', FCKLang.EditLink		, 34 ) ;
+					menu.AddItem( 'Unlink'	, FCKLang.RemoveLink	, 35 ) ;
+				}
+			}} ;
+
+		case 'Image' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'IMG' && !tag.getAttribute( '_fckfakelement' ) )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Image', FCKLang.ImageProperties, 37 ) ;
+				}
+			}} ;
+
+		case 'Anchor' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'IMG' && tag.getAttribute( '_fckanchor' ) )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Anchor', FCKLang.AnchorProp, 36 ) ;
+				}
+			}} ;
+
+		case 'Flash' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'IMG' && tag.getAttribute( '_fckflash' ) )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Flash', FCKLang.FlashProperties, 38 ) ;
+				}
+			}} ;
+
+		case 'Form' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( FCKSelection.HasAncestorNode('FORM') )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Form', FCKLang.FormProp, 48 ) ;
+				}
+			}} ;
+
+		case 'Checkbox' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'INPUT' && tag.type == 'checkbox' )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Checkbox', FCKLang.CheckboxProp, 49 ) ;
+				}
+			}} ;
+
+		case 'Radio' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'INPUT' && tag.type == 'radio' )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Radio', FCKLang.RadioButtonProp, 50 ) ;
+				}
+			}} ;
+
+		case 'TextField' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'INPUT' && ( tag.type == 'text' || tag.type == 'password' ) )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'TextField', FCKLang.TextFieldProp, 51 ) ;
+				}
+			}} ;
+
+		case 'HiddenField' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'INPUT' && tag.type == 'hidden' )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'HiddenField', FCKLang.HiddenFieldProp, 56 ) ;
+				}
+			}} ;
+
+		case 'ImageButton' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'INPUT' && tag.type == 'image' )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'ImageButton', FCKLang.ImageButtonProp, 55 ) ;
+				}
+			}} ;
+
+		case 'Button' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'INPUT' && ( tag.type == 'button' || tag.type == 'submit' || tag.type == 'reset' ) )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Button', FCKLang.ButtonProp, 54 ) ;
+				}
+			}} ;
+
+		case 'Select' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'SELECT' )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Select', FCKLang.SelectionFieldProp, 53 ) ;
+				}
+			}} ;
+
+		case 'Textarea' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( tagName == 'TEXTAREA' )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'Textarea', FCKLang.TextareaProp, 52 ) ;
+				}
+			}} ;
+
+		case 'BulletedList' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( FCKSelection.HasAncestorNode('UL') )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'BulletedList', FCKLang.BulletedListProp, 27 ) ;
+				}
+			}} ;
+
+		case 'NumberedList' :
+			return {
+			AddItems : function( menu, tag, tagName )
+			{
+				if ( FCKSelection.HasAncestorNode('OL') )
+				{
+					menu.AddSeparator() ;
+					menu.AddItem( 'NumberedList', FCKLang.NumberedListProp, 26 ) ;
+				}
+			}} ;
+	}
+}
+
+function FCK_ContextMenu_OnBeforeOpen()
+{
+	// Update the UI.
+	FCK.Events.FireEvent( "OnSelectionChange" ) ;
+
+  	// Get the actual selected tag (if any).
+	var oTag, sTagName ;
+	
+	if ( oTag = FCKSelection.GetSelectedElement() )
+		sTagName = oTag.tagName ;
+
+	// Cleanup the current menu items.
+	var oMenu = FCK.ContextMenu._InnerContextMenu ;
+	oMenu.RemoveAllItems() ;
+
+	// Loop through the listeners.
+	var aListeners = FCK.ContextMenu.Listeners ;
+	for ( var i = 0 ; i < aListeners.length ; i++ )
+		aListeners[i].AddItems( oMenu, oTag, sTagName ) ;
+}
+
+function FCK_ContextMenu_OnItemClick( item )
+{
+	FCK.Focus() ;
+	FCKCommands.GetCommand( item.Name ).Execute() ;
+}

stud/FCKeditor/editor/_source/internals/fckbrowserinfo.js

@@ -0,0 +1,37 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckbrowserinfo.js
+ * 	Contains browser detection information.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var s = navigator.userAgent.toLowerCase() ;
+
+var FCKBrowserInfo = 
+{
+	IsIE		: s.Contains('msie'),
+	IsIE7		: s.Contains('msie 7'),
+	IsGecko		: s.Contains('gecko/'),
+	IsSafari	: s.Contains('safari'),
+	IsOpera		: s.Contains('opera')
+}
+
+FCKBrowserInfo.IsGeckoLike = FCKBrowserInfo.IsGecko || FCKBrowserInfo.IsSafari || FCKBrowserInfo.IsOpera ;
+
+if ( FCKBrowserInfo.IsGecko )
+{
+	var sGeckoVersion = s.match( /gecko\/(\d+)/ )[1] ;
+	FCKBrowserInfo.IsGecko10 = sGeckoVersion < 20051111 ;	// Actually "10" refers to versions before Firefox 1.5, where Gecko 20051111 has been released.
+}

stud/FCKeditor/editor/_source/internals/fckcodeformatter.js

@@ -0,0 +1,96 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckcodeformatter.js
+ * 	Format the HTML.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKCodeFormatter = new Object() ;
+
+FCKCodeFormatter.Init = function()
+{
+	var oRegex = this.Regex = new Object() ;
+
+	// Regex for line breaks.
+	oRegex.BlocksOpener = /\<(P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TITLE|META|LINK|BASE|SCRIPT|LINK|TD|TH|AREA|OPTION)[^\>]*\>/gi ;
+	oRegex.BlocksCloser = /\<\/(P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TITLE|META|LINK|BASE|SCRIPT|LINK|TD|TH|AREA|OPTION)[^\>]*\>/gi ;
+
+	oRegex.NewLineTags	= /\<(BR|HR)[^\>]*\>/gi ;
+
+	oRegex.MainTags = /\<\/?(HTML|HEAD|BODY|FORM|TABLE|TBODY|THEAD|TR)[^\>]*\>/gi ;
+
+	oRegex.LineSplitter = /\s*\n+\s*/g ;
+
+	// Regex for indentation.
+	oRegex.IncreaseIndent = /^\<(HTML|HEAD|BODY|FORM|TABLE|TBODY|THEAD|TR|UL|OL)[ \/\>]/i ;
+	oRegex.DecreaseIndent = /^\<\/(HTML|HEAD|BODY|FORM|TABLE|TBODY|THEAD|TR|UL|OL)[ \>]/i ;
+	oRegex.FormatIndentatorRemove = new RegExp( '^' + FCKConfig.FormatIndentator ) ;
+
+	oRegex.ProtectedTags = /(<PRE[^>]*>)([\s\S]*?)(<\/PRE>)/gi ;
+}
+
+FCKCodeFormatter._ProtectData = function( outer, opener, data, closer )
+{
+	return opener + '___FCKpd___' + FCKCodeFormatter.ProtectedData.AddItem( data ) + closer ;
+}
+
+FCKCodeFormatter.Format = function( html )
+{
+	if ( !this.Regex )
+		this.Init() ;
+
+	// Protected content that remain untouched during the
+	// process go in the following array.
+	FCKCodeFormatter.ProtectedData = new Array() ;
+	
+	var sFormatted = html.replace( this.Regex.ProtectedTags, FCKCodeFormatter._ProtectData ) ;
+	
+	// Line breaks.
+	sFormatted		= sFormatted.replace( this.Regex.BlocksOpener, '\n$&' ) ; ;
+	sFormatted		= sFormatted.replace( this.Regex.BlocksCloser, '$&\n' ) ;
+	sFormatted		= sFormatted.replace( this.Regex.NewLineTags, '$&\n' ) ;
+	sFormatted		= sFormatted.replace( this.Regex.MainTags, '\n$&\n' ) ;
+
+	// Indentation.
+	var sIndentation = '' ;
+	
+	var asLines = sFormatted.split( this.Regex.LineSplitter ) ;
+	sFormatted = '' ;
+	
+	for ( var i = 0 ; i < asLines.length ; i++ )
+	{
+		var sLine = asLines[i] ;
+		
+		if ( sLine.length == 0 )
+			continue ;
+		
+		if ( this.Regex.DecreaseIndent.test( sLine ) )
+			sIndentation = sIndentation.replace( this.Regex.FormatIndentatorRemove, '' ) ;
+
+		sFormatted += sIndentation + sLine + '\n' ;
+		
+		if ( this.Regex.IncreaseIndent.test( sLine ) )
+			sIndentation += FCKConfig.FormatIndentator ;
+	}
+	
+	// Now we put back the protected data.
+	for ( var i = 0 ; i < FCKCodeFormatter.ProtectedData.length ; i++ )
+	{
+		var oRegex = new RegExp( '___FCKpd___' + i ) ;
+		sFormatted = sFormatted.replace( oRegex, FCKCodeFormatter.ProtectedData[i].replace( /\$/g, '$$$$' ) ) ;
+	}
+
+	return sFormatted.trim() ;
+}

stud/FCKeditor/editor/_source/internals/fckcommands.js

@@ -0,0 +1,126 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckcommands.js
+ * 	Define all commands available in the editor.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKCommands = FCK.Commands = new Object() ;
+FCKCommands.LoadedCommands = new Object() ;
+
+FCKCommands.RegisterCommand = function( commandName, command )
+{
+	this.LoadedCommands[ commandName ] = command ;
+}
+
+FCKCommands.GetCommand = function( commandName )
+{
+	var oCommand = FCKCommands.LoadedCommands[ commandName ] ;
+	
+	if ( oCommand )
+		return oCommand ;
+
+	switch ( commandName )
+	{
+		case 'DocProps'		: oCommand = new FCKDialogCommand( 'DocProps'	, FCKLang.DocProps				, 'dialog/fck_docprops.html'	, 400, 390, FCKCommands.GetFullPageState ) ; break ;
+		case 'Templates'	: oCommand = new FCKDialogCommand( 'Templates'	, FCKLang.DlgTemplatesTitle		, 'dialog/fck_template.html'	, 380, 450 ) ; break ;
+		case 'Link'			: oCommand = new FCKDialogCommand( 'Link'		, FCKLang.DlgLnkWindowTitle		, 'dialog/fck_link.html'		, 400, 330, FCK.GetNamedCommandState, 'CreateLink' ) ; break ;
+		case 'Unlink'		: oCommand = new FCKUnlinkCommand() ; break ;
+		case 'Anchor'		: oCommand = new FCKDialogCommand( 'Anchor'		, FCKLang.DlgAnchorTitle		, 'dialog/fck_anchor.html'		, 370, 170 ) ; break ;
+		case 'BulletedList'	: oCommand = new FCKDialogCommand( 'BulletedList', FCKLang.BulletedListProp		, 'dialog/fck_listprop.html'	, 370, 170 ) ; break ;
+		case 'NumberedList'	: oCommand = new FCKDialogCommand( 'NumberedList', FCKLang.NumberedListProp		, 'dialog/fck_listprop.html'	, 370, 170 ) ; break ;
+		case 'About'		: oCommand = new FCKDialogCommand( 'About'		, FCKLang.About					, 'dialog/fck_about.html'		, 400, 330 ) ; break ;
+
+		case 'Find'			: oCommand = new FCKDialogCommand( 'Find'		, FCKLang.DlgFindTitle			, 'dialog/fck_find.html'		, 340, 170 ) ; break ;
+		case 'Replace'		: oCommand = new FCKDialogCommand( 'Replace'	, FCKLang.DlgReplaceTitle		, 'dialog/fck_replace.html'		, 340, 200 ) ; break ;
+
+		case 'Image'		: oCommand = new FCKDialogCommand( 'Image'		, FCKLang.DlgImgTitle			, 'dialog/fck_image.html'		, 450, 400 ) ; break ;
+		case 'Flash'		: oCommand = new FCKDialogCommand( 'Flash'		, FCKLang.DlgFlashTitle			, 'dialog/fck_flash.html'		, 450, 400 ) ; break ;
+		case 'SpecialChar'	: oCommand = new FCKDialogCommand( 'SpecialChar', FCKLang.DlgSpecialCharTitle	, 'dialog/fck_specialchar.html'	, 400, 320 ) ; break ;
+		case 'Smiley'		: oCommand = new FCKDialogCommand( 'Smiley'		, FCKLang.DlgSmileyTitle		, 'dialog/fck_smiley.html'		, FCKConfig.SmileyWindowWidth, FCKConfig.SmileyWindowHeight ) ; break ;
+		case 'Table'		: oCommand = new FCKDialogCommand( 'Table'		, FCKLang.DlgTableTitle			, 'dialog/fck_table.html'		, 450, 250 ) ; break ;
+		case 'TableProp'	: oCommand = new FCKDialogCommand( 'Table'		, FCKLang.DlgTableTitle			, 'dialog/fck_table.html?Parent', 400, 250 ) ; break ;
+		case 'TableCellProp': oCommand = new FCKDialogCommand( 'TableCell'	, FCKLang.DlgCellTitle			, 'dialog/fck_tablecell.html'	, 550, 250 ) ; break ;
+		case 'UniversalKey'	: oCommand = new FCKDialogCommand( 'UniversalKey', FCKLang.UniversalKeyboard	, 'dialog/fck_universalkey.html', 415, 300 ) ; break ;
+
+		case 'Style'		: oCommand = new FCKStyleCommand() ; break ;
+
+		case 'FontName'		: oCommand = new FCKFontNameCommand() ; break ;
+		case 'FontSize'		: oCommand = new FCKFontSizeCommand() ; break ;
+		case 'FontFormat'	: oCommand = new FCKFormatBlockCommand() ; break ;
+
+		case 'Source'		: oCommand = new FCKSourceCommand() ; break ;
+		case 'Preview'		: oCommand = new FCKPreviewCommand() ; break ;
+		case 'Save'			: oCommand = new FCKSaveCommand() ; break ;
+		case 'NewPage'		: oCommand = new FCKNewPageCommand() ; break ;
+		case 'PageBreak'	: oCommand = new FCKPageBreakCommand() ; break ;
+
+		case 'TextColor'	: oCommand = new FCKTextColorCommand('ForeColor') ; break ;
+		case 'BGColor'		: oCommand = new FCKTextColorCommand('BackColor') ; break ;
+
+		case 'PasteText'	: oCommand = new FCKPastePlainTextCommand() ; break ;
+		case 'PasteWord'	: oCommand = new FCKPasteWordCommand() ; break ;
+
+		case 'TableInsertRow'		: oCommand = new FCKTableCommand('TableInsertRow') ; break ;
+		case 'TableDeleteRows'		: oCommand = new FCKTableCommand('TableDeleteRows') ; break ;
+		case 'TableInsertColumn'	: oCommand = new FCKTableCommand('TableInsertColumn') ; break ;
+		case 'TableDeleteColumns'	: oCommand = new FCKTableCommand('TableDeleteColumns') ; break ;
+		case 'TableInsertCell'		: oCommand = new FCKTableCommand('TableInsertCell') ; break ;
+		case 'TableDeleteCells'		: oCommand = new FCKTableCommand('TableDeleteCells') ; break ;
+		case 'TableMergeCells'		: oCommand = new FCKTableCommand('TableMergeCells') ; break ;
+		case 'TableSplitCell'		: oCommand = new FCKTableCommand('TableSplitCell') ; break ;
+		case 'TableDelete'			: oCommand = new FCKTableCommand('TableDelete') ; break ;
+
+		case 'Form'			: oCommand = new FCKDialogCommand( 'Form'		, FCKLang.Form			, 'dialog/fck_form.html'		, 380, 230 ) ; break ;
+		case 'Checkbox'		: oCommand = new FCKDialogCommand( 'Checkbox'	, FCKLang.Checkbox		, 'dialog/fck_checkbox.html'	, 380, 230 ) ; break ;
+		case 'Radio'		: oCommand = new FCKDialogCommand( 'Radio'		, FCKLang.RadioButton	, 'dialog/fck_radiobutton.html'	, 380, 230 ) ; break ;
+		case 'TextField'	: oCommand = new FCKDialogCommand( 'TextField'	, FCKLang.TextField		, 'dialog/fck_textfield.html'	, 380, 230 ) ; break ;
+		case 'Textarea'		: oCommand = new FCKDialogCommand( 'Textarea'	, FCKLang.Textarea		, 'dialog/fck_textarea.html'	, 380, 230 ) ; break ;
+		case 'HiddenField'	: oCommand = new FCKDialogCommand( 'HiddenField', FCKLang.HiddenField	, 'dialog/fck_hiddenfield.html'	, 380, 230 ) ; break ;
+		case 'Button'		: oCommand = new FCKDialogCommand( 'Button'		, FCKLang.Button		, 'dialog/fck_button.html'		, 380, 230 ) ; break ;
+		case 'Select'		: oCommand = new FCKDialogCommand( 'Select'		, FCKLang.SelectionField, 'dialog/fck_select.html'		, 400, 380 ) ; break ;
+		case 'ImageButton'	: oCommand = new FCKDialogCommand( 'ImageButton', FCKLang.ImageButton	, 'dialog/fck_image.html?ImageButton', 450, 400 ) ; break ;
+
+		case 'SpellCheck'	: oCommand = new FCKSpellCheckCommand() ; break ;
+		case 'FitWindow'	: oCommand = new FCKFitWindow() ; break ;
+
+		case 'Undo'	: oCommand = new FCKUndoCommand() ; break ;
+		case 'Redo'	: oCommand = new FCKRedoCommand() ; break ;
+
+		// Generic Undefined command (usually used when a command is under development).
+		case 'Undefined'	: oCommand = new FCKUndefinedCommand() ; break ;
+		
+		// By default we assume that it is a named command.
+		default:
+			if ( FCKRegexLib.NamedCommands.test( commandName ) )
+				oCommand = new FCKNamedCommand( commandName ) ;
+			else
+			{
+				alert( FCKLang.UnknownCommand.replace( /%1/g, commandName ) ) ;
+				return null ;
+			}
+	}
+	
+	FCKCommands.LoadedCommands[ commandName ] = oCommand ;
+	
+	return oCommand ;
+}
+
+// Gets the state of the "Document Properties" button. It must be enabled only
+// when "Full Page" editing is available.
+FCKCommands.GetFullPageState = function()
+{
+	return FCKConfig.FullPage ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+}

stud/FCKeditor/editor/_source/internals/fckconfig.js

@@ -0,0 +1,195 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckconfig.js
+ * 	Creates and initializes the FCKConfig object.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKConfig = FCK.Config = new Object() ;
+
+/*
+	For the next major version (probably 3.0) we should move all this stuff to
+	another dedicated object and leave FCKConfig as a holder object for settings only).
+*/
+
+// Editor Base Path
+if ( document.location.protocol == 'file:' )
+{
+	FCKConfig.BasePath = unescape( document.location.pathname.substr(1) ) ;
+	FCKConfig.BasePath = FCKConfig.BasePath.replace( /\\/gi, '/' ) ;
+	FCKConfig.BasePath = 'file://' + FCKConfig.BasePath.substring(0,FCKConfig.BasePath.lastIndexOf('/')+1) ;
+	FCKConfig.FullBasePath = FCKConfig.BasePath ;
+}
+else
+{
+	FCKConfig.BasePath = document.location.pathname.substring(0,document.location.pathname.lastIndexOf('/')+1) ;
+	FCKConfig.FullBasePath = document.location.protocol + '//' + document.location.host + FCKConfig.BasePath ;
+}
+
+FCKConfig.EditorPath = FCKConfig.BasePath.replace( /editor\/$/, '' ) ;
+
+// There is a bug in Gecko. If the editor is hidden on startup, an error is 
+// thrown when trying to get the screen dimentions.
+try
+{
+	FCKConfig.ScreenWidth	= screen.width ;
+	FCKConfig.ScreenHeight	= screen.height ;
+}
+catch (e) 
+{
+	FCKConfig.ScreenWidth	= 800 ;
+	FCKConfig.ScreenHeight	= 600 ;
+}
+
+// Override the actual configuration values with the values passed throw the 
+// hidden field "<InstanceName>___Config".
+FCKConfig.ProcessHiddenField = function()
+{
+	this.PageConfig = new Object() ;
+
+	// Get the hidden field.
+	var oConfigField = window.parent.document.getElementById( FCK.Name + '___Config' ) ;
+	
+	// Do nothing if the config field was not defined.
+	if ( ! oConfigField ) return ;
+
+	var aCouples = oConfigField.value.split('&') ;
+
+	for ( var i = 0 ; i < aCouples.length ; i++ )
+	{
+		if ( aCouples[i].length == 0 )
+			continue ;
+
+		var aConfig = aCouples[i].split( '=' ) ;
+		var sKey = unescape( aConfig[0] ) ;
+		var sVal = unescape( aConfig[1] ) ;
+
+		if ( sKey == 'CustomConfigurationsPath' )	// The Custom Config File path must be loaded immediately.
+			FCKConfig[ sKey ] = sVal ;
+
+		else if ( sVal.toLowerCase() == "true" )	// If it is a boolean TRUE.
+			this.PageConfig[ sKey ] = true ;
+
+		else if ( sVal.toLowerCase() == "false" )	// If it is a boolean FALSE.
+			this.PageConfig[ sKey ] = false ;
+
+		else if ( sVal.length > 0 && !isNaN( sVal ) )	// If it is a number.
+			this.PageConfig[ sKey ] = parseInt( sVal ) ;
+
+		else										// In any other case it is a string.
+			this.PageConfig[ sKey ] = sVal ;
+	}
+}
+
+function FCKConfig_LoadPageConfig()
+{
+	var oPageConfig = FCKConfig.PageConfig ;
+	for ( var sKey in oPageConfig )
+		FCKConfig[ sKey ] = oPageConfig[ sKey ] ;
+}
+
+function FCKConfig_PreProcess()
+{
+	var oConfig = FCKConfig ;
+	
+	// Force debug mode if fckdebug=true in the QueryString (main page).
+	if ( oConfig.AllowQueryStringDebug )
+	{
+		try
+		{
+			if ( (/fckdebug=true/i).test( window.top.location.search ) )
+				oConfig.Debug = true ;
+		}
+		catch (e) { /* Ignore it. Much probably we are inside a FRAME where the "top" is in another domain (security error). */ }
+	}
+
+	// Certifies that the "PluginsPath" configuration ends with a slash.
+	if ( !oConfig.PluginsPath.endsWith('/') )
+		oConfig.PluginsPath += '/' ;
+
+	// EditorAreaCSS accepts an array of paths or a single path (as string).
+	// In the last case, transform it in an array.
+	if ( typeof( oConfig.EditorAreaCSS ) == 'string' )
+		oConfig.EditorAreaCSS = [ oConfig.EditorAreaCSS ] ;
+
+	var sComboPreviewCSS = oConfig.ToolbarComboPreviewCSS ;
+	if ( !sComboPreviewCSS || sComboPreviewCSS.length == 0 )
+		oConfig.ToolbarComboPreviewCSS = oConfig.EditorAreaCSS ;
+	else if ( typeof( sComboPreviewCSS ) == 'string' )
+		oConfig.ToolbarComboPreviewCSS = [ sComboPreviewCSS ] ;
+}
+
+// Define toolbar sets collection.
+FCKConfig.ToolbarSets = new Object() ;
+
+// Defines the plugins collection.
+FCKConfig.Plugins = new Object() ;
+FCKConfig.Plugins.Items = new Array() ;
+
+FCKConfig.Plugins.Add = function( name, langs, path )
+{
+	FCKConfig.Plugins.Items.AddItem( [name, langs, path] ) ;
+}
+
+// FCKConfig.ProtectedSource: object that holds a collection of Regular 
+// Expressions that defined parts of the raw HTML that must remain untouched
+// like custom tags, scripts, server side code, etc...
+FCKConfig.ProtectedSource = new Object() ;
+
+// Initialize the regex array with the default ones.
+FCKConfig.ProtectedSource.RegexEntries = [
+	// First of any other protection, we must protect all comments to avoid 
+	// loosing them (of course, IE related).
+	/<!--[\s\S]*?-->/g ,
+
+	// Script tags will also be forced to be protected, otherwise IE will execute them.
+	/<script[\s\S]*?<\/script>/gi,
+	
+	// <noscript> tags (get lost in IE and messed up in FF).
+	/<noscript[\s\S]*?<\/noscript>/gi
+] ;
+
+FCKConfig.ProtectedSource.Add = function( regexPattern )
+{
+	this.RegexEntries.AddItem( regexPattern ) ;
+}
+
+FCKConfig.ProtectedSource.Protect = function( html )
+{
+	function _Replace( protectedSource )
+	{
+		var index = FCKTempBin.AddElement( protectedSource ) ;
+		return '<!--{PS..' + index + '}-->' ;
+	}
+	
+	for ( var i = 0 ; i < this.RegexEntries.length ; i++ )
+	{
+		html = html.replace( this.RegexEntries[i], _Replace ) ;
+	}
+	
+	return html ;
+}
+
+FCKConfig.ProtectedSource.Revert = function( html, clearBin )
+{
+	function _Replace( m, opener, index )
+	{
+		var protectedValue = clearBin ? FCKTempBin.RemoveElement( index ) : FCKTempBin.Elements[ index ] ;
+		// There could be protected source inside another one.
+		return FCKConfig.ProtectedSource.Revert( protectedValue, clearBin ) ;
+	}
+
+	return html.replace( /(<|&lt;)!--\{PS..(\d+)\}--(>|&gt;)/g, _Replace ) ;
+}

stud/FCKeditor/editor/_source/internals/fckdebug.js

@@ -0,0 +1,77 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckdebug.js
+ * 	Debug window control and operations.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKDebug = new Object() ;
+
+FCKDebug.Output = function( message, color, noParse )
+{
+	if ( ! FCKConfig.Debug ) return ;
+	
+	if ( !noParse && message != null && isNaN( message ) )
+		message = message.replace(/</g, "&lt;") ;
+
+	if ( !this.DebugWindow || this.DebugWindow.closed )
+		this.DebugWindow = window.open( FCKConfig.BasePath + 'fckdebug.html', 'FCKeditorDebug', 'menubar=no,scrollbars=no,resizable=yes,location=no,toolbar=no,width=600,height=500', true ) ;
+	
+	if ( this.DebugWindow && this.DebugWindow.Output)
+	{
+		try 
+		{
+			this.DebugWindow.Output( message, color ) ;
+		} 
+		catch ( e ) {}	 // Ignore errors
+	}
+}
+
+FCKDebug.OutputObject = function( anyObject, color )
+{
+	if ( ! FCKConfig.Debug ) return ;
+
+	var message ;
+	
+	if ( anyObject != null ) 
+	{
+		message = 'Properties of: ' + anyObject + '</b><blockquote>' ;
+		
+		for (var prop in anyObject)
+		{
+			try 
+			{
+				var sVal = anyObject[ prop ] ? anyObject[ prop ] + '' : '[null]' ;
+				message += '<b>' + prop + '</b> : ' + sVal.replace(/</g, '&lt;') + '<br>' ;
+			} 
+			catch (e)
+			{
+				try
+				{
+					message += '<b>' + prop + '</b> : [' + typeof( anyObject[ prop ] ) + ']<br>' ;
+				}
+				catch (e)
+				{
+					message += '<b>' + prop + '</b> : [-error-]<br>' ;
+				}
+			}
+		}
+
+		message += '</blockquote><b>' ; 
+	} else
+		message = 'OutputObject : Object is "null".' ;
+		
+	FCKDebug.Output( message, color, true ) ;
+}

stud/FCKeditor/editor/_source/internals/fckdialog.js

@@ -0,0 +1,34 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckdialog.js
+ * 	Dialog windows operations.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKDialog = new Object() ;
+
+// This method opens a dialog window using the standard dialog template.
+FCKDialog.OpenDialog = function( dialogName, dialogTitle, dialogPage, width, height, customValue, parentWindow, resizable )
+{
+	// Setup the dialog info.
+	var oDialogInfo = new Object() ;
+	oDialogInfo.Title = dialogTitle ;
+	oDialogInfo.Page = dialogPage ;
+	oDialogInfo.Editor = window ;
+	oDialogInfo.CustomValue = customValue ;		// Optional
+	
+	var sUrl = FCKConfig.BasePath + 'fckdialog.html' ;
+	this.Show( oDialogInfo, dialogName, sUrl, width, height, parentWindow, resizable ) ;
+}

stud/FCKeditor/editor/_source/internals/fckdialog_gecko.js

@@ -0,0 +1,101 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckdialog_gecko.js
+ * 	Dialog windows operations. (Gecko specific implementations)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKDialog.Show = function( dialogInfo, dialogName, pageUrl, dialogWidth, dialogHeight, parentWindow, resizable )
+{
+	var iTop  = (FCKConfig.ScreenHeight - dialogHeight) / 2 ;
+	var iLeft = (FCKConfig.ScreenWidth  - dialogWidth)  / 2 ;
+
+	var sOption  = "location=no,menubar=no,toolbar=no,dependent=yes,dialog=yes,minimizable=no,modal=yes,alwaysRaised=yes" +
+		",resizable="  + ( resizable ? 'yes' : 'no' ) +
+		",width="  + dialogWidth +
+		",height=" + dialogHeight +
+		",top="  + iTop +
+		",left=" + iLeft ;
+
+	if ( !parentWindow )
+		parentWindow = window ;
+	
+	FCKFocusManager.Lock() ;
+	
+	var oWindow = parentWindow.open( '', 'FCKeditorDialog_' + dialogName, sOption, true ) ;
+	
+	if ( !oWindow )
+	{
+		alert( FCKLang.DialogBlocked ) ;
+		FCKFocusManager.Unlock() ;
+		return ;
+	}
+		
+	oWindow.moveTo( iLeft, iTop ) ;
+	oWindow.resizeTo( dialogWidth, dialogHeight ) ;
+	oWindow.focus() ;
+	oWindow.location.href = pageUrl ;
+	
+	oWindow.dialogArguments = dialogInfo ;
+	
+	// On some Gecko browsers (probably over slow connections) the 
+	// "dialogArguments" are not set to the target window so we must
+	// put it in the opener window so it can be used by the target one.
+	parentWindow.FCKLastDialogInfo = dialogInfo ;
+	
+	this.Window = oWindow ;
+	
+	// Try/Catch must be used to avoit an error when using a frameset 
+	// on a different domain: 
+	// "Permission denied to get property Window.releaseEvents".
+	try
+	{
+		window.top.captureEvents( Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS ) ;
+		window.top.parent.addEventListener( 'mousedown', this.CheckFocus, true ) ;
+		window.top.parent.addEventListener( 'mouseup', this.CheckFocus, true ) ;
+		window.top.parent.addEventListener( 'click', this.CheckFocus, true ) ;
+		window.top.parent.addEventListener( 'focus', this.CheckFocus, true ) ;
+	}
+	catch (e)
+	{}
+}
+
+FCKDialog.CheckFocus = function()
+{
+	// It is strange, but we have to check the FCKDialog existence to avoid a 
+	// random error: "FCKDialog is not defined".
+	if ( typeof( FCKDialog ) != "object" )
+		return false ;
+	
+	if ( FCKDialog.Window && !FCKDialog.Window.closed )
+		FCKDialog.Window.focus() ;
+	else
+	{
+		// Try/Catch must be used to avoit an error when using a frameset 
+		// on a different domain: 
+		// "Permission denied to get property Window.releaseEvents".
+		try
+		{
+			window.top.releaseEvents(Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS) ;
+			window.top.parent.removeEventListener( 'onmousedown', FCKDialog.CheckFocus, true ) ;
+			window.top.parent.removeEventListener( 'mouseup', FCKDialog.CheckFocus, true ) ;
+			window.top.parent.removeEventListener( 'click', FCKDialog.CheckFocus, true ) ;
+			window.top.parent.removeEventListener( 'onfocus', FCKDialog.CheckFocus, true ) ;
+		}
+		catch (e)
+		{}
+	}
+	return false ;
+}

stud/FCKeditor/editor/_source/internals/fckdialog_ie.js

@@ -0,0 +1,40 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckdialog_ie.js
+ * 	Dialog windows operations. (IE specific implementations)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKDialog.Show = function( dialogInfo, dialogName, pageUrl, dialogWidth, dialogHeight, parentWindow )
+{
+	if ( !parentWindow )
+		parentWindow = window ;
+
+	FCKFocusManager.Lock() ;
+	
+	var oReturn ;
+	
+	try
+	{
+		oReturn = parentWindow.showModalDialog( pageUrl, dialogInfo, "dialogWidth:" + dialogWidth + "px;dialogHeight:" + dialogHeight + "px;help:no;scroll:no;status:no") ;
+	}
+	catch( e ) 
+	{}
+	
+	if ( !oReturn )
+		alert( FCKLang.DialogBlocked ) ;	
+
+	FCKFocusManager.Unlock() ;
+}

stud/FCKeditor/editor/_source/internals/fckdocumentprocessor.js

@@ -0,0 +1,175 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckdocumentprocessor.js
+ * 	Advanced document processors.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKDocumentProcessor = new Object() ;
+FCKDocumentProcessor._Items = new Array() ;
+
+FCKDocumentProcessor.AppendNew = function()
+{
+	var oNewItem = new Object() ;
+	this._Items.AddItem( oNewItem ) ;
+	return oNewItem ;
+}
+
+FCKDocumentProcessor.Process = function( document )
+{
+	var oProcessor, i = 0 ;
+	while( ( oProcessor = this._Items[i++] ) )
+		oProcessor.ProcessDocument( document ) ;
+}
+
+var FCKDocumentProcessor_CreateFakeImage = function( fakeClass, realElement )
+{
+	var oImg = FCK.EditorDocument.createElement( 'IMG' ) ;
+	oImg.className = fakeClass ;
+	oImg.src = FCKConfig.FullBasePath + 'images/spacer.gif' ;
+	oImg.setAttribute( '_fckfakelement', 'true', 0 ) ;
+	oImg.setAttribute( '_fckrealelement', FCKTempBin.AddElement( realElement ), 0 ) ;
+	return oImg ;
+}
+
+// Link Anchors
+var FCKAnchorsProcessor = FCKDocumentProcessor.AppendNew() ;
+FCKAnchorsProcessor.ProcessDocument = function( document )
+{
+	var aLinks = document.getElementsByTagName( 'A' ) ;
+
+	var oLink ;
+	var i = aLinks.length - 1 ;
+	while ( i >= 0 && ( oLink = aLinks[i--] ) )
+	{
+		// If it is anchor.
+		if ( oLink.name.length > 0 && ( !oLink.getAttribute('href') || oLink.getAttribute('href').length == 0 ) )
+		{
+			var oImg = FCKDocumentProcessor_CreateFakeImage( 'FCK__Anchor', oLink.cloneNode(true) ) ;
+			oImg.setAttribute( '_fckanchor', 'true', 0 ) ;
+			
+			oLink.parentNode.insertBefore( oImg, oLink ) ;
+			oLink.parentNode.removeChild( oLink ) ;
+		}
+	}
+}
+
+// Page Breaks
+var FCKPageBreaksProcessor = FCKDocumentProcessor.AppendNew() ;
+FCKPageBreaksProcessor.ProcessDocument = function( document )
+{
+	var aDIVs = document.getElementsByTagName( 'DIV' ) ;
+
+	var eDIV ;
+	var i = aDIVs.length - 1 ;
+	while ( i >= 0 && ( eDIV = aDIVs[i--] ) )
+	{
+		if ( eDIV.style.pageBreakAfter == 'always' && eDIV.childNodes.length == 1 && eDIV.childNodes[0].style && eDIV.childNodes[0].style.display == 'none' )
+		{
+			var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', eDIV.cloneNode(true) ) ;
+			
+			eDIV.parentNode.insertBefore( oFakeImage, eDIV ) ;
+			eDIV.parentNode.removeChild( eDIV ) ;
+		}
+	}
+/*
+	var aCenters = document.getElementsByTagName( 'CENTER' ) ;
+
+	var oCenter ;
+	var i = aCenters.length - 1 ;
+	while ( i >= 0 && ( oCenter = aCenters[i--] ) )
+	{
+		if ( oCenter.style.pageBreakAfter == 'always' && oCenter.innerHTML.trim().length == 0 )
+		{
+			var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', oCenter.cloneNode(true) ) ;
+			
+			oCenter.parentNode.insertBefore( oFakeImage, oCenter ) ;
+			oCenter.parentNode.removeChild( oCenter ) ;
+		}
+	}
+*/
+}
+
+// Flash Embeds.
+var FCKFlashProcessor = FCKDocumentProcessor.AppendNew() ;
+FCKFlashProcessor.ProcessDocument = function( document )
+{
+	/*
+	Sample code:
+	This is some <embed src="/UserFiles/Flash/Yellow_Runners.swf"></embed><strong>sample text</strong>. You are&nbsp;<a name="fred"></a> using <a href="http://www.fckeditor.net/">FCKeditor</a>.
+	*/
+
+	var aEmbeds = document.getElementsByTagName( 'EMBED' ) ;
+
+	var oEmbed ;
+	var i = aEmbeds.length - 1 ;
+	while ( i >= 0 && ( oEmbed = aEmbeds[i--] ) )
+	{
+		if ( oEmbed.src.endsWith( '.swf', true ) )
+		{
+			var oCloned = oEmbed.cloneNode( true ) ;
+			
+			// On IE, some properties are not getting clonned properly, so we 
+			// must fix it. Thanks to Alfonso Martinez.
+			if ( FCKBrowserInfo.IsIE )
+			{
+				var oAtt ;
+				if ( oAtt = oEmbed.getAttribute( 'scale' ) ) oCloned.setAttribute( 'scale', oAtt ) ;
+				if ( oAtt = oEmbed.getAttribute( 'play' ) ) oCloned.setAttribute( 'play', oAtt ) ;
+				if ( oAtt = oEmbed.getAttribute( 'loop' ) ) oCloned.setAttribute( 'loop', oAtt ) ;
+				if ( oAtt = oEmbed.getAttribute( 'menu' ) ) oCloned.setAttribute( 'menu', oAtt ) ;
+				if ( oAtt = oEmbed.getAttribute( 'wmode' ) ) oCloned.setAttribute( 'wmode', oAtt ) ;
+				if ( oAtt = oEmbed.getAttribute( 'quality' ) ) oCloned.setAttribute( 'quality', oAtt ) ;
+			}
+		
+			var oImg = FCKDocumentProcessor_CreateFakeImage( 'FCK__Flash', oCloned ) ;
+			oImg.setAttribute( '_fckflash', 'true', 0 ) ;
+			
+			FCKFlashProcessor.RefreshView( oImg, oEmbed ) ;
+
+			oEmbed.parentNode.insertBefore( oImg, oEmbed ) ;
+			oEmbed.parentNode.removeChild( oEmbed ) ;
+
+//			oEmbed.setAttribute( '_fcktemp', 'true', 0) ;
+//			oEmbed.style.display = 'none' ;
+//			oEmbed.hidden = true ;
+		}
+	}
+}
+
+FCKFlashProcessor.RefreshView = function( placholderImage, originalEmbed )
+{
+	if ( originalEmbed.width > 0 )
+		placholderImage.style.width = FCKTools.ConvertHtmlSizeToStyle( originalEmbed.width ) ;
+		
+	if ( originalEmbed.height > 0 )
+		placholderImage.style.height = FCKTools.ConvertHtmlSizeToStyle( originalEmbed.height ) ;
+}
+
+FCK.GetRealElement = function( fakeElement )
+{
+	var e = FCKTempBin.Elements[ fakeElement.getAttribute('_fckrealelement') ] ;
+
+	if ( fakeElement.getAttribute('_fckflash') )
+	{
+		if ( fakeElement.style.width.length > 0 )
+				e.width = FCKTools.ConvertStyleSizeToHtml( fakeElement.style.width ) ;
+		
+		if ( fakeElement.style.height.length > 0 )
+				e.height = FCKTools.ConvertStyleSizeToHtml( fakeElement.style.height ) ;
+	}
+	
+	return e ;
+}

stud/FCKeditor/editor/_source/internals/fcklanguagemanager.js

@@ -0,0 +1,152 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcklanguagemanager.js
+ * 	Defines the FCKLanguageManager object that is used for language 
+ * 	operations.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+var FCKLanguageManager = FCK.Language = new Object() ;
+
+FCKLanguageManager.AvailableLanguages = 
+{
+	'ar'		: 'Arabic',
+	'bg'		: 'Bulgarian',
+	'bn'		: 'Bengali/Bangla',
+	'bs'		: 'Bosnian',
+	'ca'		: 'Catalan',
+	'cs'		: 'Czech',
+	'da'		: 'Danish',
+	'de'		: 'German',
+	'el'		: 'Greek',
+	'en'		: 'English',
+	'en-au'		: 'English (Australia)',
+	'en-ca'		: 'English (Canadian)',
+	'en-uk'		: 'English (United Kingdom)',
+	'eo'		: 'Esperanto',
+	'es'		: 'Spanish',
+	'et'		: 'Estonian',
+	'eu'		: 'Basque',
+	'fa'		: 'Persian',
+	'fi'		: 'Finnish',
+	'fo'		: 'Faroese',
+	'fr'		: 'French',
+	'gl'		: 'Galician',
+	'he'		: 'Hebrew',
+	'hi'		: 'Hindi',
+	'hr'		: 'Croatian',
+	'hu'		: 'Hungarian',
+	'it'		: 'Italian',
+	'ja'		: 'Japanese',
+	'km'		: 'Khmer',
+	'ko'		: 'Korean',
+	'lt'		: 'Lithuanian',
+	'lv'		: 'Latvian',
+	'mn'		: 'Mongolian',
+	'ms'		: 'Malay',
+	'nb'		: 'Norwegian Bokmal',
+	'nl'		: 'Dutch',
+	'no'		: 'Norwegian',
+	'pl'		: 'Polish',
+	'pt'		: 'Portuguese (Portugal)',
+	'pt-br'		: 'Portuguese (Brazil)',
+	'ro'		: 'Romanian',
+	'ru'		: 'Russian',
+	'sk'		: 'Slovak',
+	'sl'		: 'Slovenian',
+	'sr'		: 'Serbian (Cyrillic)',
+	'sr-latn'	: 'Serbian (Latin)',
+	'sv'		: 'Swedish',
+	'th'		: 'Thai',
+	'tr'		: 'Turkish',
+	'uk'		: 'Ukrainian',
+	'vi'		: 'Vietnamese',
+	'zh'		: 'Chinese Traditional',
+	'zh-cn'		: 'Chinese Simplified'
+}
+
+FCKLanguageManager.GetActiveLanguage = function()
+{
+	if ( FCKConfig.AutoDetectLanguage )
+	{
+		var sUserLang ;
+		
+		// IE accepts "navigator.userLanguage" while Gecko "navigator.language".
+		if ( navigator.userLanguage )
+			sUserLang = navigator.userLanguage.toLowerCase() ;
+		else if ( navigator.language )
+			sUserLang = navigator.language.toLowerCase() ;
+		else
+		{
+			// Firefox 1.0 PR has a bug: it doens't support the "language" property.
+			return FCKConfig.DefaultLanguage ;
+		}
+		
+		// Some language codes are set in 5 characters, 
+		// like "pt-br" for Brasilian Portuguese.
+		if ( sUserLang.length >= 5 )
+		{
+			sUserLang = sUserLang.substr(0,5) ;
+			if ( this.AvailableLanguages[sUserLang] ) return sUserLang ;
+		}
+		
+		// If the user's browser is set to, for example, "pt-br" but only the 
+		// "pt" language file is available then get that file.
+		if ( sUserLang.length >= 2 )
+		{
+			sUserLang = sUserLang.substr(0,2) ;
+			if ( this.AvailableLanguages[sUserLang] ) return sUserLang ;
+		}
+	}
+	
+	return this.DefaultLanguage ;
+}
+
+FCKLanguageManager.TranslateElements = function( targetDocument, tag, propertyToSet, encode )
+{
+	var e = targetDocument.getElementsByTagName(tag) ;
+	var sKey, s ;
+	for ( var i = 0 ; i < e.length ; i++ )
+	{
+		if ( sKey = e[i].getAttribute( 'fckLang' ) )
+		{
+			if ( s = FCKLang[ sKey ] )
+			{
+				if ( encode )
+					s = FCKTools.HTMLEncode( s ) ;
+				eval( 'e[i].' + propertyToSet + ' = s' ) ;
+			}
+		}
+	}
+}
+
+FCKLanguageManager.TranslatePage = function( targetDocument )
+{
+	this.TranslateElements( targetDocument, 'INPUT', 'value' ) ;
+	this.TranslateElements( targetDocument, 'SPAN', 'innerHTML' ) ;
+	this.TranslateElements( targetDocument, 'LABEL', 'innerHTML' ) ;
+	this.TranslateElements( targetDocument, 'OPTION', 'innerHTML', true ) ;
+}
+
+FCKLanguageManager.Initialize = function()
+{
+	if ( this.AvailableLanguages[ FCKConfig.DefaultLanguage ] )
+		this.DefaultLanguage = FCKConfig.DefaultLanguage ;
+	else
+		this.DefaultLanguage = 'en' ;
+
+	this.ActiveLanguage = new Object() ;
+	this.ActiveLanguage.Code = this.GetActiveLanguage() ;
+	this.ActiveLanguage.Name = this.AvailableLanguages[ this.ActiveLanguage.Code ] ;
+}

stud/FCKeditor/editor/_source/internals/fckplugins.js

@@ -0,0 +1,42 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckplugins.js
+ * 	Defines the FCKPlugins object that is responsible for loading the Plugins.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKPlugins = FCK.Plugins = new Object() ;
+FCKPlugins.ItemsCount = 0 ;
+FCKPlugins.Items = new Object() ;
+	
+FCKPlugins.Load = function()
+{
+	var oItems = FCKPlugins.Items ;
+
+	// build the plugins collection.
+	for ( var i = 0 ; i < FCKConfig.Plugins.Items.length ; i++ )
+	{
+		var oItem = FCKConfig.Plugins.Items[i] ;
+		var oPlugin = oItems[ oItem[0] ] = new FCKPlugin( oItem[0], oItem[1], oItem[2] ) ;
+		FCKPlugins.ItemsCount++ ;
+	}
+
+	// Load all items in the plugins collection.
+	for ( var s in oItems )
+		oItems[s].Load() ;
+
+	// This is a self destroyable function (must be called once).
+	FCKPlugins.Load = null ;
+}

stud/FCKeditor/editor/_source/internals/fckregexlib.js

@@ -0,0 +1,87 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckregexlib.js
+ * 	These are some Regular Expresions used by the editor.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKRegexLib = {
+
+// This is the Regular expression used by the SetHTML method for the "'" entity.
+AposEntity		: /'/gi ,
+
+// Used by the Styles combo to identify styles that can't be applied to text.
+ObjectElements	: /^(?:IMG|TABLE|TR|TD|TH|INPUT|SELECT|TEXTAREA|HR|OBJECT|A|UL|OL|LI)$/i ,
+
+BlockElements	: /^(?:P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TD|TH)$/i ,
+
+// Elements marked as empty "Empty" in the XHTML DTD.
+EmptyElements	: /^(?:BASE|META|LINK|HR|BR|PARAM|IMG|AREA|INPUT)$/i ,
+
+// List all named commands (commands that can be interpreted by the browser "execCommand" method.
+NamedCommands	: /^(?:Cut|Copy|Paste|Print|SelectAll|RemoveFormat|Unlink|Undo|Redo|Bold|Italic|Underline|StrikeThrough|Subscript|Superscript|JustifyLeft|JustifyCenter|JustifyRight|JustifyFull|Outdent|Indent|InsertOrderedList|InsertUnorderedList|InsertHorizontalRule)$/i ,
+
+BodyContents	: /([\s\S]*\<body[^\>]*\>)([\s\S]*)(\<\/body\>[\s\S]*)/i ,
+
+// Temporary text used to solve some browser specific limitations.
+ToReplace		: /___fcktoreplace:([\w]+)/ig ,
+
+// Get the META http-equiv attribute from the tag.
+MetaHttpEquiv	: /http-equiv\s*=\s*["']?([^"' ]+)/i ,
+
+HasBaseTag		: /<base /i ,
+
+HtmlOpener		: /<html\s?[^>]*>/i ,
+HeadOpener		: /<head\s?[^>]*>/i ,
+HeadCloser		: /<\/head\s*>/i ,
+
+TableBorderClass : /\s*FCK__ShowTableBorders\s*/ ,
+
+// Validate element names.
+ElementName		: /(^[A-Za-z_:][\w.\-:]*\w$)|(^[A-Za-z_]$)/ ,
+
+// Used in conjuction with the FCKConfig.ForceSimpleAmpersand configuration option.
+ForceSimpleAmpersand : /___FCKAmp___/g ,
+
+// Get the closing parts of the tags with no closing tags, like <br/>... gets the "/>" part.
+SpaceNoClose	: /\/>/g ,
+
+EmptyParagraph	: /^<(p|div)>\s*<\/\1>$/i ,
+
+TagBody			: /></ ,
+
+StrongOpener	: /<STRONG([ \>])/gi ,
+StrongCloser	: /<\/STRONG>/gi ,
+EmOpener		: /<EM([ \>])/gi ,
+EmCloser		: /<\/EM>/gi ,
+AbbrOpener		: /<ABBR([ \>])/gi ,
+AbbrCloser		: /<\/ABBR>/gi ,
+
+GeckoEntitiesMarker : /#\?-\:/g ,
+
+// We look for the "src" and href attribute with the " or ' or whithout one of
+// them. We have to do all in one, otherwhise we will have problems with URLs
+// like "thumbnail.php?src=someimage.jpg" (SF-BUG 1554141).
+ProtectUrlsImg	: /(?:(<img(?=\s).*?\ssrc=)("|')(.*?)\2)|(?:(<img\s.*?src=)([^"'][^ >]+))/gi ,
+ProtectUrlsA	: /(?:(<a(?=\s).*?\shref=)("|')(.*?)\2)|(?:(<a\s.*?href=)([^"'][^ >]+))/gi ,
+
+Html4DocType	: /HTML 4\.0 Transitional/i ,
+DocTypeTag		: /<!DOCTYPE[^>]*>/i ,
+
+// These regex are used to save the original event attributes in the HTML.
+TagsWithEvent	: /<[^\>]+ on\w+[\s\r\n]*=[\s\r\n]*?('|")[\s\S]+?\>/g ,
+EventAttributes	: /\s(on\w+)[\s\r\n]*=[\s\r\n]*?('|")([\s\S]*?)\2/g,
+ProtectedEvents : /\s\w+_fckprotectedatt="([^"]+)"/g
+}

stud/FCKeditor/editor/_source/internals/fckselection.js

@@ -0,0 +1,20 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckselection.js
+ * 	Active selection functions.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKSelection = FCK.Selection = new Object() ;

stud/FCKeditor/editor/_source/internals/fckselection_gecko.js

@@ -0,0 +1,144 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckselection_gecko.js
+ * 	Active selection functions. (Gecko specific implementation)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Get the selection type (like document.select.type in IE).
+FCKSelection.GetType = function()
+{
+//	if ( ! this._Type )
+//	{
+		// By default set the type to "Text".
+		this._Type = 'Text' ;
+
+		// Check if the actual selection is a Control (IMG, TABLE, HR, etc...).
+		var oSel ;
+		try { oSel = FCK.EditorWindow.getSelection() ; }
+		catch (e) {}
+		
+		if ( oSel && oSel.rangeCount == 1 )
+		{
+			var oRange = oSel.getRangeAt(0) ;
+			if ( oRange.startContainer == oRange.endContainer && (oRange.endOffset - oRange.startOffset) == 1 && oRange.startContainer.nodeType != Node.TEXT_NODE )
+				this._Type = 'Control' ;
+		}
+//	}
+	return this._Type ;
+}
+
+// Retrieves the selected element (if any), just in the case that a single
+// element (object like and image or a table) is selected.
+FCKSelection.GetSelectedElement = function()
+{
+	if ( this.GetType() == 'Control' )
+	{
+		var oSel = FCK.EditorWindow.getSelection() ;
+		return oSel.anchorNode.childNodes[ oSel.anchorOffset ] ;
+	}
+}
+
+FCKSelection.GetParentElement = function()
+{
+	if ( this.GetType() == 'Control' )
+		return FCKSelection.GetSelectedElement().parentNode ;
+	else
+	{
+		var oSel = FCK.EditorWindow.getSelection() ;
+		if ( oSel )
+		{
+			var oNode = oSel.anchorNode ;
+
+			while ( oNode && oNode.nodeType != 1 )
+				oNode = oNode.parentNode ;
+
+			return oNode ;
+		}
+	}
+}
+
+FCKSelection.SelectNode = function( element )
+{
+//	FCK.Focus() ;
+
+	var oRange = FCK.EditorDocument.createRange() ;
+	oRange.selectNode( element ) ;
+
+	var oSel = FCK.EditorWindow.getSelection() ;
+	oSel.removeAllRanges() ;
+	oSel.addRange( oRange ) ;
+}
+
+FCKSelection.Collapse = function( toStart )
+{
+	var oSel = FCK.EditorWindow.getSelection() ;
+	
+	if ( toStart == null || toStart === true )
+		oSel.collapseToStart() ;
+	else
+		oSel.collapseToEnd() ;
+}
+
+// The "nodeTagName" parameter must be Upper Case.
+FCKSelection.HasAncestorNode = function( nodeTagName )
+{
+	var oContainer = this.GetSelectedElement() ;
+	if ( ! oContainer && FCK.EditorWindow )
+	{
+		try		{ oContainer = FCK.EditorWindow.getSelection().getRangeAt(0).startContainer ; }
+		catch(e){}
+	}
+
+	while ( oContainer )
+	{
+		if ( oContainer.nodeType == 1 && oContainer.tagName == nodeTagName ) return true ;
+		oContainer = oContainer.parentNode ;
+	}
+
+	return false ;
+}
+
+// The "nodeTagName" parameter must be Upper Case.
+FCKSelection.MoveToAncestorNode = function( nodeTagName )
+{
+	var oNode ;
+
+	var oContainer = this.GetSelectedElement() ;
+	if ( ! oContainer )
+		oContainer = FCK.EditorWindow.getSelection().getRangeAt(0).startContainer ;
+
+	while ( oContainer )
+	{
+		if ( oContainer.tagName == nodeTagName ) 
+			return oContainer ;
+		oContainer = oContainer.parentNode ;
+	}
+	return null ;
+}
+
+FCKSelection.Delete = function()
+{
+	// Gets the actual selection.
+	var oSel = FCK.EditorWindow.getSelection() ;
+
+	// Deletes the actual selection contents.
+	for ( var i = 0 ; i < oSel.rangeCount ; i++ )
+	{
+		oSel.getRangeAt(i).deleteContents() ;
+	}
+
+	return oSel ;
+}

stud/FCKeditor/editor/_source/internals/fckselection_ie.js

@@ -0,0 +1,151 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckselection_ie.js
+ * 	Active selection functions. (IE specific implementation)
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Get the selection type.
+FCKSelection.GetType = function()
+{
+	return FCK.EditorDocument.selection.type ;
+}
+
+// Retrieves the selected element (if any), just in the case that a single
+// element (object like and image or a table) is selected.
+FCKSelection.GetSelectedElement = function()
+{
+	if ( this.GetType() == 'Control' )
+	{
+		var oRange = FCK.EditorDocument.selection.createRange() ;
+
+		if ( oRange && oRange.item )
+			return FCK.EditorDocument.selection.createRange().item(0) ;
+	}
+}
+
+FCKSelection.GetParentElement = function()
+{
+	switch ( this.GetType() )
+	{
+		case 'Control' :
+			return FCKSelection.GetSelectedElement().parentElement ;
+		case 'None' :
+			return ;
+		default :
+			return FCK.EditorDocument.selection.createRange().parentElement() ;
+	}
+}
+
+FCKSelection.SelectNode = function( node )
+{
+	FCK.Focus() ;
+	FCK.EditorDocument.selection.empty() ;
+
+	try 
+	{
+		// Try to select the node as a control.
+		var oRange = FCK.EditorDocument.body.createControlRange() ;
+		oRange.addElement( node ) ;
+	} 
+	catch(e) 
+	{
+		// If failed, select it as a text range.
+		var oRange = FCK.EditorDocument.selection.createRange() ;
+		oRange.moveToElementText( node ) ;
+	}
+
+	oRange.select() ;
+}
+
+FCKSelection.Collapse = function( toStart )
+{
+	FCK.Focus() ;
+	if ( this.GetType() == 'Text' )
+	{
+		var oRange = FCK.EditorDocument.selection.createRange() ;
+		oRange.collapse( toStart == null || toStart === true ) ;
+		oRange.select() ;
+	}
+}
+
+// The "nodeTagName" parameter must be Upper Case.
+FCKSelection.HasAncestorNode = function( nodeTagName )
+{
+	var oContainer ;
+
+	if ( FCK.EditorDocument.selection.type == "Control" )
+	{
+		oContainer = this.GetSelectedElement() ;
+	}
+	else
+	{
+		var oRange  = FCK.EditorDocument.selection.createRange() ;
+		oContainer = oRange.parentElement() ;
+	}
+
+	while ( oContainer )
+	{
+		if ( oContainer.tagName == nodeTagName ) return true ;
+		oContainer = oContainer.parentNode ;
+	}
+
+	return false ;
+}
+
+// The "nodeTagName" parameter must be UPPER CASE.
+FCKSelection.MoveToAncestorNode = function( nodeTagName )
+{
+	var oNode ;
+
+	if ( FCK.EditorDocument.selection.type == "Control" )
+	{
+		var oRange = FCK.EditorDocument.selection.createRange() ;
+		for ( i = 0 ; i < oRange.length ; i++ )
+		{
+			if (oRange(i).parentNode)
+			{
+				oNode = oRange(i).parentNode ;
+				break ;
+			}
+		}
+	}
+	else
+	{
+		var oRange  = FCK.EditorDocument.selection.createRange() ;
+		oNode = oRange.parentElement() ;
+	}
+
+	while ( oNode && oNode.nodeName != nodeTagName )
+		oNode = oNode.parentNode ;
+
+	return oNode ;
+}
+
+FCKSelection.Delete = function()
+{
+	// Gets the actual selection.
+	var oSel = FCK.EditorDocument.selection ;
+
+	// Deletes the actual selection contents.
+	if ( oSel.type.toLowerCase() != "none" )
+	{
+		oSel.clear() ;
+	}
+
+	return oSel ;
+}
+
+

stud/FCKeditor/editor/_source/internals/fcktablehandler.js

@@ -0,0 +1,383 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktablehandler.js
+ * 	Manage table operations.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKTableHandler = new Object() ;
+
+FCKTableHandler.InsertRow = function()
+{
+	// Get the row where the selection is placed in.	
+	var oRow = FCKSelection.MoveToAncestorNode("TR") ;
+	if ( !oRow ) return ;
+
+	// Create a clone of the row.
+	var oNewRow = oRow.cloneNode( true ) ;
+
+	// Insert the new row (copy) before of it.
+	oRow.parentNode.insertBefore( oNewRow, oRow ) ;
+
+	// Clean the row (it seems that the new row has been added after it).
+	FCKTableHandler.ClearRow( oRow ) ;
+}
+
+FCKTableHandler.DeleteRows = function( row )
+{
+	// If no row has been passed as a parameer,
+	// then get the row where the selection is placed in.	
+	if ( !row )
+		row = FCKSelection.MoveToAncestorNode("TR") ;
+	if ( !row ) return ;
+
+	// Get the row's table.	
+	var oTable = FCKTools.GetElementAscensor( row, 'TABLE' ) ;
+
+	// If just one row is available then delete the entire table.
+	if ( oTable.rows.length == 1 ) 
+	{
+		FCKTableHandler.DeleteTable( oTable ) ;
+		return ;
+	}
+
+	// Delete the row.
+	row.parentNode.removeChild( row ) ;
+}
+
+FCKTableHandler.DeleteTable = function( table )
+{
+	// If no table has been passed as a parameer,
+	// then get the table where the selection is placed in.	
+	if ( !table )
+	{
+		var table = FCKSelection.GetSelectedElement() ;
+		if ( !table || table.tagName != 'TABLE' )
+			table = FCKSelection.MoveToAncestorNode("TABLE") ;
+	}
+	if ( !table ) return ;
+
+	// Delete the table.
+	FCKSelection.SelectNode( table ) ;
+	FCKSelection.Collapse();
+	table.parentNode.removeChild( table ) ;
+}
+
+FCKTableHandler.InsertColumn = function()
+{
+	// Get the cell where the selection is placed in.
+	var oCell = FCKSelection.MoveToAncestorNode("TD") ;
+	if ( !oCell )
+	    oCell =  FCKSelection.MoveToAncestorNode("TH") ;
+
+	if ( !oCell ) return ;
+	
+	// Get the cell's table.
+	var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;
+
+	// Get the index of the column to be created (based on the cell).
+	var iIndex = oCell.cellIndex + 1 ;
+
+	// Loop throw all rows available in the table.
+	for ( var i = 0 ; i < oTable.rows.length ; i++ )
+	{
+		// Get the row.
+		var oRow = oTable.rows[i] ;
+	
+		// If the row doens't have enought cells, ignore it.
+		if ( oRow.cells.length < iIndex )
+			continue ;
+		
+		oCell = oRow.cells[iIndex-1].cloneNode(false) ;
+		
+		if ( FCKBrowserInfo.IsGecko )
+			oCell.innerHTML = GECKO_BOGUS ;
+		
+		// Get the cell that is placed in the new cell place.
+		var oBaseCell = oRow.cells[iIndex] ;
+
+		// If the cell is available (we are not in the last cell of the row).
+		if ( oBaseCell )
+			oRow.insertBefore( oCell, oBaseCell ) ;	// Insert the new cell just before of it.
+		else
+			oRow.appendChild( oCell ) ;				// Append the cell at the end of the row.
+	}
+}
+
+FCKTableHandler.DeleteColumns = function()
+{
+	// Get the cell where the selection is placed in.
+	var oCell = FCKSelection.MoveToAncestorNode('TD') || FCKSelection.MoveToAncestorNode('TH') ;
+
+	if ( !oCell ) return ;
+	
+	// Get the cell's table.	
+	var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;
+
+	// Get the cell index.
+	var iIndex = oCell.cellIndex ;
+
+	// Loop throw all rows (from down to up, because it's possible that some
+	// rows will be deleted).
+	for ( var i = oTable.rows.length - 1 ; i >= 0 ; i-- )
+	{
+		// Get the row.
+		var oRow = oTable.rows[i] ;
+		
+		// If the cell to be removed is the first one and the row has just one cell.
+		if ( iIndex == 0 && oRow.cells.length == 1 )
+		{
+			// Remove the entire row.
+			FCKTableHandler.DeleteRows( oRow ) ;
+			continue ;
+		}
+		
+		// If the cell to be removed exists the delete it.
+		if ( oRow.cells[iIndex] )
+			oRow.removeChild( oRow.cells[iIndex] ) ;
+	}
+}
+
+FCKTableHandler.InsertCell = function( cell )
+{
+	// Get the cell where the selection is placed in.
+	var oCell = cell ? cell : FCKSelection.MoveToAncestorNode("TD") ;
+	if ( !oCell ) return ;
+
+	// Create the new cell element to be added.
+	var oNewCell = FCK.EditorDocument.createElement("TD");
+	if ( FCKBrowserInfo.IsGecko )
+		oNewCell.innerHTML = GECKO_BOGUS ;
+//	oNewCell.innerHTML = "&nbsp;" ;
+
+	// If it is the last cell in the row.
+	if ( oCell.cellIndex == oCell.parentNode.cells.length - 1 )
+	{
+		// Add the new cell at the end of the row.
+		oCell.parentNode.appendChild( oNewCell ) ;
+	}
+	else
+	{
+		// Add the new cell before the next cell (after the active one).
+		oCell.parentNode.insertBefore( oNewCell, oCell.nextSibling ) ;
+	}
+	
+	return oNewCell ;
+}
+
+FCKTableHandler.DeleteCell = function( cell )
+{
+	// If this is the last cell in the row.
+	if ( cell.parentNode.cells.length == 1 )
+	{
+		// Delete the entire row.
+		FCKTableHandler.DeleteRows( FCKTools.GetElementAscensor( cell, 'TR' ) ) ;
+		return ;
+	}
+
+	// Delete the cell from the row.
+	cell.parentNode.removeChild( cell ) ;
+}
+
+FCKTableHandler.DeleteCells = function()
+{
+	var aCells = FCKTableHandler.GetSelectedCells() ;
+	
+	for ( var i = aCells.length - 1 ; i >= 0  ; i-- )
+	{
+		FCKTableHandler.DeleteCell( aCells[i] ) ;
+	}
+}
+
+FCKTableHandler.MergeCells = function()
+{
+	// Get all selected cells.
+	var aCells = FCKTableHandler.GetSelectedCells() ;
+	
+	// At least 2 cells must be selected.
+	if ( aCells.length < 2 )
+		return ;
+		
+	// The merge can occour only if the selected cells are from the same row.
+	if ( aCells[0].parentNode != aCells[aCells.length-1].parentNode )
+		return ;
+
+	// Calculate the new colSpan for the first cell.
+	var iColSpan = isNaN( aCells[0].colSpan ) ? 1 : aCells[0].colSpan ;
+
+	var sHtml = '' ;
+	var oCellsContents = FCK.EditorDocument.createDocumentFragment() ;
+	
+	for ( var i = aCells.length - 1 ; i >= 0 ; i-- )
+	{
+		var eCell = aCells[i] ;
+		
+		// Move its contents to the document fragment.
+		for ( var c = eCell.childNodes.length - 1 ; c >= 0 ; c-- )
+		{
+			var eChild = eCell.removeChild( eCell.childNodes[c] ) ;
+	
+			if ( ( eChild.hasAttribute && eChild.hasAttribute('_moz_editor_bogus_node') ) || ( eChild.getAttribute && eChild.getAttribute( 'type', 2 ) == '_moz' ) )
+				continue ;
+			
+				oCellsContents.insertBefore( eChild, oCellsContents.firstChild ) ;
+		}
+		
+		if ( i > 0 )
+		{
+			// Accumulate the colspan of the cell.
+			iColSpan += isNaN( eCell.colSpan ) ? 1 : eCell.colSpan ;
+
+			// Delete the cell.
+			FCKTableHandler.DeleteCell( eCell ) ;
+		}
+	}
+	
+	// Set the innerHTML of the remaining cell (the first one).
+	aCells[0].colSpan = iColSpan ;
+	
+	if ( FCKBrowserInfo.IsGecko && oCellsContents.childNodes.length == 0 )
+		aCells[0].innerHTML = GECKO_BOGUS ;
+	else
+		aCells[0].appendChild( oCellsContents ) ;
+}
+
+FCKTableHandler.SplitCell = function()
+{
+	// Check that just one cell is selected, otherwise return.
+	var aCells = FCKTableHandler.GetSelectedCells() ;
+	if ( aCells.length != 1 )
+		return ;
+	
+	var aMap = this._CreateTableMap( aCells[0].parentNode.parentNode ) ;
+	var iCellIndex = FCKTableHandler._GetCellIndexSpan( aMap, aCells[0].parentNode.rowIndex , aCells[0] ) ;
+		
+	var aCollCells = this._GetCollumnCells( aMap, iCellIndex ) ;
+	
+	for ( var i = 0 ; i < aCollCells.length ; i++ )
+	{
+		if ( aCollCells[i] == aCells[0] )
+		{
+			var oNewCell = this.InsertCell( aCells[0] ) ;
+			if ( !isNaN( aCells[0].rowSpan ) && aCells[0].rowSpan > 1 )
+				oNewCell.rowSpan = aCells[0].rowSpan ;
+		}
+		else
+		{
+			if ( isNaN( aCollCells[i].colSpan ) )
+				aCollCells[i].colSpan = 2 ;
+			else
+				aCollCells[i].colSpan += 1 ;
+		}
+	}
+}
+
+// Get the cell index from a TableMap.
+FCKTableHandler._GetCellIndexSpan = function( tableMap, rowIndex, cell )
+{
+	if ( tableMap.length < rowIndex + 1 )
+		return null ;
+	
+	var oRow = tableMap[ rowIndex ] ;
+	
+	for ( var c = 0 ; c < oRow.length ; c++ )
+	{
+		if ( oRow[c] == cell )
+			return c ;
+	}
+	
+	return null ;
+}
+
+// Get the cells available in a collumn of a TableMap.
+FCKTableHandler._GetCollumnCells = function( tableMap, collumnIndex )
+{
+	var aCollCells = new Array() ;
+
+	for ( var r = 0 ; r < tableMap.length ; r++ )
+	{
+		var oCell = tableMap[r][collumnIndex] ;
+		if ( oCell && ( aCollCells.length == 0 || aCollCells[ aCollCells.length - 1 ] != oCell ) )
+			aCollCells[ aCollCells.length ] = oCell ;
+	}
+	
+	return aCollCells ;
+}
+
+// This function is quite hard to explain. It creates a matrix representing all cells in a table.
+// The difference here is that the "spanned" cells (colSpan and rowSpan) are duplicated on the matrix
+// cells that are "spanned". For example, a row with 3 cells where the second cell has colSpan=2 and rowSpan=3
+// will produce a bi-dimensional matrix with the following values (representing the cells):
+//		Cell1, Cell2, Cell2, Cell 3
+//		Cell4, Cell2, Cell2, Cell 5
+FCKTableHandler._CreateTableMap = function( table )
+{
+	var aRows = table.rows ;
+	
+	// Row and Collumn counters.
+	var r = -1 ;
+	
+	var aMap = new Array() ;
+	
+	for ( var i = 0 ; i < aRows.length ; i++ )
+	{
+		r++ ;
+		if ( !aMap[r] )
+			aMap[r] = new Array() ;
+		
+		var c = -1 ;
+		
+		for ( var j = 0 ; j < aRows[i].cells.length ; j++ )
+		{
+			var oCell = aRows[i].cells[j] ;
+		
+			c++ ;
+			while ( aMap[r][c] )
+				c++ ;
+			
+			var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ;
+			var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ;
+
+			for ( var rs = 0 ; rs < iRowSpan ; rs++ )
+			{
+				if ( !aMap[r + rs] )
+					aMap[r + rs] = new Array() ;
+					
+				for ( var cs = 0 ; cs < iColSpan ; cs++ )
+				{
+					aMap[r + rs][c + cs] = aRows[i].cells[j] ;
+				}
+			}
+			
+			c += iColSpan - 1 ;
+		}
+	}
+	return aMap ;
+}
+
+FCKTableHandler.ClearRow = function( tr )
+{
+	// Get the array of row's cells.
+	var aCells = tr.cells ;
+
+	// Replace the contents of each cell with "nothing".
+	for ( var i = 0 ; i < aCells.length ; i++ ) 
+	{
+		if ( FCKBrowserInfo.IsGecko )
+			aCells[i].innerHTML = GECKO_BOGUS ;
+		else
+			aCells[i].innerHTML = '' ;
+	}
+}

stud/FCKeditor/editor/_source/internals/fcktablehandler_gecko.js

@@ -0,0 +1,53 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktablehandler_gecko.js
+ * 	Manage table operations (IE specific).
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKTableHandler.GetSelectedCells = function()
+{
+	var aCells = new Array() ;
+
+	var oSelection = FCK.EditorWindow.getSelection() ;
+
+	// If the selection is a text.
+	if ( oSelection.rangeCount == 1 && oSelection.anchorNode.nodeType == 3 )
+	{
+		var oParent = FCKTools.GetElementAscensor( oSelection.anchorNode, 'TD,TH' ) ;
+		
+		if ( oParent )
+		{
+			aCells[0] = oParent ;
+			return aCells ;
+		}	
+	}
+
+	for ( var i = 0 ; i < oSelection.rangeCount ; i++ )
+	{
+		var oRange = oSelection.getRangeAt(i) ;
+		var oCell ;
+		
+		if ( oRange.startContainer.tagName.Equals( 'TD', 'TH' ) )
+			oCell = oRange.startContainer ;
+		else
+			oCell = oRange.startContainer.childNodes[ oRange.startOffset ] ;
+		
+		if ( oCell.tagName.Equals( 'TD', 'TH' ) )
+			aCells[aCells.length] = oCell ;
+	}
+
+	return aCells ;
+}

stud/FCKeditor/editor/_source/internals/fcktablehandler_ie.js

@@ -0,0 +1,54 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktablehandler_ie.js
+ * 	Manage table operations (IE specific).
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKTableHandler.GetSelectedCells = function()
+{
+	var aCells = new Array() ;
+
+	var oRange = FCK.EditorDocument.selection.createRange() ;
+//	var oParent = oRange.parentElement() ;
+	var oParent = FCKSelection.GetParentElement() ;
+	
+	if ( oParent && oParent.tagName.Equals( 'TD', 'TH' ) )
+		aCells[0] = oParent ;
+	else
+	{
+		var oParent = FCKSelection.MoveToAncestorNode( "TABLE" ) ;
+		
+		if ( oParent )
+		{
+			// Loops throw all cells checking if the cell is, or part of it, is inside the selection
+			// and then add it to the selected cells collection.
+			for ( var i = 0 ; i < oParent.cells.length ; i++ )
+			{
+				var oCellRange = FCK.EditorDocument.selection.createRange() ;
+				oCellRange.moveToElementText( oParent.cells[i] ) ;
+				
+				if ( oRange.inRange( oCellRange ) 
+					|| ( oRange.compareEndPoints('StartToStart',oCellRange) >= 0 &&  oRange.compareEndPoints('StartToEnd',oCellRange) <= 0 )
+					|| ( oRange.compareEndPoints('EndToStart',oCellRange) >= 0 &&  oRange.compareEndPoints('EndToEnd',oCellRange) <= 0 ) )
+				{
+					aCells[aCells.length] = oParent.cells[i] ;
+				}
+			}
+		}
+	}
+	
+	return aCells ;
+}

stud/FCKeditor/editor/_source/internals/fcktoolbaritems.js

@@ -0,0 +1,118 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbaritems.js
+ * 	Toolbar items definitions.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarItems = new Object() ;
+FCKToolbarItems.LoadedItems = new Object() ;
+
+FCKToolbarItems.RegisterItem = function( itemName, item )
+{
+	this.LoadedItems[ itemName ] = item ;
+}
+
+FCKToolbarItems.GetItem = function( itemName )
+{
+	var oItem = FCKToolbarItems.LoadedItems[ itemName ] ;
+
+	if ( oItem )
+		return oItem ;
+
+	switch ( itemName )
+	{
+		case 'Source'			: oItem = new FCKToolbarButton( 'Source'	, FCKLang.Source, null, FCK_TOOLBARITEM_ICONTEXT, true, true, 1 ) ; break ;
+		case 'DocProps'			: oItem = new FCKToolbarButton( 'DocProps'	, FCKLang.DocProps, null, null, null, null, 2 ) ; break ;
+		case 'Save'				: oItem = new FCKToolbarButton( 'Save'		, FCKLang.Save, null, null, true, null, 3 ) ; break ;
+		case 'NewPage'			: oItem = new FCKToolbarButton( 'NewPage'	, FCKLang.NewPage, null, null, true, null, 4  ) ; break ;
+		case 'Preview'			: oItem = new FCKToolbarButton( 'Preview'	, FCKLang.Preview, null, null, true, null, 5  ) ; break ;
+		case 'Templates'		: oItem = new FCKToolbarButton( 'Templates'	, FCKLang.Templates, null, null, null, null, 6 ) ; break ;
+		case 'About'			: oItem = new FCKToolbarButton( 'About'		, FCKLang.About, null, null, true, null, 47  ) ; break ;
+
+		case 'Cut'				: oItem = new FCKToolbarButton( 'Cut'		, FCKLang.Cut, null, null, false, true, 7 ) ; break ;
+		case 'Copy'				: oItem = new FCKToolbarButton( 'Copy'		, FCKLang.Copy, null, null, false, true, 8 ) ; break ;
+		case 'Paste'			: oItem = new FCKToolbarButton( 'Paste'		, FCKLang.Paste, null, null, false, true, 9 ) ; break ;
+		case 'PasteText'		: oItem = new FCKToolbarButton( 'PasteText'	, FCKLang.PasteText, null, null, false, true, 10 ) ; break ;
+		case 'PasteWord'		: oItem = new FCKToolbarButton( 'PasteWord'	, FCKLang.PasteWord, null, null, false, true, 11 ) ; break ;
+		case 'Print'			: oItem = new FCKToolbarButton( 'Print'		, FCKLang.Print, null, null, false, true, 12 ) ; break ;
+		case 'SpellCheck'		: oItem = new FCKToolbarButton( 'SpellCheck', FCKLang.SpellCheck, null, null, null, null, 13 ) ; break ;
+		case 'Undo'				: oItem = new FCKToolbarButton( 'Undo'		, FCKLang.Undo, null, null, false, true, 14 ) ; break ;
+		case 'Redo'				: oItem = new FCKToolbarButton( 'Redo'		, FCKLang.Redo, null, null, false, true, 15 ) ; break ;
+		case 'SelectAll'		: oItem = new FCKToolbarButton( 'SelectAll'	, FCKLang.SelectAll, null, null, null, null, 18 ) ; break ;
+		case 'RemoveFormat'		: oItem = new FCKToolbarButton( 'RemoveFormat', FCKLang.RemoveFormat, null, null, false, true, 19 ) ; break ;
+		case 'FitWindow'		: oItem = new FCKToolbarButton( 'FitWindow'	, FCKLang.FitWindow, null, null, true, true, 66 ) ; break ;
+
+		case 'Bold'				: oItem = new FCKToolbarButton( 'Bold'		, FCKLang.Bold, null, null, false, true, 20 ) ; break ;
+		case 'Italic'			: oItem = new FCKToolbarButton( 'Italic'	, FCKLang.Italic, null, null, false, true, 21 ) ; break ;
+		case 'Underline'		: oItem = new FCKToolbarButton( 'Underline'	, FCKLang.Underline, null, null, false, true, 22 ) ; break ;
+		case 'StrikeThrough'	: oItem = new FCKToolbarButton( 'StrikeThrough'	, FCKLang.StrikeThrough, null, null, false, true, 23 ) ; break ;
+		case 'Subscript'		: oItem = new FCKToolbarButton( 'Subscript'		, FCKLang.Subscript, null, null, false, true, 24 ) ; break ;
+		case 'Superscript'		: oItem = new FCKToolbarButton( 'Superscript'	, FCKLang.Superscript, null, null, false, true, 25 ) ; break ;
+
+		case 'OrderedList'		: oItem = new FCKToolbarButton( 'InsertOrderedList'		, FCKLang.NumberedListLbl, FCKLang.NumberedList, null, false, true, 26 ) ; break ;
+		case 'UnorderedList'	: oItem = new FCKToolbarButton( 'InsertUnorderedList'	, FCKLang.BulletedListLbl, FCKLang.BulletedList, null, false, true, 27 ) ; break ;
+		case 'Outdent'			: oItem = new FCKToolbarButton( 'Outdent'	, FCKLang.DecreaseIndent, null, null, false, true, 28 ) ; break ;
+		case 'Indent'			: oItem = new FCKToolbarButton( 'Indent'	, FCKLang.IncreaseIndent, null, null, false, true, 29 ) ; break ;
+
+		case 'Link'				: oItem = new FCKToolbarButton( 'Link'		, FCKLang.InsertLinkLbl, FCKLang.InsertLink, null, false, true, 34 ) ; break ;
+		case 'Unlink'			: oItem = new FCKToolbarButton( 'Unlink'	, FCKLang.RemoveLink, null, null, false, true, 35 ) ; break ;
+		case 'Anchor'			: oItem = new FCKToolbarButton( 'Anchor'	, FCKLang.Anchor, null, null, null, null, 36 ) ; break ;
+
+		case 'Image'			: oItem = new FCKToolbarButton( 'Image'			, FCKLang.InsertImageLbl, FCKLang.InsertImage, null, false, true, 37 ) ; break ;
+		case 'Flash'			: oItem = new FCKToolbarButton( 'Flash'			, FCKLang.InsertFlashLbl, FCKLang.InsertFlash, null, false, true, 38 ) ; break ;
+		case 'Table'			: oItem = new FCKToolbarButton( 'Table'			, FCKLang.InsertTableLbl, FCKLang.InsertTable, null, false, true, 39 ) ; break ;
+		case 'SpecialChar'		: oItem = new FCKToolbarButton( 'SpecialChar'	, FCKLang.InsertSpecialCharLbl, FCKLang.InsertSpecialChar, null, false, true, 42 ) ; break ;
+		case 'Smiley'			: oItem = new FCKToolbarButton( 'Smiley'		, FCKLang.InsertSmileyLbl, FCKLang.InsertSmiley, null, false, true, 41 ) ; break ;
+		case 'PageBreak'		: oItem = new FCKToolbarButton( 'PageBreak'		, FCKLang.PageBreakLbl, FCKLang.PageBreak, null, false, true, 43 ) ; break ;
+		case 'UniversalKey'		: oItem = new FCKToolbarButton( 'UniversalKey'	, FCKLang.UniversalKeyboard , null, null, false, true, 44) ; break ;
+
+		case 'Rule'				: oItem = new FCKToolbarButton( 'InsertHorizontalRule', FCKLang.InsertLineLbl, FCKLang.InsertLine, null, false, true, 40 ) ; break ;
+
+		case 'JustifyLeft'		: oItem = new FCKToolbarButton( 'JustifyLeft'	, FCKLang.LeftJustify, null, null, false, true, 30 ) ; break ;
+		case 'JustifyCenter'	: oItem = new FCKToolbarButton( 'JustifyCenter'	, FCKLang.CenterJustify, null, null, false, true, 31 ) ; break ;
+		case 'JustifyRight'		: oItem = new FCKToolbarButton( 'JustifyRight'	, FCKLang.RightJustify, null, null, false, true, 32 ) ; break ;
+		case 'JustifyFull'		: oItem = new FCKToolbarButton( 'JustifyFull'	, FCKLang.BlockJustify, null, null, false, true, 33 ) ; break ;
+
+		case 'Style'			: oItem = new FCKToolbarStyleCombo() ; break ;
+		case 'FontName'			: oItem = new FCKToolbarFontsCombo() ; break ;
+		case 'FontSize'			: oItem = new FCKToolbarFontSizeCombo() ; break ;
+		case 'FontFormat'		: oItem = new FCKToolbarFontFormatCombo() ; break ;
+
+		case 'TextColor'		: oItem = new FCKToolbarPanelButton( 'TextColor', FCKLang.TextColor, null, null, 45 ) ; break ;
+		case 'BGColor'			: oItem = new FCKToolbarPanelButton( 'BGColor'	, FCKLang.BGColor, null, null, 46 ) ; break ;
+
+		case 'Find'				: oItem = new FCKToolbarButton( 'Find'		, FCKLang.Find, null, null, null, null, 16 ) ; break ;
+		case 'Replace'			: oItem = new FCKToolbarButton( 'Replace'	, FCKLang.Replace, null, null, null, null, 17 ) ; break ;
+
+		case 'Form'				: oItem = new FCKToolbarButton( 'Form'			, FCKLang.Form, null, null, null, null, 48 ) ; break ;
+		case 'Checkbox'			: oItem = new FCKToolbarButton( 'Checkbox'		, FCKLang.Checkbox, null, null, null, null, 49 ) ; break ;
+		case 'Radio'			: oItem = new FCKToolbarButton( 'Radio'			, FCKLang.RadioButton, null, null, null, null, 50 ) ; break ;
+		case 'TextField'		: oItem = new FCKToolbarButton( 'TextField'		, FCKLang.TextField, null, null, null, null, 51 ) ; break ;
+		case 'Textarea'			: oItem = new FCKToolbarButton( 'Textarea'		, FCKLang.Textarea, null, null, null, null, 52 ) ; break ;
+		case 'HiddenField'		: oItem = new FCKToolbarButton( 'HiddenField'	, FCKLang.HiddenField, null, null, null, null, 56 ) ; break ;
+		case 'Button'			: oItem = new FCKToolbarButton( 'Button'		, FCKLang.Button, null, null, null, null, 54 ) ; break ;
+		case 'Select'			: oItem = new FCKToolbarButton( 'Select'		, FCKLang.SelectionField, null, null, null, null, 53 ) ; break ;
+		case 'ImageButton'		: oItem = new FCKToolbarButton( 'ImageButton'	, FCKLang.ImageButton, null, null, null, null, 55 ) ; break ;
+
+		default:
+			alert( FCKLang.UnknownToolbarItem.replace( /%1/g, itemName ) ) ;
+			return null ;
+	}
+
+	FCKToolbarItems.LoadedItems[ itemName ] = oItem ;
+
+	return oItem ;
+}

stud/FCKeditor/editor/_source/internals/fcktoolbarset.js

@@ -0,0 +1,352 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktoolbarset.js
+ * 	Defines the FCKToolbarSet object that is used to load and draw the 
+ * 	toolbar.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+function FCKToolbarSet_Create( overhideLocation )
+{
+	var oToolbarSet ;
+	
+	var sLocation = overhideLocation || FCKConfig.ToolbarLocation ;
+	switch ( sLocation )
+	{
+		case 'In' :
+				document.getElementById( 'xToolbarRow' ).style.display = '' ;
+				oToolbarSet = new FCKToolbarSet( document ) ;
+			break ;
+			
+//		case 'OutTop' :
+			// Not supported.
+			
+		default :
+			FCK.Events.AttachEvent( 'OnBlur', FCK_OnBlur ) ;
+			FCK.Events.AttachEvent( 'OnFocus', FCK_OnFocus ) ;
+
+			var eToolbarTarget ;
+			
+			// Out:[TargetWindow]([TargetId])
+			var oOutMatch = sLocation.match( /^Out:(.+)\((\w+)\)$/ ) ;
+			if ( oOutMatch )
+			{
+				eToolbarTarget = eval( 'parent.' + oOutMatch[1] ).document.getElementById( oOutMatch[2] ) ;
+			}
+			else
+			{
+				// Out:[TargetId]
+				oOutMatch = sLocation.match( /^Out:(\w+)$/ ) ;
+				if ( oOutMatch )
+					eToolbarTarget = parent.document.getElementById( oOutMatch[1] ) ;
+			}
+			
+			if ( !eToolbarTarget )
+			{
+				alert( 'Invalid value for "ToolbarLocation"' ) ;
+				return this._Init( 'In' ) ;
+			}
+			
+			// If it is a shared toolbar, it may be already available in the target element.
+			if ( oToolbarSet = eToolbarTarget.__FCKToolbarSet )
+				break ;
+
+			// Create the IFRAME that will hold the toolbar inside the target element.
+			var eToolbarIFrame = FCKTools.GetElementDocument( eToolbarTarget ).createElement( 'iframe' ) ;
+			eToolbarIFrame.frameBorder = 0 ;
+			eToolbarIFrame.width = '100%' ;
+			eToolbarIFrame.height = '10' ;
+			eToolbarTarget.appendChild( eToolbarIFrame ) ;
+			eToolbarIFrame.unselectable = 'on' ;
+			
+			// Write the basic HTML for the toolbar (copy from the editor main page).
+			var eTargetDocument = eToolbarIFrame.contentWindow.document ;
+			eTargetDocument.open() ;
+			eTargetDocument.write( '<html><head><script type="text/javascript"> window.onload = window.onresize = function() { window.frameElement.height = document.body.scrollHeight ; } </script></head><body style="overflow: hidden">' + document.getElementById( 'xToolbarSpace' ).innerHTML + '</body></html>' ) ;
+			eTargetDocument.close() ;
+			
+			eTargetDocument.oncontextmenu = FCKTools.CancelEvent ;
+
+			// Load external resources (must be done here, otherwise Firefox will not
+			// have the document DOM ready to be used right away.
+			FCKTools.AppendStyleSheet( eTargetDocument, FCKConfig.SkinPath + 'fck_editor.css' ) ;
+			
+			oToolbarSet = eToolbarTarget.__FCKToolbarSet = new FCKToolbarSet( eTargetDocument ) ;
+			oToolbarSet._IFrame = eToolbarIFrame ;
+
+			if ( FCK.IECleanup )
+				FCK.IECleanup.AddItem( eToolbarTarget, FCKToolbarSet_Target_Cleanup ) ;
+	}
+	
+	oToolbarSet.CurrentInstance = FCK ;
+
+	FCK.AttachToOnSelectionChange( oToolbarSet.RefreshItemsState ) ;
+
+	return oToolbarSet ;
+}
+
+function FCK_OnBlur( editorInstance )
+{
+	var eToolbarSet = editorInstance.ToolbarSet ;
+	
+	if ( eToolbarSet.CurrentInstance == editorInstance )
+		eToolbarSet.Disable() ;
+}
+
+function FCK_OnFocus( editorInstance )
+{
+	var oToolbarset = editorInstance.ToolbarSet ;
+	var oInstance = editorInstance || FCK ;
+	
+	// Unregister the toolbar window from the current instance.
+	oToolbarset.CurrentInstance.FocusManager.RemoveWindow( oToolbarset._IFrame.contentWindow ) ;
+	
+	// Set the new current instance.
+	oToolbarset.CurrentInstance = oInstance ;
+	
+	// Register the toolbar window in the current instance.
+	oInstance.FocusManager.AddWindow( oToolbarset._IFrame.contentWindow, true ) ;
+
+	oToolbarset.Enable() ;
+}
+
+function FCKToolbarSet_Cleanup()
+{
+	this._TargetElement = null ;
+	this._IFrame = null ;
+}
+
+function FCKToolbarSet_Target_Cleanup()
+{
+	this.__FCKToolbarSet = null ;
+}
+
+var FCKToolbarSet = function( targetDocument )
+{
+	this._Document = targetDocument ; 
+
+	// Get the element that will hold the elements structure.
+	this._TargetElement	= targetDocument.getElementById( 'xToolbar' ) ;
+	
+	// Setup the expand and collapse handlers.
+	var eExpandHandle	= targetDocument.getElementById( 'xExpandHandle' ) ;
+	var eCollapseHandle	= targetDocument.getElementById( 'xCollapseHandle' ) ;
+
+	eExpandHandle.title		= FCKLang.ToolbarExpand ;
+	eExpandHandle.onclick	= FCKToolbarSet_Expand_OnClick ;
+	
+	eCollapseHandle.title	= FCKLang.ToolbarCollapse ;
+	eCollapseHandle.onclick	= FCKToolbarSet_Collapse_OnClick ;
+
+	// Set the toolbar state at startup.
+	if ( !FCKConfig.ToolbarCanCollapse || FCKConfig.ToolbarStartExpanded )
+		this.Expand() ;
+	else
+		this.Collapse() ;
+
+	// Enable/disable the collapse handler
+	eCollapseHandle.style.display = FCKConfig.ToolbarCanCollapse ? '' : 'none' ;
+
+	if ( FCKConfig.ToolbarCanCollapse )
+		eCollapseHandle.style.display = '' ;
+	else
+		targetDocument.getElementById( 'xTBLeftBorder' ).style.display = '' ;
+		
+	// Set the default properties.
+	this.Toolbars = new Array() ;
+	this.IsLoaded = false ;
+
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( this, FCKToolbarSet_Cleanup ) ;
+}
+
+function FCKToolbarSet_Expand_OnClick()
+{
+	FCK.ToolbarSet.Expand() ;
+}
+
+function FCKToolbarSet_Collapse_OnClick()
+{
+	FCK.ToolbarSet.Collapse() ;
+}
+
+FCKToolbarSet.prototype.Expand = function()
+{
+	this._ChangeVisibility( false ) ;
+}
+
+FCKToolbarSet.prototype.Collapse = function()
+{
+	this._ChangeVisibility( true ) ;
+}
+
+FCKToolbarSet.prototype._ChangeVisibility = function( collapse )
+{
+	this._Document.getElementById( 'xCollapsed' ).style.display = collapse ? '' : 'none' ;
+	this._Document.getElementById( 'xExpanded' ).style.display = collapse ? 'none' : '' ;
+	
+	if ( FCKBrowserInfo.IsGecko )
+	{
+		// I had to use "setTimeout" because Gecko was not responding in a right
+		// way when calling window.onresize() directly.
+		FCKTools.RunFunction( window.onresize ) ;
+	}
+}
+
+FCKToolbarSet.prototype.Load = function( toolbarSetName )
+{
+	this.Name = toolbarSetName ;
+
+	this.Items = new Array() ;
+	
+	// Reset the array of toolbat items that are active only on WYSIWYG mode.
+	this.ItemsWysiwygOnly = new Array() ;
+
+	// Reset the array of toolbar items that are sensitive to the cursor position.
+	this.ItemsContextSensitive = new Array() ;
+	
+	// Cleanup the target element.
+	this._TargetElement.innerHTML = '' ;
+	
+	var ToolbarSet = FCKConfig.ToolbarSets[toolbarSetName] ;
+	
+	if ( !ToolbarSet )
+	{
+		alert( FCKLang.UnknownToolbarSet.replace( /%1/g, toolbarSetName ) ) ;
+		return ;
+	}
+	
+	this.Toolbars = new Array() ;
+	
+	for ( var x = 0 ; x < ToolbarSet.length ; x++ ) 
+	{
+		var oToolbarItems = ToolbarSet[x] ;
+		
+		var oToolbar ;
+		
+		if ( typeof( oToolbarItems ) == 'string' )
+		{
+			if ( oToolbarItems == '/' )
+				oToolbar = new FCKToolbarBreak() ;
+		}
+		else
+		{
+			oToolbar = new FCKToolbar() ;
+			
+			for ( var j = 0 ; j < oToolbarItems.length ; j++ ) 
+			{
+				var sItem = oToolbarItems[j] ;
+				
+				if ( sItem == '-')
+					oToolbar.AddSeparator() ;
+				else
+				{
+					var oItem = FCKToolbarItems.GetItem( sItem ) ;
+					if ( oItem )
+					{
+						oToolbar.AddItem( oItem ) ;
+
+						this.Items.push( oItem ) ;
+
+						if ( !oItem.SourceView )
+							this.ItemsWysiwygOnly.push( oItem ) ;
+						
+						if ( oItem.ContextSensitive )
+							this.ItemsContextSensitive.push( oItem ) ;
+					}
+				}
+			}
+			
+			// oToolbar.AddTerminator() ;
+		}
+		
+		oToolbar.Create( this._TargetElement ) ;
+
+		this.Toolbars[ this.Toolbars.length ] = oToolbar ;
+	}
+	
+	FCKTools.DisableSelection( this._Document.getElementById( 'xCollapseHandle' ).parentNode ) ;
+
+	if ( FCK.Status != FCK_STATUS_COMPLETE )
+		FCK.Events.AttachEvent( 'OnStatusChange', this.RefreshModeState ) ;
+	else
+		this.RefreshModeState() ;
+
+	this.IsLoaded = true ;
+	this.IsEnabled = true ;
+
+	FCKTools.RunFunction( this.OnLoad ) ;
+}
+
+FCKToolbarSet.prototype.Enable = function()
+{
+	if ( this.IsEnabled )
+		return ;
+
+	this.IsEnabled = true ;
+
+	var aItems = this.Items ;
+	for ( var i = 0 ; i < aItems.length ; i++ )
+		aItems[i].RefreshState() ;
+}
+
+FCKToolbarSet.prototype.Disable = function()
+{
+	if ( !this.IsEnabled )
+		return ;
+
+	this.IsEnabled = false ;
+
+	var aItems = this.Items ;
+	for ( var i = 0 ; i < aItems.length ; i++ )
+		aItems[i].Disable() ;
+}
+
+FCKToolbarSet.prototype.RefreshModeState = function( editorInstance )
+{
+	if ( FCK.Status != FCK_STATUS_COMPLETE )
+		return ;
+
+	var oToolbarSet = editorInstance ? editorInstance.ToolbarSet : this ;
+	var aItems = oToolbarSet.ItemsWysiwygOnly ;
+	
+	if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG )
+	{
+		// Enable all buttons that are available on WYSIWYG mode only.
+		for ( var i = 0 ; i < aItems.length ; i++ )
+			aItems[i].Enable() ;
+
+		// Refresh the buttons state.
+		oToolbarSet.RefreshItemsState( editorInstance ) ;
+	}
+	else
+	{
+		// Refresh the buttons state.
+		oToolbarSet.RefreshItemsState( editorInstance ) ;
+
+		// Disable all buttons that are available on WYSIWYG mode only.
+		for ( var i = 0 ; i < aItems.length ; i++ )
+			aItems[i].Disable() ;
+	}	
+}
+
+FCKToolbarSet.prototype.RefreshItemsState = function( editorInstance )
+{
+	
+	var aItems = ( editorInstance ? editorInstance.ToolbarSet : this ).ItemsContextSensitive ;
+	
+	for ( var i = 0 ; i < aItems.length ; i++ )
+		aItems[i].RefreshState() ;
+}

stud/FCKeditor/editor/_source/internals/fcktools.js

@@ -0,0 +1,236 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktools.js
+ * 	Utility functions.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKTools = new Object() ;
+
+FCKTools.AppendStyleSheet = function( documentElement, cssFileUrlOrArray )
+{
+	if ( typeof( cssFileUrlOrArray ) == 'string' )
+		return this._AppendStyleSheet( documentElement, cssFileUrlOrArray ) ;
+	else
+	{
+		for ( var i = 0 ; i < cssFileUrlOrArray.length ; i++ )
+			this._AppendStyleSheet( documentElement, cssFileUrlOrArray[i] ) ;
+	}
+}
+
+/**
+ * Gets the value of the hidden INPUT element that is associated to the editor.
+ * This element has its ID set to the editor's instance name so the user refers
+ * to the instance name when getting the posted data.
+ */
+FCKTools.GetLinkedFieldValue = function()
+{
+	return FCK.LinkedField.value ;
+}
+
+/**
+ * Attachs a function call to the submit event of the linked field form. This
+ * function us generally used to update the linked field value before
+ * submitting the form.
+ */
+FCKTools.AttachToLinkedFieldFormSubmit = function( functionPointer )
+{
+	// Gets the linked field form
+	var oForm = FCK.LinkedField.form ;
+	
+	// Return now if no form is available
+	if (!oForm) return ;
+
+	// Attaches the functionPointer call to the onsubmit event
+	if ( FCKBrowserInfo.IsIE )
+		oForm.attachEvent( "onsubmit", functionPointer ) ;
+	else
+		oForm.addEventListener( 'submit', functionPointer, false ) ;
+	
+	//**
+	// Attaches the functionPointer call to the submit method 
+	// This is done because IE doesn't fire onsubmit when the submit method is called
+	// BEGIN --
+	
+	// Creates a Array in the form object that will hold all Attached function call
+	// (in the case there are more than one editor in the same page)
+	if (! oForm.updateFCKeditor) oForm.updateFCKeditor = new Array() ;
+	
+	// Adds the function pointer to the array of functions to call when "submit" is called
+	oForm.updateFCKeditor[oForm.updateFCKeditor.length] = functionPointer ;
+
+	// Switches the original submit method with a new one that first call all functions
+	// on the above array and the call the original submit
+	// IE sees it oForm.submit function as an 'object'.
+	if (! oForm.originalSubmit && ( typeof( oForm.submit ) == 'function' || ( !oForm.submit.tagName && !oForm.submit.length ) ) )
+	{
+		// Creates a copy of the original submit
+		oForm.originalSubmit = oForm.submit ;
+		
+		// Creates our replacement for the submit
+		oForm.submit = FCKTools_SubmitReplacer ;
+	}
+	// END --
+}
+
+function FCKTools_SubmitReplacer()
+{
+	if (this.updateFCKeditor)
+	{
+		// Calls all functions in the functions array
+		for (var i = 0 ; i < this.updateFCKeditor.length ; i++)
+			this.updateFCKeditor[i]() ;
+	}
+	// Calls the original "submit"
+	this.originalSubmit() ;
+}
+
+// Get the window object where the element is placed in.
+FCKTools.GetElementWindow = function( element )
+{
+	return this.GetDocumentWindow( this.GetElementDocument( element ) ) ;
+}
+
+FCKTools.GetDocumentWindow = function( doc )
+{
+	// With Safari, there is not way to retrieve the window from the document, so we must fix it.
+	if ( FCKBrowserInfo.IsSafari && !doc.parentWindow )
+		this.FixDocumentParentWindow( window.top ) ;
+	
+	return doc.parentWindow || doc.defaultView ;
+}
+
+/*
+	This is a Safari specific function that fix the reference to the parent 
+	window from the document object.
+*/
+FCKTools.FixDocumentParentWindow = function( targetWindow )
+{
+	targetWindow.document.parentWindow = targetWindow ; 
+	
+	for ( var i = 0 ; i < targetWindow.frames.length ; i++ )
+		FCKTools.FixDocumentParentWindow( targetWindow.frames[i] ) ;
+}
+
+FCKTools.GetParentWindow = function( document )
+{
+	return document.contentWindow ? document.contentWindow : document.parentWindow ;
+}
+
+FCKTools.HTMLEncode = function( text )
+{
+	if ( !text )
+		return '' ;
+
+	text = text.replace( /&/g, '&amp;' ) ;
+	text = text.replace( /</g, '&lt;' ) ;
+	text = text.replace( />/g, '&gt;' ) ;
+
+	return text ;
+}
+
+/**
+ * Adds an option to a SELECT element.
+ */
+FCKTools.AddSelectOption = function( selectElement, optionText, optionValue )
+{
+	var oOption = FCKTools.GetElementDocument( selectElement ).createElement( "OPTION" ) ;
+
+	oOption.text	= optionText ;
+	oOption.value	= optionValue ;	
+
+	selectElement.options.add(oOption) ;
+
+	return oOption ;
+}
+
+FCKTools.RunFunction = function( func, thisObject, paramsArray, timerWindow )
+{
+	if ( func )
+		this.SetTimeout( func, 0, thisObject, paramsArray, timerWindow ) ;
+}
+
+FCKTools.SetTimeout = function( func, milliseconds, thisObject, paramsArray, timerWindow )
+{
+	return ( timerWindow || window ).setTimeout( 
+		function()
+		{
+			if ( paramsArray )
+				func.apply( thisObject, [].concat( paramsArray ) ) ;
+			else
+				func.apply( thisObject ) ;
+		},
+		milliseconds ) ;
+}
+
+FCKTools.SetInterval = function( func, milliseconds, thisObject, paramsArray, timerWindow )
+{
+	return ( timerWindow || window ).setInterval( 
+		function()
+		{
+			func.apply( thisObject, paramsArray || [] ) ;
+		},
+		milliseconds ) ;
+}
+
+FCKTools.ConvertStyleSizeToHtml = function( size )
+{
+	return size.endsWith( '%' ) ? size : parseInt( size ) ;
+}
+
+FCKTools.ConvertHtmlSizeToStyle = function( size )
+{
+	return size.endsWith( '%' ) ? size : ( size + 'px' ) ;
+}
+
+// START iCM MODIFICATIONS
+// Amended to accept a list of one or more ascensor tag names
+// Amended to check the element itself before working back up through the parent hierarchy
+FCKTools.GetElementAscensor = function( element, ascensorTagNames )
+{
+//	var e = element.parentNode ;
+	var e = element ;
+	var lstTags = "," + ascensorTagNames.toUpperCase() + "," ;
+
+	while ( e )
+	{
+		if ( lstTags.indexOf( "," + e.nodeName.toUpperCase() + "," ) != -1 )
+			return e ;
+
+		e = e.parentNode ;
+	}
+	return null ;
+}
+// END iCM MODIFICATIONS
+
+FCKTools.CreateEventListener = function( func, params )
+{
+	var f = function()
+	{
+		var aAllParams = [] ;
+		
+		for ( var i = 0 ; i < arguments.length ; i++ )
+			aAllParams.push( arguments[i] ) ;
+
+		func.apply( this, aAllParams.concat( params ) ) ;
+	} 
+
+	return f ;
+}
+
+FCKTools.GetElementDocument = function ( element )
+{
+	return element.ownerDocument || element.document ;
+}

stud/FCKeditor/editor/_source/internals/fcktools_gecko.js

@@ -0,0 +1,231 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktools_gecko.js
+ * 	Utility functions. (Gecko version).
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Constant for the Gecko Bogus Node.
+var GECKO_BOGUS = FCKBrowserInfo.IsGecko ? '<br _moz_editor_bogus_node="TRUE">' : '' ;
+
+FCKTools.CancelEvent = function( e )
+{
+	if ( e )
+		e.preventDefault() ;
+}
+
+FCKTools.DisableSelection = function( element )
+{
+	if ( FCKBrowserInfo.IsGecko )
+		element.style.MozUserSelect	= 'none' ;	// Gecko only.	
+	else
+		element.style.userSelect	= 'none' ;	// CSS3 (not supported yet).
+}
+
+// Appends a CSS file to a document.
+FCKTools._AppendStyleSheet = function( documentElement, cssFileUrl )
+{
+	var e = documentElement.createElement( 'LINK' ) ;
+	e.rel	= 'stylesheet' ;
+	e.type	= 'text/css' ;
+	e.href	= cssFileUrl ;
+	documentElement.getElementsByTagName("HEAD")[0].appendChild( e ) ;
+	return e ;
+}
+
+// Removes all attributes and values from the element.
+FCKTools.ClearElementAttributes = function( element )
+{
+	// Loop throw all attributes in the element
+	for ( var i = 0 ; i < element.attributes.length ; i++ )
+	{
+		// Remove the element by name.
+		element.removeAttribute( element.attributes[i].name, 0 ) ;	// 0 : Case Insensitive
+	}
+}
+
+// Returns an Array of strings with all defined in the elements inside another element.
+FCKTools.GetAllChildrenIds = function( parentElement )
+{
+	// Create the array that will hold all Ids.
+	var aIds = new Array() ;
+	
+	// Define a recursive function that search for the Ids.
+	var fGetIds = function( parent )
+	{
+		for ( var i = 0 ; i < parent.childNodes.length ; i++ )
+		{
+			var sId = parent.childNodes[i].id ;
+			
+			// Check if the Id is defined for the element.
+			if ( sId && sId.length > 0 ) aIds[ aIds.length ] = sId ;
+			
+			// Recursive call.
+			fGetIds( parent.childNodes[i] ) ;
+		}
+	}
+	
+	// Start the recursive calls.
+	fGetIds( parentElement ) ;
+
+	return aIds ;
+}
+
+FCKTools.RemoveOuterTags = function( e )
+{
+	var oFragment = e.ownerDocument.createDocumentFragment() ;
+			
+	for ( var i = 0 ; i < e.childNodes.length ; i++ )
+		oFragment.appendChild( e.childNodes[i] ) ;
+			
+	e.parentNode.replaceChild( oFragment, e ) ;
+}
+
+FCKTools.CreateXmlObject = function( object )
+{
+	switch ( object )
+	{
+		case 'XmlHttp' :
+			return new XMLHttpRequest() ;
+		case 'DOMDocument' :
+			return document.implementation.createDocument( '', '', null ) ;
+	}
+	return null ;
+}
+
+FCKTools.GetScrollPosition = function( relativeWindow )
+{
+	return { X : relativeWindow.pageXOffset, Y : relativeWindow.pageYOffset } ;
+}
+
+FCKTools.AddEventListener = function( sourceObject, eventName, listener )
+{
+	sourceObject.addEventListener( eventName, listener, false ) ;
+}
+
+FCKTools.RemoveEventListener = function( sourceObject, eventName, listener )
+{
+	sourceObject.removeEventListener( eventName, listener, false ) ;
+}
+
+// Listeners attached with this function cannot be detached.
+FCKTools.AddEventListenerEx = function( sourceObject, eventName, listener, paramsArray )
+{
+	sourceObject.addEventListener( 
+		eventName, 
+		function( e )
+		{
+			listener.apply( sourceObject, [ e ].concat( paramsArray || [] ) ) ;
+		},
+		false 
+	) ;
+}
+
+// Returns and object with the "Width" and "Height" properties.
+FCKTools.GetViewPaneSize = function( win )
+{
+	return { Width : win.innerWidth, Height : win.innerHeight } ;
+}
+
+FCKTools.SaveStyles = function( element )
+{
+	var oSavedStyles = new Object() ;
+	
+	if ( element.className.length > 0 )
+	{
+		oSavedStyles.Class = element.className ;
+		element.className = '' ;
+	}
+
+	var sInlineStyle = element.getAttribute( 'style' ) ;
+
+	if ( sInlineStyle && sInlineStyle.length > 0 )
+	{
+		oSavedStyles.Inline = sInlineStyle ;
+		element.setAttribute( 'style', '', 0 ) ;	// 0 : Case Insensitive
+	}
+
+	return oSavedStyles ;
+}
+
+FCKTools.RestoreStyles = function( element, savedStyles )
+{
+	element.className = savedStyles.Class || '' ;
+
+	if ( savedStyles.Inline )
+		element.setAttribute( 'style', savedStyles.Inline, 0 ) ;	// 0 : Case Insensitive
+	else
+		element.removeAttribute( 'style', 0 ) ;
+}
+
+FCKTools.RegisterDollarFunction = function( targetWindow )
+{
+	targetWindow.$ = function( id ) 
+	{ 
+		return this.document.getElementById( id ) ;
+	} ;
+}
+
+FCKTools.AppendElement = function( target, elementName )
+{
+	return target.appendChild( target.ownerDocument.createElement( elementName ) ) ;
+}
+
+// Get the coordinates of an element.
+//		@el : The element to get the position.
+//		@relativeWindow: The window to which we want the coordinates relative to.
+FCKTools.GetElementPosition = function( el, relativeWindow )
+{
+	// Initializes the Coordinates object that will be returned by the function.
+	var c = { X:0, Y:0 } ;
+	
+	var oWindow = relativeWindow || window ;
+
+	var oOwnerWindow = FCKTools.GetElementWindow( el ) ;
+
+	// Loop throw the offset chain.
+	while ( el )
+	{
+		var sPosition = oOwnerWindow.getComputedStyle(el, '').position ;
+
+		// Check for non "static" elements.
+		// 'FCKConfig.FloatingPanelsZIndex' -- Submenus are under a positioned IFRAME.
+		if ( sPosition && sPosition != 'static' && el.style.zIndex != FCKConfig.FloatingPanelsZIndex ) 
+			break ;
+
+		c.X += el.offsetLeft - el.scrollLeft ;
+		c.Y += el.offsetTop - el.scrollTop  ;
+
+		if ( el.offsetParent )
+			el = el.offsetParent ;
+		else
+		{
+			if ( oOwnerWindow != oWindow )
+			{
+				if ( el = oOwnerWindow.frameElement )
+					oOwnerWindow = FCKTools.GetElementWindow( el ) ;
+			}
+			else
+			{
+				c.X += el.scrollLeft ;
+				c.Y += el.scrollTop  ;
+				break ;
+			}
+		}
+	}
+
+	// Return the Coordinates object
+	return c ;
+}

stud/FCKeditor/editor/_source/internals/fcktools_ie.js

@@ -0,0 +1,202 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fcktools_ie.js
+ * 	Utility functions. (IE version).
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKTools.CancelEvent = function( e )
+{
+	return false ;
+}
+
+// Appends one or more CSS files to a document.
+FCKTools._AppendStyleSheet = function( documentElement, cssFileUrl )
+{
+	return documentElement.createStyleSheet( cssFileUrl ).owningElement ;
+}
+
+// Removes all attributes and values from the element.
+FCKTools.ClearElementAttributes = function( element )
+{
+	element.clearAttributes() ;
+}
+
+FCKTools.GetAllChildrenIds = function( parentElement )
+{
+	var aIds = new Array() ;
+	for ( var i = 0 ; i < parentElement.all.length ; i++ )
+	{
+		var sId = parentElement.all[i].id ;
+		if ( sId && sId.length > 0 )
+			aIds[ aIds.length ] = sId ;
+	}
+	return aIds ;
+}
+
+FCKTools.RemoveOuterTags = function( e )
+{
+	e.insertAdjacentHTML( 'beforeBegin', e.innerHTML ) ;
+	e.parentNode.removeChild( e ) ;
+}
+
+FCKTools.CreateXmlObject = function( object )
+{
+	var aObjs ;
+	
+	switch ( object )
+	{
+		case 'XmlHttp' :
+			aObjs = [ 'MSXML2.XmlHttp', 'Microsoft.XmlHttp' ] ;
+			break ;
+				
+		case 'DOMDocument' :
+			aObjs = [ 'MSXML2.DOMDocument', 'Microsoft.XmlDom' ] ;
+			break ;
+	}
+
+	for ( var i = 0 ; i < 2 ; i++ )
+	{
+		try { return new ActiveXObject( aObjs[i] ) ; }
+		catch (e) 
+		{}
+	}
+	
+	if ( FCKLang.NoActiveX )
+	{
+		alert( FCKLang.NoActiveX ) ;
+		FCKLang.NoActiveX = null ;
+	}
+}
+
+FCKTools.DisableSelection = function( element )
+{
+	element.unselectable = 'on' ;
+
+	var e, i = 0 ;
+	while ( e = element.all[ i++ ] )
+	{
+		switch ( e.tagName )
+		{
+			case 'IFRAME' :
+			case 'TEXTAREA' :
+			case 'INPUT' :
+			case 'SELECT' :
+				/* Ignore the above tags */
+				break ;
+			default :
+				e.unselectable = 'on' ;
+		}
+	}
+}
+
+FCKTools.GetScrollPosition = function( relativeWindow )
+{
+	var oDoc = relativeWindow.document ;
+
+	// Try with the doc element.
+	var oPos = { X : oDoc.documentElement.scrollLeft, Y : oDoc.documentElement.scrollTop } ;
+	
+	if ( oPos.X > 0 || oPos.Y > 0 )
+		return oPos ;
+
+	// If no scroll, try with the body.
+	return { X : oDoc.body.scrollLeft, Y : oDoc.body.scrollTop } ;
+}
+
+FCKTools.AddEventListener = function( sourceObject, eventName, listener )
+{
+	sourceObject.attachEvent( 'on' + eventName, listener ) ;
+}
+
+FCKTools.RemoveEventListener = function( sourceObject, eventName, listener )
+{
+	sourceObject.detachEvent( 'on' + eventName, listener ) ;
+}
+
+// Listeners attached with this function cannot be detached.
+FCKTools.AddEventListenerEx = function( sourceObject, eventName, listener, paramsArray )
+{
+	// Ok... this is a closures party, but is the only way to make it clean of memory leaks.
+	var o = new Object() ;
+	o.Source = sourceObject ;
+	o.Params = paramsArray || [] ;	// Memory leak if we have DOM objects here.
+	o.Listener = function( ev )
+	{
+		return listener.apply( o.Source, [ ev ].concat( o.Params ) ) ;
+	}
+	
+	if ( FCK.IECleanup )
+		FCK.IECleanup.AddItem( null, function() { o.Source = null ; o.Params = null ; } ) ;
+	
+	sourceObject.attachEvent( 'on' + eventName, o.Listener ) ;
+
+	sourceObject = null ;	// Memory leak cleaner (because of the above closure).
+	paramsArray = null ;	// Memory leak cleaner (because of the above closure).
+}
+
+// Returns and object with the "Width" and "Height" properties.
+FCKTools.GetViewPaneSize = function( win )
+{
+	var oSizeSource ;
+	
+	var oDoc = win.document.documentElement ;
+	if ( oDoc && oDoc.clientWidth )				// IE6 Strict Mode
+		oSizeSource = oDoc ;
+	else
+		oSizeSource = top.document.body ;		// Other IEs
+	
+	if ( oSizeSource )
+		return { Width : oSizeSource.clientWidth, Height : oSizeSource.clientHeight } ;
+	else
+		return { Width : 0, Height : 0 } ;
+}
+
+FCKTools.SaveStyles = function( element )
+{
+	var oSavedStyles = new Object() ;
+	
+	if ( element.className.length > 0 )
+	{
+		oSavedStyles.Class = element.className ;
+		element.className = '' ;
+	}
+
+	var sInlineStyle = element.style.cssText ;
+
+	if ( sInlineStyle.length > 0 )
+	{
+		oSavedStyles.Inline = sInlineStyle ;
+		element.style.cssText = '' ;
+	}
+	
+	return oSavedStyles ;
+}
+
+FCKTools.RestoreStyles = function( element, savedStyles )
+{
+	element.className		= savedStyles.Class || '' ;
+	element.style.cssText	= savedStyles.Inline || '' ;
+}
+
+FCKTools.RegisterDollarFunction = function( targetWindow )
+{
+	targetWindow.$ = targetWindow.document.getElementById ;
+}
+
+FCKTools.AppendElement = function( target, elementName )
+{
+	return target.appendChild( this.GetElementDocument( target ).createElement( elementName ) ) ;
+}

stud/FCKeditor/editor/_source/internals/fckundo_gecko.js

@@ -0,0 +1,23 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckundo_gecko.js
+ * 	Fake implementation to ignore calls on Gecko.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKUndo = new Object() ;
+
+FCKUndo.SaveUndoStep = function()
+{}

stud/FCKeditor/editor/_source/internals/fckundo_ie.js

@@ -0,0 +1,119 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckundo_ie.js
+ * 	IE specific implementation for the Undo/Redo system.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKUndo = new Object() ;
+
+FCKUndo.SavedData = new Array() ;
+FCKUndo.CurrentIndex = -1 ;
+FCKUndo.TypesCount = FCKUndo.MaxTypes = 25 ;
+FCKUndo.Typing = false ;
+
+FCKUndo.SaveUndoStep = function()
+{
+	if ( FCK.EditMode != FCK_EDITMODE_WYSIWYG )
+		return ;
+
+	// Shrink the array to the current level.
+	FCKUndo.SavedData = FCKUndo.SavedData.slice( 0, FCKUndo.CurrentIndex + 1 ) ;
+
+	// Get the Actual HTML.
+	var sHtml = FCK.EditorDocument.body.innerHTML ;
+
+	// Cancel operation if the new step is identical to the previous one.
+	if ( FCKUndo.CurrentIndex >= 0 && sHtml == FCKUndo.SavedData[ FCKUndo.CurrentIndex ][0] )
+		return ;
+
+	// If we reach the Maximun number of undo levels, we must remove the first
+	// entry of the list shifting all elements.
+	if ( FCKUndo.CurrentIndex + 1 >= FCKConfig.MaxUndoLevels )
+		FCKUndo.SavedData.shift() ;
+	else
+		FCKUndo.CurrentIndex++ ;
+
+	// Get the actual selection.
+	var sBookmark ;
+	if ( FCK.EditorDocument.selection.type == 'Text' )
+		sBookmark = FCK.EditorDocument.selection.createRange().getBookmark() ;
+
+	// Save the new level in front of the actual position.
+	FCKUndo.SavedData[ FCKUndo.CurrentIndex ] = [ sHtml, sBookmark ] ;
+
+	FCK.Events.FireEvent( "OnSelectionChange" ) ;
+}
+
+FCKUndo.CheckUndoState = function()
+{
+	return ( FCKUndo.Typing || FCKUndo.CurrentIndex > 0 ) ;
+}
+
+FCKUndo.CheckRedoState = function()
+{
+	return ( !FCKUndo.Typing && FCKUndo.CurrentIndex < ( FCKUndo.SavedData.length - 1 ) ) ;
+}
+
+FCKUndo.Undo = function()
+{
+	if ( FCKUndo.CheckUndoState() )
+	{
+		// If it is the first step.
+		if ( FCKUndo.CurrentIndex == ( FCKUndo.SavedData.length - 1 ) )
+		{
+			// Save the actual state for a possible "Redo" call.
+			FCKUndo.SaveUndoStep() ;
+		}
+
+		// Go a step back.
+		FCKUndo._ApplyUndoLevel( --FCKUndo.CurrentIndex ) ;
+
+		FCK.Events.FireEvent( "OnSelectionChange" ) ;
+	}
+}
+
+FCKUndo.Redo = function()
+{
+	if ( FCKUndo.CheckRedoState() )
+	{
+		// Go a step forward.
+		FCKUndo._ApplyUndoLevel( ++FCKUndo.CurrentIndex ) ;
+
+		FCK.Events.FireEvent( "OnSelectionChange" ) ;
+	}
+}
+
+FCKUndo._ApplyUndoLevel = function(level)
+{
+	var oData = FCKUndo.SavedData[ level ] ;
+	
+	if ( !oData )
+		return ;
+
+	// Update the editor contents with that step data.
+	FCK.SetInnerHtml( oData[0] ) ;
+//	FCK.EditorDocument.body.innerHTML = oData[0] ;
+
+	if ( oData[1] ) 
+	{
+		var oRange = FCK.EditorDocument.selection.createRange() ;
+		oRange.moveToBookmark( oData[1] ) ;
+		oRange.select() ;
+	}
+	
+	FCKUndo.TypesCount = 0 ; 
+	FCKUndo.Typing = false ;
+}

stud/FCKeditor/editor/_source/internals/fckurlparams.js

@@ -0,0 +1,32 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckurlparams.js
+ * 	Defines the FCKURLParams object that is used to get all parameters
+ * 	passed by the URL QueryString (after the "?").
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// #### URLParams: holds all URL passed parameters (like ?Param1=Value1&Param2=Value2)
+var FCKURLParams = new Object() ;
+
+var aParams = document.location.search.substr(1).split('&') ;
+for ( var i = 0 ; i < aParams.length ; i++ )
+{
+	var aParam = aParams[i].split('=') ;
+	var sParamName  = aParam[0] ;
+	var sParamValue = aParam[1] ;
+
+	FCKURLParams[ sParamName ] = sParamValue ;
+}

stud/FCKeditor/editor/_source/internals/fckxhtml.js

@@ -0,0 +1,390 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckxhtml.js
+ * 	Defines the FCKXHtml object, responsible for the XHTML operations.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKXHtml = new Object() ;
+
+FCKXHtml.CurrentJobNum = 0 ;
+
+FCKXHtml.GetXHTML = function( node, includeNode, format )
+{
+	FCKXHtmlEntities.Initialize() ;
+	
+	// Save the current IsDirty state. The XHTML processor may change the
+	// original HTML, dirtying it.
+	var bIsDirty = FCK.IsDirty() ;
+	
+	this._CreateNode = FCKConfig.ForceStrongEm ? FCKXHtml_CreateNode_StrongEm : FCKXHtml_CreateNode_Normal ;
+
+	// Special blocks are blocks of content that remain untouched during the
+	// process. It is used for SCRIPTs and STYLEs.
+	FCKXHtml.SpecialBlocks = new Array() ;
+
+	// Create the XML DOMDocument object.
+	this.XML = FCKTools.CreateXmlObject( 'DOMDocument' ) ;
+
+	// Add a root element that holds all child nodes.
+	this.MainNode = this.XML.appendChild( this.XML.createElement( 'xhtml' ) ) ;
+
+	FCKXHtml.CurrentJobNum++ ;
+
+	if ( includeNode )
+		this._AppendNode( this.MainNode, node ) ;
+	else
+		this._AppendChildNodes( this.MainNode, node, false ) ;
+
+	// Get the resulting XHTML as a string.
+	var sXHTML = this._GetMainXmlString() ;
+
+	this.XML = null ;
+	
+	// Strip the "XHTML" root node.
+	sXHTML = sXHTML.substr( 7, sXHTML.length - 15 ).trim() ;
+	
+	// Remove the trailing <br> added by Gecko.
+	if ( FCKBrowserInfo.IsGecko )
+		sXHTML = sXHTML.replace( /<br\/>$/, '' ) ;
+
+	// Add a space in the tags with no closing tags, like <br/> -> <br />
+	sXHTML = sXHTML.replace( FCKRegexLib.SpaceNoClose, ' />');
+
+	if ( FCKConfig.ForceSimpleAmpersand )
+		sXHTML = sXHTML.replace( FCKRegexLib.ForceSimpleAmpersand, '&' ) ;
+
+	if ( format )
+		sXHTML = FCKCodeFormatter.Format( sXHTML ) ;
+
+	// Now we put back the SpecialBlocks contents.
+	for ( var i = 0 ; i < FCKXHtml.SpecialBlocks.length ; i++ )
+	{
+		var oRegex = new RegExp( '___FCKsi___' + i ) ;
+		sXHTML = sXHTML.replace( oRegex, FCKXHtml.SpecialBlocks[i] ) ;
+	}
+	
+	// Replace entities marker with the ampersand.
+	sXHTML = sXHTML.replace( FCKRegexLib.GeckoEntitiesMarker, '&' ) ;
+
+	// Restore the IsDirty state if it was not dirty.
+	if ( !bIsDirty )
+		FCK.ResetIsDirty() ;
+
+	return sXHTML
+}
+
+FCKXHtml._AppendAttribute = function( xmlNode, attributeName, attributeValue )
+{
+	if ( FCKConfig.ForceSimpleAmpersand && attributeValue.replace )
+		attributeValue = attributeValue.replace( /&/g, '___FCKAmp___' ) ;
+	
+	try
+	{
+		// Create the attribute.
+		var oXmlAtt = this.XML.createAttribute( attributeName ) ;
+
+		oXmlAtt.value = attributeValue ? attributeValue : '' ;
+
+		// Set the attribute in the node.
+		xmlNode.attributes.setNamedItem( oXmlAtt ) ;
+	}
+	catch (e)
+	{}
+}
+
+FCKXHtml._AppendChildNodes = function( xmlNode, htmlNode, isBlockElement )
+{
+	var iCount = 0 ;
+	
+	var oNode = htmlNode.firstChild ;
+
+	while ( oNode )
+	{
+		if ( this._AppendNode( xmlNode, oNode ) )
+			iCount++ ;
+
+		oNode = oNode.nextSibling ;
+	}
+	
+	if ( iCount == 0 )
+	{
+		if ( isBlockElement && FCKConfig.FillEmptyBlocks )
+		{
+			this._AppendEntity( xmlNode, 'nbsp' ) ;
+			return ;
+		}
+
+		// We can't use short representation of empty elements that are not marked
+		// as empty in th XHTML DTD.
+		if ( !FCKRegexLib.EmptyElements.test( htmlNode.nodeName ) )
+			xmlNode.appendChild( this.XML.createTextNode('') ) ;
+	}
+}
+
+FCKXHtml._AppendNode = function( xmlNode, htmlNode )
+{
+	if ( !htmlNode )
+		return ;
+
+	switch ( htmlNode.nodeType )
+	{
+		// Element Node.
+		case 1 :
+
+			// Here we found an element that is not the real element, but a 
+			// fake one (like the Flash placeholder image), so we must get the real one.
+			if ( htmlNode.getAttribute('_fckfakelement') )
+				return FCKXHtml._AppendNode( xmlNode, FCK.GetRealElement( htmlNode ) ) ;
+		
+			// Mozilla insert custom nodes in the DOM.
+			if ( FCKBrowserInfo.IsGecko && htmlNode.hasAttribute('_moz_editor_bogus_node') )
+				return false ;
+			
+			// This is for elements that are instrumental to FCKeditor and 
+			// must be removed from the final HTML.
+			if ( htmlNode.getAttribute('_fcktemp') )
+				return false ;
+
+			// Get the element name.
+			var sNodeName = htmlNode.nodeName ;
+			
+			//Add namespace:
+			if ( FCKBrowserInfo.IsIE && htmlNode.scopeName && htmlNode.scopeName != 'HTML' && htmlNode.scopeName != 'FCK' )
+				sNodeName = htmlNode.scopeName + ':' + sNodeName ;
+
+			// Check if the node name is valid, otherwise ignore this tag.
+			// If the nodeName starts with a slash, it is a orphan closing tag.
+			// On some strange cases, the nodeName is empty, even if the node exists.
+			if ( !FCKRegexLib.ElementName.test( sNodeName ) )
+				return false ;
+
+			sNodeName = sNodeName.toLowerCase() ;
+
+			if ( FCKBrowserInfo.IsGecko && sNodeName == 'br' && htmlNode.hasAttribute('type') && htmlNode.getAttribute( 'type', 2 ) == '_moz' )
+				return false ;
+
+			// The already processed nodes must be marked to avoid then to be duplicated (bad formatted HTML).
+			// So here, the "mark" is checked... if the element is Ok, then mark it.
+			if ( htmlNode._fckxhtmljob && htmlNode._fckxhtmljob == FCKXHtml.CurrentJobNum )
+				return false ;
+
+			var oNode = this._CreateNode( sNodeName ) ;
+			
+			// Add all attributes.
+			FCKXHtml._AppendAttributes( xmlNode, htmlNode, oNode, sNodeName ) ;
+			
+			htmlNode._fckxhtmljob = FCKXHtml.CurrentJobNum ;
+
+			// Tag specific processing.
+			var oTagProcessor = FCKXHtml.TagProcessors[ sNodeName ] ;
+
+			if ( oTagProcessor )
+			{
+				oNode = oTagProcessor( oNode, htmlNode, xmlNode ) ;
+				if ( !oNode ) break ;
+			}
+			else
+				this._AppendChildNodes( oNode, htmlNode, FCKRegexLib.BlockElements.test( sNodeName ) ) ;
+
+			xmlNode.appendChild( oNode ) ;
+
+			break ;
+
+		// Text Node.
+		case 3 :
+			this._AppendTextNode( xmlNode, htmlNode.nodeValue.replaceNewLineChars(' ') ) ;
+			break ;
+
+		// Comment
+		case 8 :
+			// IE catches the <!DOTYPE ... > as a comment, but it has no
+			// innerHTML, so we can catch it, and ignore it.
+			if ( FCKBrowserInfo.IsIE && !htmlNode.innerHTML )
+				break ;
+
+			try { xmlNode.appendChild( this.XML.createComment( htmlNode.nodeValue ) ) ; }
+			catch (e) { /* Do nothing... probably this is a wrong format comment. */ }
+			break ;
+
+		// Unknown Node type.
+		default :
+			xmlNode.appendChild( this.XML.createComment( "Element not supported - Type: " + htmlNode.nodeType + " Name: " + htmlNode.nodeName ) ) ;
+			break ;
+	}
+	return true ;
+}
+
+function FCKXHtml_CreateNode_StrongEm( nodeName )
+{
+	switch ( nodeName )
+	{
+		case 'b' :
+			nodeName = 'strong' ;
+			break ;
+		case 'i' :
+			nodeName = 'em' ;
+			break ;
+	}
+	return this.XML.createElement( nodeName ) ;
+}
+
+function FCKXHtml_CreateNode_Normal( nodeName )
+{
+	return this.XML.createElement( nodeName ) ;
+}
+
+// Append an item to the SpecialBlocks array and returns the tag to be used.
+FCKXHtml._AppendSpecialItem = function( item )
+{
+	return '___FCKsi___' + FCKXHtml.SpecialBlocks.AddItem( item ) ;
+}
+
+FCKXHtml._AppendEntity = function( xmlNode, entity )
+{
+	xmlNode.appendChild( this.XML.createTextNode( '#?-:' + entity + ';' ) ) ;
+}
+
+FCKXHtml._AppendTextNode = function( targetNode, textValue )
+{
+	targetNode.appendChild( this.XML.createTextNode( textValue.replace( FCKXHtmlEntities.EntitiesRegex, FCKXHtml_GetEntity ) ) ) ;
+	return ;
+}
+
+// Retrieves a entity (internal format) for a given character.
+function FCKXHtml_GetEntity( character )
+{
+	// We cannot simply place the entities in the text, because the XML parser
+	// will translate & to &amp;. So we use a temporary marker which is replaced
+	// in the end of the processing.
+	var sEntity = FCKXHtmlEntities.Entities[ character ] || ( '#' + character.charCodeAt(0) ) ;
+	return '#?-:' + sEntity + ';' ;
+}
+
+// An object that hold tag specific operations.
+FCKXHtml.TagProcessors = new Object() ;
+
+FCKXHtml.TagProcessors['img'] = function( node, htmlNode )
+{
+	// The "ALT" attribute is required in XHTML.
+	if ( ! node.attributes.getNamedItem( 'alt' ) )
+		FCKXHtml._AppendAttribute( node, 'alt', '' ) ;
+
+	var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ;
+	if ( sSavedUrl != null )
+		FCKXHtml._AppendAttribute( node, 'src', sSavedUrl ) ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['a'] = function( node, htmlNode )
+{
+	var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ;
+	if ( sSavedUrl != null )
+		FCKXHtml._AppendAttribute( node, 'href', sSavedUrl ) ;
+
+	FCKXHtml._AppendChildNodes( node, htmlNode, false ) ;
+
+	// Firefox may create empty tags when deleting the selection in some special cases (SF-BUG 1556878).
+	if ( node.childNodes.length == 0 && !node.getAttribute( 'name' ) )
+		return false ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['script'] = function( node, htmlNode )
+{
+	// The "TYPE" attribute is required in XHTML.
+	if ( ! node.attributes.getNamedItem( 'type' ) )
+		FCKXHtml._AppendAttribute( node, 'type', 'text/javascript' ) ;
+
+	node.appendChild( FCKXHtml.XML.createTextNode( FCKXHtml._AppendSpecialItem( htmlNode.text ) ) ) ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['style'] = function( node, htmlNode )
+{
+	// The "TYPE" attribute is required in XHTML.
+	if ( ! node.attributes.getNamedItem( 'type' ) )
+		FCKXHtml._AppendAttribute( node, 'type', 'text/css' ) ;
+
+	node.appendChild( FCKXHtml.XML.createTextNode( FCKXHtml._AppendSpecialItem( htmlNode.innerHTML ) ) ) ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['title'] = function( node, htmlNode )
+{
+	node.appendChild( FCKXHtml.XML.createTextNode( FCK.EditorDocument.title ) ) ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['table'] = function( node, htmlNode )
+{
+	// There is a trick to show table borders when border=0. We add to the
+	// table class the FCK__ShowTableBorders rule. So now we must remove it.
+
+	var oClassAtt = node.attributes.getNamedItem( 'class' ) ;
+
+	if ( oClassAtt && FCKRegexLib.TableBorderClass.test( oClassAtt.nodeValue ) )
+	{
+		var sClass = oClassAtt.nodeValue.replace( FCKRegexLib.TableBorderClass, '' ) ;
+
+		if ( sClass.length == 0 )
+			node.attributes.removeNamedItem( 'class' ) ;
+		else
+			FCKXHtml._AppendAttribute( node, 'class', sClass ) ;
+	}
+
+	FCKXHtml._AppendChildNodes( node, htmlNode, false ) ;
+
+	return node ;
+}
+
+// Fix nested <ul> and <ol>.
+FCKXHtml.TagProcessors['ol'] = FCKXHtml.TagProcessors['ul'] = function( node, htmlNode, targetNode )
+{
+	if ( htmlNode.innerHTML.trim().length == 0 )
+		return ;
+
+	var ePSibling = targetNode.lastChild ;
+	
+	if ( ePSibling && ePSibling.nodeType == 3 )
+		ePSibling = ePSibling.previousSibling ;
+	
+	if ( ePSibling && ePSibling.nodeName.toUpperCase() == 'LI' )
+	{
+		htmlNode._fckxhtmljob = null ;
+		FCKXHtml._AppendNode( ePSibling, htmlNode ) ;
+		return ;
+	}
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['span'] = function( node, htmlNode )
+{
+	// Firefox may create empty tags when deleting the selection in some special cases (SF-BUG 1084404).
+	if ( htmlNode.innerHTML.length == 0 )
+		return false ;
+		
+	FCKXHtml._AppendChildNodes( node, htmlNode, false ) ;
+
+	return node ;
+}

stud/FCKeditor/editor/_source/internals/fckxhtml_gecko.js

@@ -0,0 +1,62 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckxhtml_gecko.js
+ * 	Defines the FCKXHtml object, responsible for the XHTML operations.
+ * 	Gecko specific.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKXHtml._GetMainXmlString = function()
+{
+	// Create the XMLSerializer.
+	var oSerializer = new XMLSerializer() ;
+
+	// Return the serialized XML as a string.
+	return oSerializer.serializeToString( this.MainNode ) ;
+}
+
+FCKXHtml._AppendAttributes = function( xmlNode, htmlNode, node )
+{
+	var aAttributes = htmlNode.attributes ;
+	
+	for ( var n = 0 ; n < aAttributes.length ; n++ )
+	{
+		var oAttribute = aAttributes[n] ;
+		
+		if ( oAttribute.specified )
+		{
+			var sAttName = oAttribute.nodeName.toLowerCase() ;
+			var sAttValue ;
+
+			// Ignore any attribute starting with "_fck".
+			if ( sAttName.startsWith( '_fck' ) )
+				continue ;
+			// There is a bug in Mozilla that returns '_moz_xxx' attributes as specified.
+			else if ( sAttName.indexOf( '_moz' ) == 0 )
+				continue ;
+			// There are one cases (on Gecko) when the oAttribute.nodeValue must be used:
+			//		- for the "class" attribute
+			else if ( sAttName == 'class' )
+				sAttValue = oAttribute.nodeValue ;
+			// XHTML doens't support attribute minimization like "CHECKED". It must be trasformed to cheched="checked".
+			else if ( oAttribute.nodeValue === true )
+				sAttValue = sAttName ;
+			else
+				sAttValue = htmlNode.getAttribute( sAttName, 2 ) ;	// We must use getAttribute to get it exactly as it is defined.
+
+			this._AppendAttribute( node, sAttName, sAttValue ) ;
+		}
+	}
+}

stud/FCKeditor/editor/_source/internals/fckxhtml_ie.js

@@ -0,0 +1,184 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckxhtml_ie.js
+ * 	Defines the FCKXHtml object, responsible for the XHTML operations.
+ * 	IE specific.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKXHtml._GetMainXmlString = function()
+{
+	return this.MainNode.xml ;
+}
+
+FCKXHtml._AppendAttributes = function( xmlNode, htmlNode, node, nodeName )
+{
+	var aAttributes = htmlNode.attributes ;
+
+	for ( var n = 0 ; n < aAttributes.length ; n++ )
+	{
+		var oAttribute = aAttributes[n] ;
+
+		if ( oAttribute.specified )
+		{
+			var sAttName = oAttribute.nodeName.toLowerCase() ;
+			var sAttValue ;
+
+			// Ignore any attribute starting with "_fck".
+			if ( sAttName.startsWith( '_fck' ) )
+				continue ;
+			// The following must be done because of a bug on IE regarding the style
+			// attribute. It returns "null" for the nodeValue.
+			else if ( sAttName == 'style' )
+				sAttValue = htmlNode.style.cssText ;
+			// There are two cases when the oAttribute.nodeValue must be used:
+			//		- for the "class" attribute
+			//		- for events attributes (on IE only).
+			else if ( sAttName == 'class' || sAttName.indexOf('on') == 0 )
+				sAttValue = oAttribute.nodeValue ;
+			else if ( nodeName == 'body' && sAttName == 'contenteditable' )
+				continue ;
+			// XHTML doens't support attribute minimization like "CHECKED". It must be trasformed to cheched="checked".
+			else if ( oAttribute.nodeValue === true )
+				sAttValue = sAttName ;
+			// We must use getAttribute to get it exactly as it is defined.
+			else if ( ! (sAttValue = htmlNode.getAttribute( sAttName, 2 ) ) )
+				sAttValue = oAttribute.nodeValue ;
+
+			this._AppendAttribute( node, sAttName, sAttValue ) ;
+		}
+	}
+}
+
+FCKXHtml.TagProcessors['meta'] = function( node, htmlNode )
+{
+	var oHttpEquiv = node.attributes.getNamedItem( 'http-equiv' ) ;
+
+	if ( oHttpEquiv == null || oHttpEquiv.value.length == 0 )
+	{
+		// Get the http-equiv value from the outerHTML.
+		var sHttpEquiv = htmlNode.outerHTML.match( FCKRegexLib.MetaHttpEquiv ) ;
+
+		if ( sHttpEquiv )
+		{
+			sHttpEquiv = sHttpEquiv[1] ;
+			FCKXHtml._AppendAttribute( node, 'http-equiv', sHttpEquiv ) ;
+		}
+	}
+
+	return node ;
+}
+
+// IE automaticaly changes <FONT> tags to <FONT size=+0>.
+FCKXHtml.TagProcessors['font'] = function( node, htmlNode )
+{
+	if ( node.attributes.length == 0 )
+		node = FCKXHtml.XML.createDocumentFragment() ;
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+	return node ;
+}
+
+// IE doens't see the value attribute as an attribute for the <INPUT> tag.
+FCKXHtml.TagProcessors['input'] = function( node, htmlNode )
+{
+	if ( htmlNode.name )
+		FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ;
+
+	if ( htmlNode.value && !node.attributes.getNamedItem( 'value' ) )
+		FCKXHtml._AppendAttribute( node, 'value', htmlNode.value ) ;
+
+	if ( !node.attributes.getNamedItem( 'type' ) )
+		FCKXHtml._AppendAttribute( node, 'type', 'text' ) ;
+
+	return node ;
+}
+
+// IE ignores the "SELECTED" attribute so we must add it manually.
+FCKXHtml.TagProcessors['option'] = function( node, htmlNode )
+{
+	if ( htmlNode.selected && !node.attributes.getNamedItem( 'selected' ) )
+		FCKXHtml._AppendAttribute( node, 'selected', 'selected' ) ;
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+	return node ;
+}
+
+// IE ignores the "COORDS" and "SHAPE" attribute so we must add it manually.
+FCKXHtml.TagProcessors['area'] = function( node, htmlNode )
+{
+	if ( ! node.attributes.getNamedItem( 'coords' ) )
+	{
+		var sCoords = htmlNode.getAttribute( 'coords', 2 ) ;
+		if ( sCoords && sCoords != '0,0,0' )
+			FCKXHtml._AppendAttribute( node, 'coords', sCoords ) ;
+	}
+
+	if ( ! node.attributes.getNamedItem( 'shape' ) )
+	{
+		var sCoords = htmlNode.getAttribute( 'shape', 2 ) ;
+		if ( sCoords && sCoords.length > 0 )
+			FCKXHtml._AppendAttribute( node, 'shape', sCoords ) ;
+	}
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['label'] = function( node, htmlNode )
+{
+	if ( htmlNode.htmlFor.length > 0 )
+		FCKXHtml._AppendAttribute( node, 'for', htmlNode.htmlFor ) ;
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+	return node ;
+}
+
+FCKXHtml.TagProcessors['form'] = function( node, htmlNode )
+{
+	if ( htmlNode.acceptCharset && htmlNode.acceptCharset.length > 0 && htmlNode.acceptCharset != 'UNKNOWN' )
+		FCKXHtml._AppendAttribute( node, 'accept-charset', htmlNode.acceptCharset ) ;
+
+	if ( htmlNode.name ) 
+		FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; 
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+	return node ;
+}
+
+// IE doens't hold the name attribute as an attribute for the <TEXTAREA> and <SELECT> tags.
+FCKXHtml.TagProcessors['textarea'] = FCKXHtml.TagProcessors['select'] = function( node, htmlNode )
+{ 
+	if ( htmlNode.name ) 
+		FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; 
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ; 
+ 
+	return node ; 
+} 
+
+// On very rare cases, IE is loosing the "align" attribute for DIV. (right align and apply bulleted list)
+FCKXHtml.TagProcessors['div'] = function( node, htmlNode )
+{
+	if ( htmlNode.align.length > 0 )
+		FCKXHtml._AppendAttribute( node, 'align', htmlNode.align ) ;
+
+	FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+	return node ;
+}

stud/FCKeditor/editor/_source/internals/fckxhtmlentities.js

@@ -0,0 +1,340 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2006 Frederico Caldeira Knabben
+ * 
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * 		http://www.opensource.org/licenses/lgpl-license.php
+ * 
+ * For further information visit:
+ * 		http://www.fckeditor.net/
+ * 
+ * "Support Open Source software. What about a donation today?"
+ * 
+ * File Name: fckxhtmlentities.js
+ * 	This file define the HTML entities handled by the editor.
+ * 
+ * File Authors:
+ * 		Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKXHtmlEntities = new Object() ;
+
+FCKXHtmlEntities.Initialize = function()
+{
+	if ( FCKXHtmlEntities.Entities )
+		return ;
+
+	var sChars = '' ;
+
+	if ( FCKConfig.ProcessHTMLEntities )
+	{
+		FCKXHtmlEntities.Entities = {
+			// Latin-1 Entities
+			' ':'nbsp',
+			'¡':'iexcl',
+			'¢':'cent',
+			'£':'pound',
+			'¤':'curren',
+			'¥':'yen',
+			'¦':'brvbar',
+			'§':'sect',
+			'¨':'uml',
+			'©':'copy',
+			'ª':'ordf',
+			'«':'laquo',
+			'¬':'not',
+			'­':'shy',
+			'®':'reg',
+			'¯':'macr',
+			'°':'deg',
+			'±':'plusmn',
+			'²':'sup2',
+			'³':'sup3',
+			'´':'acute',
+			'µ':'micro',
+			'¶':'para',
+			'·':'middot',
+			'¸':'cedil',
+			'¹':'sup1',
+			'º':'ordm',
+			'»':'raquo',
+			'¼':'frac14',
+			'½':'frac12',
+			'¾':'frac34',
+			'¿':'iquest',
+			'×':'times',
+			'÷':'divide',
+
+			// Symbols
+
+			'ƒ':'fnof',
+			'•':'bull',
+			'…':'hellip',
+			'′':'prime',
+			'″':'Prime',
+			'‾':'oline',
+			'⁄':'frasl',
+			'℘':'weierp',
+			'ℑ':'image',
+			'ℜ':'real',
+			'™':'trade',
+			'ℵ':'alefsym',
+			'←':'larr',
+			'↑':'uarr',
+			'→':'rarr',
+			'↓':'darr',
+			'↔':'harr',
+			'↵':'crarr',
+			'⇐':'lArr',
+			'⇑':'uArr',
+			'⇒':'rArr',
+			'⇓':'dArr',
+			'⇔':'hArr',
+			'∀':'forall',
+			'∂':'part',
+			'∃':'exist',
+			'∅':'empty',
+			'∇':'nabla',
+			'∈':'isin',
+			'∉':'notin',
+			'∋':'ni',
+			'∏':'prod',
+			'∑':'sum',
+			'−':'minus',
+			'∗':'lowast',
+			'√':'radic',
+			'∝':'prop',
+			'∞':'infin',
+			'∠':'ang',
+			'∧':'and',
+			'∨':'or',
+			'∩':'cap',
+			'∪':'cup',
+			'∫':'int',
+			'∴':'there4',
+			'∼':'sim',
+			'≅':'cong',
+			'≈':'asymp',
+			'≠':'ne',
+			'≡':'equiv',
+			'≤':'le',
+			'≥':'ge',
+			'⊂':'sub',
+			'⊃':'sup',
+			'⊄':'nsub',
+			'⊆':'sube',
+			'⊇':'supe',
+			'⊕':'oplus',
+			'⊗':'otimes',
+			'⊥':'perp',
+			'⋅':'sdot',
+			'◊':'loz',
+			'♠':'spades',
+			'♣':'clubs',
+			'♥':'hearts',
+			'♦':'diams',
+
+			// Other Special Characters 
+
+			'"':'quot',
+		//	'&':'amp',		// This entity is automatically handled by the XHTML parser.
+		//	'<':'lt',		// This entity is automatically handled by the XHTML parser.
+		//	'>':'gt',		// This entity is automatically handled by the XHTML parser.
+			'ˆ':'circ',
+			'˜':'tilde',
+			' ':'ensp',
+			' ':'emsp',
+			' ':'thinsp',
+			'‌':'zwnj',
+			'‍':'zwj',
+			'‎':'lrm',
+			'‏':'rlm',
+			'–':'ndash',
+			'—':'mdash',
+			'‘':'lsquo',
+			'’':'rsquo',
+			'‚':'sbquo',
+			'“':'ldquo',
+			'”':'rdquo',
+			'„':'bdquo',
+			'†':'dagger',
+			'‡':'Dagger',
+			'‰':'permil',
+			'‹':'lsaquo',
+			'›':'rsaquo',
+			'€':'euro'
+		} ;
+
+		// Process Base Entities.
+		for ( var e in FCKXHtmlEntities.Entities )
+			sChars += e ;
+
+		// Include Latin Letters Entities.
+		if ( FCKConfig.IncludeLatinEntities )
+		{
+			var oEntities = {
+				'À':'Agrave',
+				'Á':'Aacute',
+				'Â':'Acirc',
+				'Ã':'Atilde',
+				'Ä':'Auml',
+				'Å':'Aring',
+				'Æ':'AElig',
+				'Ç':'Ccedil',
+				'È':'Egrave',
+				'É':'Eacute',
+				'Ê':'Ecirc',
+				'Ë':'Euml',
+				'Ì':'Igrave',
+				'Í':'Iacute',
+				'Î':'Icirc',
+				'Ï':'Iuml',
+				'Ð':'ETH',
+				'Ñ':'Ntilde',
+				'Ò':'Ograve',
+				'Ó':'Oacute',
+				'Ô':'Ocirc',
+				'Õ':'Otilde',
+				'Ö':'Ouml',
+				'Ø':'Oslash',
+				'Ù':'Ugrave',
+				'Ú':'Uacute',
+				'Û':'Ucirc',
+				'Ü':'Uuml',
+				'Ý':'Yacute',
+				'Þ':'THORN',
+				'ß':'szlig',
+				'à':'agrave',
+				'á':'aacute',
+				'â':'acirc',
+				'ã':'atilde',
+				'ä':'auml',
+				'å':'aring',
+				'æ':'aelig',
+				'ç':'ccedil',
+				'è':'egrave',
+				'é':'eacute',
+				'ê':'ecirc',
+				'ë':'euml',
+				'ì':'igrave',
+				'í':'iacute',
+				'î':'icirc',
+				'ï':'iuml',
+				'ð':'eth',
+				'ñ':'ntilde',
+				'ò':'ograve',
+				'ó':'oacute',
+				'ô':'ocirc',
+				'õ':'otilde',
+				'ö':'ouml',
+				'ø':'oslash',
+				'ù':'ugrave',
+				'ú':'uacute',
+				'û':'ucirc',
+				'ü':'uuml',
+				'ý':'yacute',
+				'þ':'thorn',
+				'ÿ':'yuml',
+				'Œ':'OElig',
+				'œ':'oelig',
+				'Š':'Scaron',
+				'š':'scaron',
+				'Ÿ':'Yuml'
+			} ; 
+			
+			for ( var e in oEntities )
+			{
+				FCKXHtmlEntities.Entities[ e ] = oEntities[ e ] ;
+				sChars += e ;
+			}
+			
+			oEntities = null ;
+		}
+
+		// Include Greek Letters Entities.
+		if ( FCKConfig.IncludeGreekEntities )
+		{
+			var oEntities = {
+				'Α':'Alpha',
+				'Β':'Beta',
+				'Γ':'Gamma',
+				'Δ':'Delta',
+				'Ε':'Epsilon',
+				'Ζ':'Zeta',
+				'Η':'Eta',
+				'Θ':'Theta',
+				'Ι':'Iota',
+				'Κ':'Kappa',
+				'Λ':'Lambda',
+				'Μ':'Mu',
+				'Ν':'Nu',
+				'Ξ':'Xi',
+				'Ο':'Omicron',
+				'Π':'Pi',
+				'Ρ':'Rho',
+				'Σ':'Sigma',
+				'Τ':'Tau',
+				'Υ':'Upsilon',
+				'Φ':'Phi',
+				'Χ':'Chi',
+				'Ψ':'Psi',
+				'Ω':'Omega',
+				'α':'alpha',
+				'β':'beta',
+				'γ':'gamma',
+				'δ':'delta',
+				'ε':'epsilon',
+				'ζ':'zeta',
+				'η':'eta',
+				'θ':'theta',
+				'ι':'iota',
+				'κ':'kappa',
+				'λ':'lambda',
+				'μ':'mu',
+				'ν':'nu',
+				'ξ':'xi',
+				'ο':'omicron',
+				'π':'pi',
+				'ρ':'rho',
+				'ς':'sigmaf',
+				'σ':'sigma',
+				'τ':'tau',
+				'υ':'upsilon',
+				'φ':'phi',
+				'χ':'chi',
+				'ψ':'psi',
+				'ω':'omega'
+			} ;
+
+			for ( var e in oEntities )
+			{
+				FCKXHtmlEntities.Entities[ e ] = oEntities[ e ] ;
+				sChars += e ;
+			}
+
+			oEntities = null ;
+		}		
+	}
+	else
+	{
+		FCKXHtmlEntities.Entities = {} ;
+
+		// Even if we are not processing the entities, we must render the &nbsp;
+		// correctly. As we don't want HTML entities, let's use its numeric
+		// representation (&#160).
+		sChars = ' ' ;
+	}
+
+	// Create the Regex used to find entities in the text.
+	var sRegexPattern = '[' + sChars + ']' ;
+	
+	if ( FCKConfig.ProcessNumericEntities )
+		sRegexPattern = '[^ -~]|' + sRegexPattern ;
+
+	var sAdditional = FCKConfig.AdditionalNumericEntities ;
+
+	if ( sAdditional || sAdditional.length > 0 )
+		sRegexPattern += '|' + FCKConfig.AdditionalNumericEntities ;
+
+	FCKXHtmlEntities.EntitiesRegex = new RegExp( sRegexPattern, 'g' ) ;
+}