. + this._AppendBogusBr( eStartBlock ) ; + this._AppendBogusBr( eNewBlock ) ; + } + } + + if ( eNewBlock ) + { + FCKDomTools.InsertAfterNode( eStartBlock, eNewBlock ) ; + + // Move the selection to the new block. + oRange.MoveToElementEditStart( eNewBlock ) ; + + if ( FCKBrowserInfo.IsGecko ) + eNewBlock.scrollIntoView( false ) ; + } + } + } + else + { + // Move the selection to the end block. + oRange.MoveToElementEditStart( eEndBlock ) ; + } + + oRange.Select() ; + } + + // Release the resources used by the range. + oRange.Release() ; + + return true ; +} + +FCKEnterKey.prototype._ExecuteEnterBr = function( blockTag ) +{ + // Get the current selection. + var oRange = new FCKDomRange( this.Window ) ; + oRange.MoveToSelection() ; + + // The selection boundaries must be in the same "block limit" element. + if ( oRange.StartBlockLimit == oRange.EndBlockLimit ) + { + oRange.DeleteContents() ; + + // Get the new selection (it is collapsed at this point). + oRange.MoveToSelection() ; + + var bIsStartOfBlock = oRange.CheckStartOfBlock() ; + var bIsEndOfBlock = oRange.CheckEndOfBlock() ; + + var sStartBlockTag = oRange.StartBlock ? oRange.StartBlock.tagName.toUpperCase() : '' ; + + var bHasShift = this._HasShift ; + + if ( !bHasShift && sStartBlockTag == 'LI' ) + return this._ExecuteEnterBlock( null, oRange ) ; + + // If we are at the end of a header block. + if ( !bHasShift && bIsEndOfBlock && (/^H[1-6]$/).test( sStartBlockTag ) ) + { + FCKDebug.Output( 'BR - Header' ) ; + + // Insert a BR after the current paragraph. + FCKDomTools.InsertAfterNode( oRange.StartBlock, this.Window.document.createElement( 'br' ) ) ; + + // The space is required by Gecko only to make the cursor blink. + if ( FCKBrowserInfo.IsGecko ) + FCKDomTools.InsertAfterNode( oRange.StartBlock, this.Window.document.createTextNode( '' ) ) ; + + // IE and Gecko have different behaviors regarding the position. + oRange.SetStart( oRange.StartBlock.nextSibling, FCKBrowserInfo.IsIE ? 3 : 1 ) ; + } + else + { + FCKDebug.Output( 'BR - No Header' ) ; + + var eBr = this.Window.document.createElement( 'br' ) ; + + oRange.InsertNode( eBr ) ; + + // The space is required by Gecko only to make the cursor blink. + if ( FCKBrowserInfo.IsGecko ) + FCKDomTools.InsertAfterNode( eBr, this.Window.document.createTextNode( '' ) ) ; + + // If we are at the end of a block, we must be sure the bogus node is available in that block. + if ( bIsEndOfBlock && FCKBrowserInfo.IsGecko ) + this._AppendBogusBr( eBr.parentNode ) ; + + if ( FCKBrowserInfo.IsIE ) + oRange.SetStart( eBr, 4 ) ; + else + oRange.SetStart( eBr.nextSibling, 1 ) ; + + } + + // This collapse guarantees the cursor will be blinking. + oRange.Collapse( true ) ; + + oRange.Select() ; + } + + // Release the resources used by the range. + oRange.Release() ; + + return true ; +} + +// Transform a block without a block tag in a valid block (orphan text in the body or td, usually). +FCKEnterKey.prototype._FixBlock = function( range, isStart, blockTag ) +{ + // Bookmark the range so we can restore it later. + var oBookmark = range.CreateBookmark() ; + + // Collapse the range to the requested ending boundary. + range.Collapse( isStart ) ; + + // Expands it to the block contents. + range.Expand( 'block_contents' ) ; + + // Create the fixed block. + var oFixedBlock = this.Window.document.createElement( blockTag ) ; + + // Move the contents of the temporary range to the fixed block. + range.ExtractContents().AppendTo( oFixedBlock ) ; + FCKDomTools.TrimNode( oFixedBlock ) ; + + // Insert the fixed block into the DOM. + range.InsertNode( oFixedBlock ) ; + + // Move the range back to the bookmarked place. + range.MoveToBookmark( oBookmark ) ; +} + +// Appends a bogus
at the end of the element, if not yet available. +FCKEnterKey.prototype._AppendBogusBr = function( element ) +{ + var eLastChild = element.getElementsByTagName('br') ; + + if ( eLastChild ) + eLastChild = eLastChild[ eLastChild.legth - 1 ] ; + + if ( !eLastChild || eLastChild.getAttribute( 'type', 2 ) != '_moz' ) + element.appendChild( FCKTools.CreateBogusBR( this.Window.document ) ) ; +} + +// Recreate the elements tree at the end of the source block, at the beginning +// of the target block. Eg.: +// If source =
Some sample text
then target =+// If source =
Some sample text
then target = +FCKEnterKey.prototype._RecreateEndingTree = function( source, target ) +{ + while ( ( source = source.lastChild ) && source.nodeType == 1 && FCKListsLib.InlineChildReqElements[ source.nodeName.toLowerCase() ] != null ) + target = target.insertBefore( source.cloneNode( false ), target.firstChild ) ; +} + +// Outdents a LI, maintaining the seletion defined on a range. +FCKEnterKey.prototype._OutdentWithSelection = function( li, range ) +{ + var oBookmark = range.CreateBookmark() ; + + FCKListHandler.OutdentListItem( li ) ; + + range.MoveToBookmark( oBookmark ) ; + range.Select() ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckevents.js b/WebRoot/FCKeditor/editor/_source/classes/fckevents.js new file mode 100644 index 0000000..54c4aed --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/classes/fckevents.js @@ -0,0 +1,53 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKEvents Class: used to handle events is a advanced way. + */ + +var 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 ; +} diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckicon.js b/WebRoot/FCKeditor/editor/_source/classes/fckicon.js new file mode 100644 index 0000000..c7346a7 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/classes/fckicon.js @@ -0,0 +1,98 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKIcon Class: renders an icon from a single image, a strip or even a + * spacer. + */ + +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, eIconImage ; + + if ( this.Position ) // It is using an icons strip image. + { + var sPos = '-' + ( ( this.Position - 1 ) * this.Size ) + 'px' ; + + if ( FCKBrowserInfo.IsIE ) + { + //
+
+ 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.
+ // 
+// eIcon = document.createElement( 'IMG' ) ;
+// eIcon.src = this.Path ? this.Path : FCK_SPACER_PATH ;
+
+ // IE makes the button 1px higher if using the system to clip the image correctly.
+ eIcon = document.createElement( 'DIV' ) ;
+
+ eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ;
+ eIconImage.src = this.Path ? this.Path : FCK_SPACER_PATH ;
+ }
+
+ eIcon.className = 'TB_Button_Image' ;
+
+ return eIcon ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckiecleanup.js b/WebRoot/FCKeditor/editor/_source/classes/fckiecleanup.js
new file mode 100644
index 0000000..22c43dd
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckiecleanup.js
@@ -0,0 +1,68 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKIECleanup Class: a generic class used as a tool to remove IE leaks.
+ */
+
+var FCKIECleanup = function( attachWindow )
+{
+ // If the attachWindow already have a cleanup object, jusgt use that one.
+ if ( attachWindow._FCKCleanupObj )
+ this.Items = attachWindow._FCKCleanupObj.Items ;
+ else
+ {
+ this.Items = new Array() ;
+
+ attachWindow._FCKCleanupObj = this ;
+ FCKTools.AddEventListenerEx( attachWindow, 'unload', FCKIECleanup_Cleanup ) ;
+// attachWindow.attachEvent( 'onunload', FCKIECleanup_Cleanup ) ;
+ }
+}
+
+FCKIECleanup.prototype.AddItem = function( dirtyItem, cleanupFunction )
+{
+ this.Items.push( [ dirtyItem, cleanupFunction ] ) ;
+}
+
+function FCKIECleanup_Cleanup()
+{
+ if ( !this._FCKCleanupObj )
+ return ;
+
+ var aItems = this._FCKCleanupObj.Items ;
+
+ while ( aItems.length > 0 )
+ {
+
+ // It is important to remove from the end to the beginning (pop()),
+ // because of the order things get created in the editor. In the code,
+ // elements in deeper position in the DOM are placed at the end of the
+ // cleanup function, so we must cleanup then first, otherwise IE could
+ // throw some crazy memory errors (IE bug).
+ var oItem = aItems.pop() ;
+ if ( oItem )
+ oItem[1].call( oItem[0] ) ;
+ }
+
+ this._FCKCleanupObj = null ;
+
+ if ( CollectGarbage )
+ CollectGarbage() ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckimagepreloader.js b/WebRoot/FCKeditor/editor/_source/classes/fckimagepreloader.js
new file mode 100644
index 0000000..ec68111
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckimagepreloader.js
@@ -0,0 +1,68 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Preload a list of images, firing an event when complete.
+ */
+
+var FCKImagePreloader = function()
+{
+ this._Images = new Array() ;
+}
+
+FCKImagePreloader.prototype =
+{
+ AddImages : function( images )
+ {
+ if ( typeof( images ) == 'string' )
+ images = images.split( ';' ) ;
+
+ this._Images = this._Images.concat( images ) ;
+ },
+
+ Start : function()
+ {
+ var aImages = this._Images ;
+ this._PreloadCount = aImages.length ;
+
+ for ( var i = 0 ; i < aImages.length ; i++ )
+ {
+ var eImg = document.createElement( 'img' ) ;
+ eImg.onload = eImg.onerror = _FCKImagePreloader_OnImage ;
+ eImg._FCKImagePreloader = this ;
+ eImg.src = aImages[i] ;
+
+ _FCKImagePreloader_ImageCache.push( eImg ) ;
+ }
+ }
+};
+
+// All preloaded images must be placed in a global array, otherwise the preload
+// magic will not happen.
+var _FCKImagePreloader_ImageCache = new Array() ;
+
+function _FCKImagePreloader_OnImage()
+{
+ var oImagePreloader = this._FCKImagePreloader ;
+
+ if ( (--oImagePreloader._PreloadCount) == 0 && oImagePreloader.OnComplete )
+ oImagePreloader.OnComplete() ;
+
+ this._FCKImagePreloader = null ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckkeystrokehandler.js b/WebRoot/FCKeditor/editor/_source/classes/fckkeystrokehandler.js
new file mode 100644
index 0000000..89667b3
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckkeystrokehandler.js
@@ -0,0 +1,136 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Control keyboard keystroke combinations.
+ */
+
+var FCKKeystrokeHandler = function( cancelCtrlDefaults )
+{
+ this.Keystrokes = new Object() ;
+ this.CancelCtrlDefaults = ( cancelCtrlDefaults !== false ) ;
+}
+
+/*
+ * Listen to keystroke events in an element or DOM document object.
+ * @target: The element or document to listen to keystroke events.
+ */
+FCKKeystrokeHandler.prototype.AttachToElement = function( target )
+{
+ // For newer browsers, it is enough to listen to the keydown event only.
+ // Some browsers instead, don't cancel key events in the keydown, but in the
+ // keypress. So we must do a longer trip in those cases.
+ FCKTools.AddEventListenerEx( target, 'keydown', _FCKKeystrokeHandler_OnKeyDown, this ) ;
+ if ( FCKBrowserInfo.IsGecko10 || FCKBrowserInfo.IsOpera || ( FCKBrowserInfo.IsGecko && FCKBrowserInfo.IsMac ) )
+ FCKTools.AddEventListenerEx( target, 'keypress', _FCKKeystrokeHandler_OnKeyPress, this ) ;
+}
+
+/*
+ * Sets a list of keystrokes. It can receive either a single array or "n"
+ * arguments, each one being an array of 1 or 2 elemenst. The first element
+ * is the keystroke combination, and the second is the value to assign to it.
+ * If the second element is missing, the keystroke definition is removed.
+ */
+FCKKeystrokeHandler.prototype.SetKeystrokes = function()
+{
+ // Look through the arguments.
+ for ( var i = 0 ; i < arguments.length ; i++ )
+ {
+ var keyDef = arguments[i] ;
+
+ if ( typeof( keyDef[0] ) == 'object' ) // It is an array with arrays defining the keystrokes.
+ this.SetKeystrokes.apply( this, keyDef ) ;
+ else
+ {
+ if ( keyDef.length == 1 ) // If it has only one element, removed the keystroke.
+ delete this.Keystrokes[ keyDef[0] ] ;
+ else // Otherwise add it.
+ this.Keystrokes[ keyDef[0] ] = keyDef[1] === true ? true : keyDef ;
+ }
+ }
+}
+
+function _FCKKeystrokeHandler_OnKeyDown( ev, keystrokeHandler )
+{
+ // Get the key code.
+ var keystroke = ev.keyCode || ev.which ;
+
+ // Combine it with the CTRL, SHIFT and ALT states.
+ var keyModifiers = 0 ;
+
+ if ( ev.ctrlKey || ev.metaKey )
+ keyModifiers += CTRL ;
+
+ if ( ev.shiftKey )
+ keyModifiers += SHIFT ;
+
+ if ( ev.altKey )
+ keyModifiers += ALT ;
+
+ var keyCombination = keystroke + keyModifiers ;
+
+ var cancelIt = keystrokeHandler._CancelIt = false ;
+
+ // Look for its definition availability.
+ var keystrokeValue = keystrokeHandler.Keystrokes[ keyCombination ] ;
+
+// FCKDebug.Output( 'KeyDown: ' + keyCombination + ' - Value: ' + keystrokeValue ) ;
+
+ // If the keystroke is defined
+ if ( keystrokeValue )
+ {
+ // If the keystroke has been explicetly set to "true" OR calling the
+ // "OnKeystroke" event, it doesn't return "true", the default behavior
+ // must be preserved.
+ if ( keystrokeValue === true || !( keystrokeHandler.OnKeystroke && keystrokeHandler.OnKeystroke.apply( keystrokeHandler, keystrokeValue ) ) )
+ return true ;
+
+ cancelIt = true ;
+ }
+
+ // By default, it will cancel all combinations with the CTRL key only (except positioning keys).
+ if ( cancelIt || ( keystrokeHandler.CancelCtrlDefaults && keyModifiers == CTRL && ( keystroke < 33 || keystroke > 40 ) ) )
+ {
+ keystrokeHandler._CancelIt = true ;
+
+ if ( ev.preventDefault )
+ return ev.preventDefault() ;
+
+ ev.returnValue = false ;
+ ev.cancelBubble = true ;
+ return false ;
+ }
+
+ return true ;
+}
+
+function _FCKKeystrokeHandler_OnKeyPress( ev, keystrokeHandler )
+{
+ if ( keystrokeHandler._CancelIt )
+ {
+// FCKDebug.Output( 'KeyPress Cancel', 'Red') ;
+
+ if ( ev.preventDefault )
+ return ev.preventDefault() ;
+
+ return false ;
+ }
+
+ return true ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckmenublock.js b/WebRoot/FCKeditor/editor/_source/classes/fckmenublock.js
new file mode 100644
index 0000000..4f1ffb2
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckmenublock.js
@@ -0,0 +1,143 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Renders a list of menu items.
+ */
+
+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' ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckmenublockpanel.js b/WebRoot/FCKeditor/editor/_source/classes/fckmenublockpanel.js
new file mode 100644
index 0000000..36cf083
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckmenublockpanel.js
@@ -0,0 +1,54 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * This class is a menu block that behaves like a panel. It's a mix of the
+ * FCKMenuBlock and FCKPanel classes.
+ */
+
+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() ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckmenuitem.js b/WebRoot/FCKeditor/editor/_source/classes/fckmenuitem.js
new file mode 100644
index 0000000..9e51ba1
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckmenuitem.js
@@ -0,0 +1,160 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Defines and renders a menu items in a menu block.
+ */
+
+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 ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckpanel.js b/WebRoot/FCKeditor/editor/_source/classes/fckpanel.js
new file mode 100644
index 0000000..7ab5093
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckpanel.js
@@ -0,0 +1,303 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Component that creates floating panels. It is used by many
+ * other components, like the toolbar items, context menu, etc...
+ */
+
+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 ;
+
+ FCK.IECleanup.AddItem( this, FCKPanel_Cleanup ) ;
+ }
+ 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( '<\/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' ;
+}
+
+
+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 )
+{
+ var iMainWidth ;
+
+ 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' : '' ;
+
+ 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' : '' ;
+
+ 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 ?
+ ( FCKTools.IsStrictMode( relElement ) ? relElement.documentElement : 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.GetDocumentWindow( 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 ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckplugin.js b/WebRoot/FCKeditor/editor/_source/classes/fckplugin.js
new file mode 100644
index 0000000..72b52f2
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckplugin.js
@@ -0,0 +1,56 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKPlugin Class: Represents a single plugin.
+ */
+
+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' ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckspecialcombo.js b/WebRoot/FCKeditor/editor/_source/classes/fckspecialcombo.js
new file mode 100644
index 0000000..7f5b534
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckspecialcombo.js
@@ -0,0 +1,363 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKSpecialCombo Class: represents a special combo.
+ */
+
+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 = '
' ;
+
+ 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 = '
' ;
+// 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 )
+{
+ //
' ;
+
+ this._LabelEl = oField.getElementsByTagName('label')[0] ; // Memory Leak
+ this._LabelEl.innerHTML = this.Label ;
+ }
+ else
+ {
+ oField.className = 'TB_Button_Off' ;
+ //oField.innerHTML = '' + this.Caption + '
' ;
+ //oField.innerHTML = '
' ;
+
+ // Gets the correct CSS class to use for the specified style (param).
+ oField.innerHTML = '' +
+ '
' ;
+ }
+
+
+ // 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:
+
+
![]()
+
+ No-Strip : Browser independent:
+
+*/
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js
new file mode 100644
index 0000000..75e7ebf
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js
@@ -0,0 +1,114 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ */
+
+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 )
+{
+ var oTargetDoc = targetSpecialCombo._Panel.Document ;
+
+ // Add the Editor Area CSS to the panel to create a realistic preview.
+ FCKTools.AppendStyleSheet( oTargetDoc, FCKConfig.ToolbarComboPreviewCSS ) ;
+
+ // Add ID and Class to the body
+ if ( FCKConfig.BodyId && FCKConfig.BodyId.length > 0 )
+ oTargetDoc.body.id = FCKConfig.BodyId ;
+ if ( FCKConfig.BodyClass && FCKConfig.BodyClass.length > 0 )
+ oTargetDoc.body.className += ' ' + FCKConfig.BodyClass ;
+
+ // 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, '\
+
' ;
+
+ 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 = '
' ;
+
+ oDiv.Command = this ;
+ oDiv.onclick = FCKTextColorCommand_MoreOnClick ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/fckconstants.js b/WebRoot/FCKeditor/editor/_source/fckconstants.js
new file mode 100644
index 0000000..75ef9bd
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/fckconstants.js
@@ -0,0 +1,52 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Defines some constants used by the editor. These constants are also
+ * globally available in the page where the editor is placed.
+ */
+
+// 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' ;
+
+var CTRL = 1000 ;
+var SHIFT = 2000 ;
+var ALT = 4000 ;
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/fckeditorapi.js b/WebRoot/FCKeditor/editor/_source/fckeditorapi.js
new file mode 100644
index 0000000..87fe508
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/fckeditorapi.js
@@ -0,0 +1,161 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Create the FCKeditorAPI object that is available as a global object in
+ * the page where the editor is placed in.
+ */
+
+var FCKeditorAPI ;
+
+function InitializeAPI()
+{
+ var oParentWindow = window.parent ;
+
+ if ( !( FCKeditorAPI = oParentWindow.FCKeditorAPI ) )
+ {
+ // Make the FCKeditorAPI object available in the parent window. Use
+ // eval so this core runs in the parent's scope and so it will still be
+ // available if the editor instance is removed ("Can't execute code
+ // from a freed script" error).
+
+ // Note: we check the existence of oEditor.GetParentForm because some external
+ // code (like JSON) can extend the Object protype and we get then extra oEditor
+ // objects that aren't really FCKeditor instances.
+ var sScript =
+ 'var FCKeditorAPI = {' +
+ 'Version : "2.4.2",' +
+ 'VersionBuild : "14978",' +
+ '__Instances : new Object(),' +
+
+ 'GetInstance : function( name )' +
+ '{' +
+ 'return this.__Instances[ name ];' +
+ '},' +
+
+ '_FormSubmit : function()' +
+ '{' +
+ 'for ( var name in FCKeditorAPI.__Instances )' +
+ '{' +
+ 'var oEditor = FCKeditorAPI.__Instances[ name ] ;' +
+ 'if ( oEditor.GetParentForm && oEditor.GetParentForm() == this )' +
+ 'oEditor.UpdateLinkedField() ;' +
+ '}' +
+ 'this._FCKOriginalSubmit() ;' +
+ '},' +
+
+ '_FunctionQueue : {' +
+ 'Functions : new Array(),' +
+ 'IsRunning : false,' +
+
+ 'Add : function( f )' +
+ '{' +
+ 'this.Functions.push( f );' +
+ '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( f )' +
+ '{' +
+ 'var aQueue = this.Functions;' +
+ 'var i = 0, fFunc;' +
+ 'while( (fFunc = aQueue[ i ]) )' +
+ '{' +
+ 'if ( fFunc == f )' +
+ '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 ( oParentWindow.execScript )
+ oParentWindow.execScript( sScript, 'JavaScript' ) ;
+ else
+ {
+ if ( FCKBrowserInfo.IsGecko10 )
+ {
+ // FF 1.0.4 gives an error with the request bellow. The
+ // following seams to work well.
+ eval.call( oParentWindow, sScript ) ;
+ }
+ else if ( FCKBrowserInfo.IsSafari )
+ {
+ // oParentWindow.eval in Safari executes in the calling window
+ // environment, instead of the parent one. The following should make it work.
+ var oParentDocument = oParentWindow.document ;
+ var eScript = oParentDocument.createElement('script') ;
+ eScript.appendChild( oParentDocument.createTextNode( sScript ) ) ;
+ oParentDocument.documentElement.appendChild( eScript ) ;
+ }
+ else
+ oParentWindow.eval( sScript ) ;
+ }
+
+ FCKeditorAPI = oParentWindow.FCKeditorAPI ;
+ }
+
+ // Add the current instance to the FCKeditorAPI's instances collection.
+ FCKeditorAPI.__Instances[ FCK.Name ] = FCK ;
+}
+
+// Attach to the form onsubmit event and to the form.submit().
+function _AttachFormSubmitToAPI()
+{
+ // Get the linked field form.
+ var oForm = FCK.GetParentForm() ;
+
+ if ( oForm )
+ {
+ // Attach to the onsubmit event.
+ FCKTools.AddEventListener( oForm, 'submit', FCK.UpdateLinkedField ) ;
+
+ // IE sees oForm.submit function as an 'object'.
+ if ( !oForm._FCKOriginalSubmit && ( typeof( oForm.submit ) == 'function' || ( !oForm.submit.tagName && !oForm.submit.length ) ) )
+ {
+ // Save the original submit.
+ oForm._FCKOriginalSubmit = oForm.submit ;
+
+ // Create our replacement for the submit.
+ oForm.submit = FCKeditorAPI._FormSubmit ;
+ }
+ }
+}
+
+function FCKeditorAPI_Cleanup()
+{
+ delete FCKeditorAPI.__Instances[ FCK.Name ] ;
+}
+FCKTools.AddEventListener( window, 'unload', FCKeditorAPI_Cleanup ) ;
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/fckjscoreextensions.js b/WebRoot/FCKeditor/editor/_source/fckjscoreextensions.js
new file mode 100644
index 0000000..dd4e1f7
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/fckjscoreextensions.js
@@ -0,0 +1,152 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Extensions to the JavaScript Core.
+ *
+ * All custom extentions functions are PascalCased to differ from the standard
+ * camelCased ones.
+ */
+
+String.prototype.Contains = function( textToCheck )
+{
+ return ( this.indexOf( textToCheck ) > -1 ) ;
+}
+
+String.prototype.Equals = function()
+{
+ var aArgs = arguments ;
+
+ // The arguments could also be a single array.
+ if ( aArgs.length == 1 && aArgs[0].pop )
+ aArgs = aArgs[0] ;
+
+ for ( var i = 0 ; i < aArgs.length ; i++ )
+ {
+ if ( this == aArgs[i] )
+ return true ;
+ }
+ return false ;
+}
+
+String.prototype.IEquals = function()
+{
+ var thisUpper = this.toUpperCase() ;
+
+ var aArgs = arguments ;
+
+ // The arguments could also be a single array.
+ if ( aArgs.length == 1 && aArgs[0].pop )
+ aArgs = aArgs[0] ;
+
+ for ( var i = 0 ; i < aArgs.length ; i++ )
+ {
+ if ( thisUpper == aArgs[i].toUpperCase() )
+ 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()
+{
+ // We are not using \s because we don't want "non-breaking spaces to be caught".
+ return this.replace( /(^[ \t\n\r]*)|([ \t\n\r]*$)/g, '' ) ;
+}
+
+String.prototype.LTrim = function()
+{
+ // We are not using \s because we don't want "non-breaking spaces to be caught".
+ return this.replace( /^[ \t\n\r]*/g, '' ) ;
+}
+
+String.prototype.RTrim = function()
+{
+ // We are not using \s because we don't want "non-breaking spaces to be caught".
+ return this.replace( /[ \t\n\r]*$/g, '' ) ;
+}
+
+String.prototype.ReplaceNewLineChars = function( replacement )
+{
+ return this.replace( /\n/g, replacement ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/fckscriptloader.js b/WebRoot/FCKeditor/editor/_source/fckscriptloader.js
new file mode 100644
index 0000000..6922783
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/fckscriptloader.js
@@ -0,0 +1,108 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * This is a utility object which can be used to load specific components of
+ * FCKeditor, including all dependencies.
+ */
+
+var FCK_GENERIC = 1 ;
+var FCK_GENERIC_SPECIFIC = 2 ;
+var FCK_SPECIFIC = 3 ;
+
+var FCKScriptLoader = new Object() ;
+FCKScriptLoader.FCKeditorPath = '/fckeditor/' ;
+
+FCKScriptLoader._Scripts = new Object() ;
+FCKScriptLoader._LoadedScripts = new Object() ;
+
+FCKScriptLoader._IsIE = (/msie/).test( navigator.userAgent.toLowerCase() ) ;
+
+FCKScriptLoader.Load = function( scriptName )
+{
+ // Check if the script has already been loaded.
+ if ( scriptName in FCKScriptLoader._LoadedScripts )
+ return ;
+
+ var oScriptInfo = this._Scripts[ scriptName ] ;
+
+ if ( !oScriptInfo )
+ {
+ alert( 'FCKScriptLoader: The script "' + scriptName + '" could not be loaded' ) ;
+ return ;
+ }
+
+ for ( var i = 0 ; i < oScriptInfo.Dependency.length ; i++ )
+ {
+ this.Load( oScriptInfo.Dependency[i] ) ;
+ }
+
+ var sBaseScriptName = oScriptInfo.BasePath + scriptName.toLowerCase() ;
+
+ if ( oScriptInfo.Compatibility == FCK_GENERIC || oScriptInfo.Compatibility == FCK_GENERIC_SPECIFIC )
+ this._LoadScript( sBaseScriptName + '.js' ) ;
+
+ if ( oScriptInfo.Compatibility == FCK_SPECIFIC || oScriptInfo.Compatibility == FCK_GENERIC_SPECIFIC )
+ {
+ if ( this._IsIE )
+ this._LoadScript( sBaseScriptName + '_ie.js' ) ;
+ else
+ this._LoadScript( sBaseScriptName + '_gecko.js' ) ;
+ }
+
+ FCKScriptLoader._LoadedScripts[ scriptName ] = true ;
+}
+
+FCKScriptLoader._LoadScript = function( scriptPathFromSource )
+{
+ document.write( '' + document.getElementById( 'xToolbarSpace' ).innerHTML + '' ) ;
+ 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 j = 0 ; j < aItems.length ; j++ )
+ aItems[j].Disable() ;
+ }
+}
+
+FCKToolbarSet.prototype.RefreshItemsState = function( editorInstance )
+{
+
+ var aItems = ( editorInstance ? editorInstance.ToolbarSet : this ).ItemsContextSensitive ;
+
+ for ( var i = 0 ; i < aItems.length ; i++ )
+ aItems[i].RefreshState() ;
+}
diff --git a/WebRoot/FCKeditor/editor/_source/internals/fcktools.js b/WebRoot/FCKeditor/editor/_source/internals/fcktools.js
new file mode 100644
index 0000000..b109e6b
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/internals/fcktools.js
@@ -0,0 +1,225 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Utility functions.
+ */
+
+// Constant for the Gecko Bogus Node.
+//var GECKO_BOGUS = '
' ; +var GECKO_BOGUS = '
' ; + +var FCKTools = new Object() ; + +FCKTools.CreateBogusBR = function( targetDocument ) +{ + var eBR = targetDocument.createElement( 'br' ) ; +// eBR.setAttribute( '_moz_editor_bogus_node', 'TRUE' ) ; + eBR.setAttribute( 'type', '_moz' ) ; + return eBR ; +} + +// Returns a reference to the appended style sheet or an array with all the appended references +FCKTools.AppendStyleSheet = function( documentElement, cssFileUrlOrArray ) +{ + if ( typeof( cssFileUrlOrArray ) == 'string' ) + return this._AppendStyleSheet( documentElement, cssFileUrlOrArray ) ; + else + { + var aStyleSheeArray = new Array() ; + + for ( var i = 0 ; i < cssFileUrlOrArray.length ; i++ ) + aStyleSheeArray.push(this._AppendStyleSheet( documentElement, cssFileUrlOrArray[i] ) ) ; + + return aStyleSheeArray ; + } +} + +FCKTools.GetElementDocument = function ( element ) +{ + return element.ownerDocument || element.document ; +} + +// Get the window object where the element is placed in. +FCKTools.GetElementWindow = function( element ) +{ + return this.GetDocumentWindow( this.GetElementDocument( element ) ) ; +} + +FCKTools.GetDocumentWindow = function( document ) +{ + // With Safari, there is not way to retrieve the window from the document, so we must fix it. + if ( FCKBrowserInfo.IsSafari && !document.parentWindow ) + this.FixDocumentParentWindow( window.top ) ; + + return document.parentWindow || document.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.HTMLEncode = function( text ) +{ + if ( !text ) + return '' ; + + text = text.replace( /&/g, '&' ) ; + text = text.replace( //g, '>' ) ; + + return text ; +} + +FCKTools.HTMLDecode = function( text ) +{ + if ( !text ) + return '' ; + + text = text.replace( />/g, '>' ) ; + text = text.replace( /</g, '<' ) ; + text = text.replace( /&/g, '&' ) ; + + 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, 10 ) ; +} + +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.IsStrictMode = function( document ) +{ + // There is no compatMode in Safari, but it seams that it always behave as + // CSS1Compat, so let's assume it as the default. + return ( 'CSS1Compat' == ( document.compatMode || 'CSS1Compat' ) ) ; +} + +// Transforms a "arguments" object to an array. +FCKTools.ArgumentsToArray = function( args, startIndex, maxLength ) +{ + startIndex = startIndex || 0 ; + maxLength = maxLength || args.length ; + + var argsArray = new Array() ; + + for ( var i = startIndex ; i < startIndex + maxLength && i < args.length ; i++ ) + argsArray.push( args[i] ) ; + + return argsArray ; +} + +FCKTools.CloneObject = function( sourceObject ) +{ + var fCloneCreator = function() {} ; + fCloneCreator.prototype = sourceObject ; + return new fCloneCreator ; +} diff --git a/WebRoot/FCKeditor/editor/_source/internals/fcktools_gecko.js b/WebRoot/FCKeditor/editor/_source/internals/fcktools_gecko.js new file mode 100644 index 0000000..9b72e8f --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fcktools_gecko.js @@ -0,0 +1,235 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Utility functions. (Gecko version). + */ + +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 ; +} + +// Replaces a tag with its contents. For example "My tag" +// will be replaced with "My tag". +FCKTools.RemoveOuterTags = function( e ) +{ + var oFragment = e.ownerDocument.createDocumentFragment() ; + + for ( var i = 0 ; i < e.childNodes.length ; i++ ) + oFragment.appendChild( e.childNodes[i].cloneNode(true) ) ; + + 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 ) + { + el = oOwnerWindow.frameElement ; + if ( el ) + oOwnerWindow = FCKTools.GetElementWindow( el ) ; + } + else + { + c.X += el.scrollLeft ; + c.Y += el.scrollTop ; + break ; + } + } + } + + // Return the Coordinates object + return c ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fcktools_ie.js b/WebRoot/FCKeditor/editor/_source/internals/fcktools_ie.js new file mode 100644 index 0000000..60ca4ce --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fcktools_ie.js @@ -0,0 +1,214 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Utility functions. (IE version). + */ + +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 ; + } + return null ; +} + +FCKTools.DisableSelection = function( element ) +{ + element.unselectable = 'on' ; + + var e, i = 0 ; + // The extra () is to avoid a warning with strict error checking. This is ok. + 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 ) ) ; +} + +// This function may be used by Regex replacements. +FCKTools.ToLowerCase = function( strValue ) +{ + return strValue.toLowerCase() ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckundo_gecko.js b/WebRoot/FCKeditor/editor/_source/internals/fckundo_gecko.js new file mode 100644 index 0000000..1a06c64 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckundo_gecko.js @@ -0,0 +1,27 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Fake implementation to ignore calls on Gecko. + */ + +var FCKUndo = new Object() ; + +FCKUndo.SaveUndoStep = function() +{} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckundo_ie.js b/WebRoot/FCKeditor/editor/_source/internals/fckundo_ie.js new file mode 100644 index 0000000..832d698 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckundo_ie.js @@ -0,0 +1,123 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * IE specific implementation for the Undo/Redo system. + */ + +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 ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckurlparams.js b/WebRoot/FCKeditor/editor/_source/internals/fckurlparams.js new file mode 100644 index 0000000..8bfe252 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckurlparams.js @@ -0,0 +1,39 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Defines the FCKURLParams object that is used to get all parameters + * passed by the URL QueryString (after the "?"). + */ + +// #### URLParams: holds all URL passed parameters (like ?Param1=Value1&Param2=Value2) +var FCKURLParams = new Object() ; + +(function() +{ + var aParams = document.location.search.substr(1).split('&') ; + for ( var i = 0 ; i < aParams.length ; i++ ) + { + var aParam = aParams[i].split('=') ; + var sParamName = decodeURIComponent( aParam[0] ) ; + var sParamValue = decodeURIComponent( aParam[1] ) ; + + FCKURLParams[ sParamName ] = sParamValue ; + } +})(); \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckxhtml.js b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml.js new file mode 100644 index 0000000..c8aa1fe --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml.js @@ -0,0 +1,466 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Defines the FCKXHtml object, responsible for the XHTML operations. + */ + +var FCKXHtml = new Object() ; + +FCKXHtml.CurrentJobNum = 0 ; + +FCKXHtml.GetXHTML = function( node, includeNode, format ) +{ + FCKXHtmlEntities.Initialize() ; + + // Set the correct entity to use for empty blocks. + this._NbspEntity = ( FCKConfig.ProcessHTMLEntities? 'nbsp' : '#160' ) ; + + // 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
added by Gecko. + // REMOVE: Maybe the following is not anymore necessary because a similar + // check is made on _AppendNode + if ( FCKBrowserInfo.IsGecko ) + sXHTML = sXHTML.replace( /
->
+ 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 ) +{ + try + { + if ( attributeValue == undefined || attributeValue == null ) + attributeValue = '' ; + else if ( attributeValue.replace ) + { + if ( FCKConfig.ForceSimpleAmpersand ) + attributeValue = attributeValue.replace( /&/g, '___FCKAmp___' ) ; + + // Entities must be replaced in the attribute values. + attributeValue = attributeValue.replace( FCKXHtmlEntities.EntitiesRegex, FCKXHtml_GetEntity ) ; + } + + // Create the attribute. + var oXmlAtt = this.XML.createAttribute( attributeName ) ; + oXmlAtt.value = attributeValue ; + + // Set the attribute in the node. + xmlNode.attributes.setNamedItem( oXmlAtt ) ; + } + catch (e) + {} +} + +FCKXHtml._AppendChildNodes = function( xmlNode, htmlNode, isBlockElement ) +{ + // Trim block elements. This is also needed to avoid Firefox leaving extra + // BRs at the end of them. + if ( isBlockElement ) + FCKDomTools.TrimNode( htmlNode, true ) ; + + 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, this._NbspEntity ) ; + return xmlNode ; + } + + var sNodeName = xmlNode.nodeName ; + + // Some inline elements are required to have something inside (span, strong, etc...). + if ( FCKListsLib.InlineChildReqElements[ sNodeName ] ) + return null ; + + // We can't use short representation of empty elements that are not marked + // as empty in th XHTML DTD. + if ( !FCKListsLib.EmptyElements[ sNodeName ] ) + xmlNode.appendChild( this.XML.createTextNode('') ) ; + } + + return xmlNode ; +} + +FCKXHtml._AppendNode = function( xmlNode, htmlNode ) +{ + if ( !htmlNode ) + return false ; + + 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.tagName.toLowerCase() ; + + if ( FCKBrowserInfo.IsIE ) + { + // IE doens't include the scope name in the nodeName. So, add the namespace. + if ( htmlNode.scopeName && htmlNode.scopeName != 'HTML' && htmlNode.scopeName != 'FCK' ) + sNodeName = htmlNode.scopeName.toLowerCase() + ':' + sNodeName ; + } + else + { + if ( sNodeName.StartsWith( 'fck:' ) ) + sNodeName = sNodeName.Remove( 0,4 ) ; + } + + // 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 ; + + // Remove the
if it is a bogus node. + if ( sNodeName == 'br' && 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 ) ; + else + oNode = this._AppendChildNodes( oNode, htmlNode, Boolean( FCKListsLib.NonEmptyBlockElements[ sNodeName ] ) ) ; + + if ( !oNode ) + return false ; + + xmlNode.appendChild( oNode ) ; + + break ; + + // Text Node. + case 3 : + return this._AppendTextNode( xmlNode, htmlNode.nodeValue.ReplaceNewLineChars(' ') ) ; + + // Comment + case 8 : + // IE catches the 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 ) +{ + var bHadText = textValue.length > 0 ; + if ( bHadText ) + targetNode.appendChild( this.XML.createTextNode( textValue.replace( FCKXHtmlEntities.EntitiesRegex, FCKXHtml_GetEntity ) ) ) ; + return bHadText ; +} + +// 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 &. 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 + ';' ; +} + +// Remove part of an attribute from a node according to a regExp +FCKXHtml._RemoveAttribute = function( xmlNode, regX, sAttribute ) +{ + var oAtt = xmlNode.attributes.getNamedItem( sAttribute ) ; + + if ( oAtt && regX.test( oAtt.nodeValue ) ) + { + var sValue = oAtt.nodeValue.replace( regX, '' ) ; + + if ( sValue.length == 0 ) + xmlNode.attributes.removeNamedItem( sAttribute ) ; + else + oAtt.nodeValue = sValue ; + } +} + +// An object that hold tag specific operations. +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 ; + }, + + a : function( node, htmlNode ) + { + // Firefox may create empty tags when deleting the selection in some special cases (SF-BUG 1556878). + if ( htmlNode.innerHTML.Trim().length == 0 && !htmlNode.name ) + return false ; + + var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ; + if ( sSavedUrl != null ) + FCKXHtml._AppendAttribute( node, 'href', sSavedUrl ) ; + + + // Anchors with content has been marked with an additional class, now we must remove it. + if ( FCKBrowserInfo.IsIE ) + { + FCKXHtml._RemoveAttribute( node, FCKRegexLib.FCK_Class, 'class' ) ; + + // Buggy IE, doesn't copy the name of changed anchors. + if ( htmlNode.name ) + FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; + } + + node = FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; + + return node ; + }, + + 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 ; + }, + + 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 ; + }, + + title : function( node, htmlNode ) + { + node.appendChild( FCKXHtml.XML.createTextNode( FCK.EditorDocument.title ) ) ; + + return node ; + }, + + 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. + + if ( FCKBrowserInfo.IsIE ) + FCKXHtml._RemoveAttribute( node, FCKRegexLib.FCK_Class, 'class' ) ; + + node = FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; + + return node ; + }, + + // Fix nested
+
+
+
+
+Bold 1
+ 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 ? ' ' : text ;
+
+ if ( this._LabelEl )
+ {
+ this._LabelEl.innerHTML = this.Label ;
+
+ // It may happen that the label is some HTML, including tags. This
+ // would be a problem because when the user click on those tags, the
+ // combo will get the selection from the editing area. So we must
+ // disable any kind of selection here.
+ FCKTools.DisableSelection( this._LabelEl ) ;
+ }
+}
+
+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 = ' + '.gif){kind=small} | ' +
+ '' + this.Caption + ' | ' + + ' | ' +
+ '
+
+
+
+
+*/
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckstyledef.js b/WebRoot/FCKeditor/editor/_source/classes/fckstyledef.js
new file mode 100644
index 0000000..f1e7304
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckstyledef.js
@@ -0,0 +1,59 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKStyleDef Class: represents a single style definition.
+ */
+
+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 '' ;
+}
+
+
+FCKStyleDef.prototype.RemoveFromSelection = function()
+{
+ if ( FCKSelection.GetType() == 'Control' )
+ this._RemoveMe( FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ) ;
+ else
+ this._RemoveMe( FCK.ToolbarSet.CurrentInstance.Selection.GetParentElement() ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckstyledef_gecko.js b/WebRoot/FCKeditor/editor/_source/classes/fckstyledef_gecko.js
new file mode 100644
index 0000000..5f2b03b
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckstyledef_gecko.js
@@ -0,0 +1,119 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKStyleDef Class: represents a single stylke definition. (Gecko specific)
+ */
+
+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 ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckstyledef_ie.js b/WebRoot/FCKeditor/editor/_source/classes/fckstyledef_ie.js
new file mode 100644
index 0000000..bcddeb2
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckstyledef_ie.js
@@ -0,0 +1,142 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKStyleDef Class: represents a single stylke definition. (IE specific)
+ */
+
+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 ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckstylesloader.js b/WebRoot/FCKeditor/editor/_source/classes/fckstylesloader.js
new file mode 100644
index 0000000..74b4a96
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckstylesloader.js
@@ -0,0 +1,88 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKStylesLoader Class: this class define objects that are responsible
+ * for loading the styles defined in the XML file.
+ */
+
+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 ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbar.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbar.js
new file mode 100644
index 0000000..50e45c4
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbar.js
@@ -0,0 +1,120 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbar Class: represents a toolbar in the toolbarset. It is a group of
+ * toolbar items.
+ */
+
+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' ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbreak_gecko.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbreak_gecko.js
new file mode 100644
index 0000000..87c97dc
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbreak_gecko.js
@@ -0,0 +1,36 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * 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.
+ */
+
+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 ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbreak_ie.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbreak_ie.js
new file mode 100644
index 0000000..2d9df63
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbreak_ie.js
@@ -0,0 +1,38 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * 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.
+ */
+
+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 ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbutton.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbutton.js
new file mode 100644
index 0000000..1372738
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbutton.js
@@ -0,0 +1,74 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarButton Class: represents a button in the toolbar.
+ */
+
+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 ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbuttonui.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbuttonui.js
new file mode 100644
index 0000000..1db2dee
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarbuttonui.js
@@ -0,0 +1,222 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarButtonUI Class: interface representation of a toolbar button.
+ */
+
+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 )
+ {
+ // | + | + |
{Image}
| {Image} | Toolbar Button |
| Toolbar Button |
{Image}
| {Image} | Toolbar Button |
| Toolbar Button |
+*/
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js
new file mode 100644
index 0000000..75e7ebf
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontformatcombo.js
@@ -0,0 +1,114 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ */
+
+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 )
+{
+ var oTargetDoc = targetSpecialCombo._Panel.Document ;
+
+ // Add the Editor Area CSS to the panel to create a realistic preview.
+ FCKTools.AppendStyleSheet( oTargetDoc, FCKConfig.ToolbarComboPreviewCSS ) ;
+
+ // Add ID and Class to the body
+ if ( FCKConfig.BodyId && FCKConfig.BodyId.length > 0 )
+ oTargetDoc.body.id = FCKConfig.BodyId ;
+ if ( FCKConfig.BodyClass && FCKConfig.BodyClass.length > 0 )
+ oTargetDoc.body.className += ' ' + FCKConfig.BodyClass ;
+
+ // 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, '<' + sTag + '>' + sLabel + '
', 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 != ' ' )
+ combo.DeselectAll(true) ;
+ }
+ else
+ {
+ if ( this._LastValue == value )
+ return ;
+
+ combo.SelectItemByLabel( value, true ) ;
+ }
+
+ this._LastValue = value ;
+ }
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontscombo.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontscombo.js
new file mode 100644
index 0000000..d17e989
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontscombo.js
@@ -0,0 +1,47 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ */
+
+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], '' + aFonts[i] + '' ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontsizecombo.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontsizecombo.js
new file mode 100644
index 0000000..d734331
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarfontsizecombo.js
@@ -0,0 +1,52 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ */
+
+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], '' + aSizeParts[1] + '', aSizeParts[1] ) ;
+ }
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarpanelbutton.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarpanelbutton.js
new file mode 100644
index 0000000..308fd77
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarpanelbutton.js
@@ -0,0 +1,91 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarPanelButton Class: represents a special button in the toolbar
+ * that shows a panel when pressed.
+ */
+
+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 ;
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarspecialcombo.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarspecialcombo.js
new file mode 100644
index 0000000..d8e8f3b
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarspecialcombo.js
@@ -0,0 +1,134 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * 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 ]
+ */
+
+var FCKToolbarSpecialCombo = function()
+{
+ this.SourceView = false ;
+ this.ContextSensitive = true ;
+ this._LastValue = null ;
+}
+
+
+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 ) ;
+}
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarstylecombo.js b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarstylecombo.js
new file mode 100644
index 0000000..27dfc48
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fcktoolbarstylecombo.js
@@ -0,0 +1,111 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKToolbarPanelButton Class: Handles the Fonts combo selector.
+ */
+
+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' ;
+
+ // Add ID and Class to the body
+ if ( FCKConfig.BodyId && FCKConfig.BodyId.length > 0 )
+ oTargetDoc.body.id = FCKConfig.BodyId ;
+ if ( FCKConfig.BodyClass && FCKConfig.BodyClass.length > 0 )
+ oTargetDoc.body.className += ' ' + FCKConfig.BodyClass ;
+
+
+ // For some reason Gecko is blocking inside the "RefreshVisibleItems" function.
+ // The problem is present only in old versions
+ if ( !( FCKBrowserInfo.IsGecko && FCKBrowserInfo.IsGecko10 ) )
+ 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.
+ }
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckw3crange.js b/WebRoot/FCKeditor/editor/_source/classes/fckw3crange.js
new file mode 100644
index 0000000..7cde7e6
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckw3crange.js
@@ -0,0 +1,448 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * This class partially implements the W3C DOM Range for browser that don't
+ * support the standards (like IE):
+ * http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html
+ */
+
+var FCKW3CRange = function( parentDocument )
+{
+ this._Document = parentDocument ;
+
+ this.startContainer = null ;
+ this.startOffset = null ;
+ this.endContainer = null ;
+ this.endOffset = null ;
+ this.collapsed = true ;
+}
+
+FCKW3CRange.CreateRange = function( parentDocument )
+{
+ // We could opt to use the Range implentation of the browsers. The problem
+ // is that every browser have different bugs on their implementations,
+ // mostly related to different interpretations of the W3C specifications.
+ // So, for now, let's use our implementation and pray for browsers fixings
+ // soon. Otherwise will go crazy on trying to find out workarounds.
+ /*
+ // Get the browser implementation of the range, if available.
+ if ( parentDocument.createRange )
+ {
+ var range = parentDocument.createRange() ;
+ if ( typeof( range.startContainer ) != 'undefined' )
+ return range ;
+ }
+ */
+ return new FCKW3CRange( parentDocument ) ;
+}
+
+FCKW3CRange.CreateFromRange = function( parentDocument, sourceRange )
+{
+ var range = FCKW3CRange.CreateRange( parentDocument ) ;
+ range.setStart( sourceRange.startContainer, sourceRange.startOffset ) ;
+ range.setEnd( sourceRange.endContainer, sourceRange.endOffset ) ;
+ return range ;
+}
+
+FCKW3CRange.prototype =
+{
+
+ _UpdateCollapsed : function()
+ {
+ this.collapsed = ( this.startContainer == this.endContainer && this.startOffset == this.endOffset ) ;
+ },
+
+ // W3C requires a check for the new position. If it is after the end
+ // boundary, the range should be collapsed to the new start. It seams we
+ // will not need this check for our use of this class so we can ignore it for now.
+ setStart : function( refNode, offset )
+ {
+ this.startContainer = refNode ;
+ this.startOffset = offset ;
+
+ if ( !this.endContainer )
+ {
+ this.endContainer = refNode ;
+ this.endOffset = offset ;
+ }
+
+ this._UpdateCollapsed() ;
+ },
+
+ // W3C requires a check for the new position. If it is before the start
+ // boundary, the range should be collapsed to the new end. It seams we
+ // will not need this check for our use of this class so we can ignore it for now.
+ setEnd : function( refNode, offset )
+ {
+ this.endContainer = refNode ;
+ this.endOffset = offset ;
+
+ if ( !this.startContainer )
+ {
+ this.startContainer = refNode ;
+ this.startOffset = offset ;
+ }
+
+ this._UpdateCollapsed() ;
+ },
+
+ setStartAfter : function( refNode )
+ {
+ this.setStart( refNode.parentNode, FCKDomTools.GetIndexOf( refNode ) + 1 ) ;
+ },
+
+ setStartBefore : function( refNode )
+ {
+ this.setStart( refNode.parentNode, FCKDomTools.GetIndexOf( refNode ) ) ;
+ },
+
+ setEndAfter : function( refNode )
+ {
+ this.setEnd( refNode.parentNode, FCKDomTools.GetIndexOf( refNode ) + 1 ) ;
+ },
+
+ setEndBefore : function( refNode )
+ {
+ this.setEnd( refNode.parentNode, FCKDomTools.GetIndexOf( refNode ) ) ;
+ },
+
+ collapse : function( toStart )
+ {
+ if ( toStart )
+ {
+ this.endContainer = this.startContainer ;
+ this.endOffset = this.startOffset ;
+ }
+ else
+ {
+ this.startContainer = this.endContainer ;
+ this.startOffset = this.endOffset ;
+ }
+
+ this.collapsed = true ;
+ },
+
+ selectNodeContents : function( refNode )
+ {
+ this.setStart( refNode, 0 ) ;
+ this.setEnd( refNode, refNode.nodeType == 3 ? refNode.data.length : refNode.childNodes.length ) ;
+ },
+
+ insertNode : function( newNode )
+ {
+ var startContainer = this.startContainer ;
+ var startOffset = this.startOffset ;
+
+ // If we are in a text node.
+ if ( startContainer.nodeType == 3 )
+ {
+ startContainer.splitText( startOffset ) ;
+
+ // Check if it is necessary to update the end boundary.
+ if ( startContainer == this.endContainer )
+ this.setEnd( startContainer.nextSibling, this.endOffset - this.startOffset ) ;
+
+ // Insert the new node it after the text node.
+ FCKDomTools.InsertAfterNode( startContainer, newNode ) ;
+
+ return ;
+ }
+ else
+ {
+ // Simply insert the new node before the current start node.
+ startContainer.insertBefore( newNode, startContainer.childNodes[ startOffset ] || null ) ;
+
+ // Check if it is necessary to update the end boundary.
+ if ( startContainer == this.endContainer )
+ {
+ this.endOffset++ ;
+ this.collapsed = false ;
+ }
+ }
+ },
+
+ deleteContents : function()
+ {
+ if ( this.collapsed )
+ return ;
+
+ this._ExecContentsAction( 0 ) ;
+ },
+
+ extractContents : function()
+ {
+ var docFrag = new FCKDocumentFragment( this._Document ) ;
+
+ if ( !this.collapsed )
+ this._ExecContentsAction( 1, docFrag ) ;
+
+ return docFrag ;
+ },
+
+ // The selection may be lost when clonning (due to the splitText() call).
+ cloneContents : function()
+ {
+ var docFrag = new FCKDocumentFragment( this._Document ) ;
+
+ if ( !this.collapsed )
+ this._ExecContentsAction( 2, docFrag ) ;
+
+ return docFrag ;
+ },
+
+ _ExecContentsAction : function( action, docFrag )
+ {
+ var startNode = this.startContainer ;
+ var endNode = this.endContainer ;
+
+ var startOffset = this.startOffset ;
+ var endOffset = this.endOffset ;
+
+ var removeStartNode = false ;
+ var removeEndNode = false ;
+
+ // Check the start and end nodes and make the necessary removals or changes.
+
+ // Start from the end, otherwise DOM mutations (splitText) made in the
+ // start boundary may interfere on the results here.
+
+ // For text containers, we must simply split the node and point to the
+ // second part. The removal will be handled by the rest of the code .
+ if ( endNode.nodeType == 3 )
+ endNode = endNode.splitText( endOffset ) ;
+ else
+ {
+ // If the end container has children and the offset is pointing
+ // to a child, then we should start from it.
+ if ( endNode.childNodes.length > 0 )
+ {
+ // If the offset points after the last node.
+ if ( endOffset > endNode.childNodes.length - 1 )
+ {
+ // Let's create a temporary node and mark it for removal.
+ endNode = FCKDomTools.InsertAfterNode( endNode.lastChild, this._Document.createTextNode('') ) ;
+ removeEndNode = true ;
+ }
+ else
+ endNode = endNode.childNodes[ endOffset ] ;
+ }
+ }
+
+ // For text containers, we must simply split the node. The removal will
+ // be handled by the rest of the code .
+ if ( startNode.nodeType == 3 )
+ {
+ startNode.splitText( startOffset ) ;
+
+ // In cases the end node is the same as the start node, the above
+ // splitting will also split the end, so me must move the end to
+ // the second part of the split.
+ if ( startNode == endNode )
+ endNode = startNode.nextSibling ;
+ }
+ else
+ {
+ // If the start container has children and the offset is pointing
+ // to a child, then we should start from its previous sibling.
+ if ( startNode.childNodes.length > 0 && startOffset <= startNode.childNodes.length - 1 )
+ {
+ // If the offset points to the first node, we don't have a
+ // sibling, so let's use the first one, but mark it for removal.
+ if ( startOffset == 0 )
+ {
+ // Let's create a temporary node and mark it for removal.
+ startNode = startNode.insertBefore( this._Document.createTextNode(''), startNode.firstChild ) ;
+ removeStartNode = true ;
+ }
+ else
+ startNode = startNode.childNodes[ startOffset ].previousSibling ;
+ }
+ }
+
+ // Get the parent nodes tree for the start and end boundaries.
+ var startParents = FCKDomTools.GetParents( startNode ) ;
+ var endParents = FCKDomTools.GetParents( endNode ) ;
+
+ // Compare them, to find the top most siblings.
+ var i, topStart, topEnd ;
+
+ for ( i = 0 ; i < startParents.length ; i++ )
+ {
+ topStart = startParents[i] ;
+ topEnd = endParents[i] ;
+
+ // The compared nodes will match until we find the top most
+ // siblings (different nodes that have the same parent).
+ // "i" will hold the index in the parants array for the top
+ // most element.
+ if ( topStart != topEnd )
+ break ;
+ }
+
+ var clone, levelStartNode, levelClone, currentNode, currentSibling ;
+
+ if ( docFrag )
+ clone = docFrag.RootNode ;
+
+ // Remove all successive sibling nodes for every node in the
+ // startParents tree.
+ for ( var j = i ; j < startParents.length ; j++ )
+ {
+ levelStartNode = startParents[j] ;
+
+ // For Extract and Clone, we must clone this level.
+ if ( clone && levelStartNode != startNode ) // action = 0 = Delete
+ levelClone = clone.appendChild( levelStartNode.cloneNode( levelStartNode == startNode ) ) ;
+
+ currentNode = levelStartNode.nextSibling ;
+
+ while( currentNode )
+ {
+ // Stop processing when the current node matches a node in the
+ // endParents tree or if it is the endNode.
+ if ( currentNode == endParents[j] || currentNode == endNode )
+ break ;
+
+ // Cache the next sibling.
+ currentSibling = currentNode.nextSibling ;
+
+ // If clonning, just clone it.
+ if ( action == 2 ) // 2 = Clone
+ clone.appendChild( currentNode.cloneNode( true ) ) ;
+ else
+ {
+ // Both Delete and Extract will remove the node.
+ currentNode.parentNode.removeChild( currentNode ) ;
+
+ // When Extracting, move the removed node to the docFrag.
+ if ( action == 1 ) // 1 = Extract
+ clone.appendChild( currentNode ) ;
+ }
+
+ currentNode = currentSibling ;
+ }
+
+ if ( clone )
+ clone = levelClone ;
+ }
+
+ if ( docFrag )
+ clone = docFrag.RootNode ;
+
+ // Remove all previous sibling nodes for every node in the
+ // endParents tree.
+ for ( var k = i ; k < endParents.length ; k++ )
+ {
+ levelStartNode = endParents[k] ;
+
+ // For Extract and Clone, we must clone this level.
+ if ( action > 0 && levelStartNode != endNode ) // action = 0 = Delete
+ levelClone = clone.appendChild( levelStartNode.cloneNode( levelStartNode == endNode ) ) ;
+
+ // The processing of siblings may have already been done by the parent.
+ if ( !startParents[k] || levelStartNode.parentNode != startParents[k].parentNode )
+ {
+ currentNode = levelStartNode.previousSibling ;
+
+ while( currentNode )
+ {
+ // Stop processing when the current node matches a node in the
+ // startParents tree or if it is the startNode.
+ if ( currentNode == startParents[k] || currentNode == startNode )
+ break ;
+
+ // Cache the next sibling.
+ currentSibling = currentNode.previousSibling ;
+
+ // If clonning, just clone it.
+ if ( action == 2 ) // 2 = Clone
+ clone.insertBefore( currentNode.cloneNode( true ), clone.firstChild ) ;
+ else
+ {
+ // Both Delete and Extract will remove the node.
+ currentNode.parentNode.removeChild( currentNode ) ;
+
+ // When Extracting, mode the removed node to the docFrag.
+ if ( action == 1 ) // 1 = Extract
+ clone.insertBefore( currentNode, clone.firstChild ) ;
+ }
+
+ currentNode = currentSibling ;
+ }
+ }
+
+ if ( clone )
+ clone = levelClone ;
+ }
+
+ if ( action == 2 ) // 2 = Clone.
+ {
+ // No changes in the DOM should be done, so fix the split text (if any).
+
+ var startTextNode = this.startContainer ;
+ if ( startTextNode.nodeType == 3 )
+ {
+ startTextNode.data += startTextNode.nextSibling.data ;
+ startTextNode.parentNode.removeChild( startTextNode.nextSibling ) ;
+ }
+
+ var endTextNode = this.endContainer ;
+ if ( endTextNode.nodeType == 3 && endTextNode.nextSibling )
+ {
+ endTextNode.data += endTextNode.nextSibling.data ;
+ endTextNode.parentNode.removeChild( endTextNode.nextSibling ) ;
+ }
+ }
+ else
+ {
+ // Collapse the range.
+
+ // If a node has been partially selected, collapse the range between
+ // topStart and topEnd. Otherwise, simply collapse it to the start. (W3C specs).
+ if ( topStart && topEnd && ( startNode.parentNode != topStart.parentNode || endNode.parentNode != topEnd.parentNode ) )
+ this.setStart( topEnd.parentNode, FCKDomTools.GetIndexOf( topEnd ) ) ;
+
+ // Collapse it to the start.
+ this.collapse( true ) ;
+ }
+
+ // Cleanup any marked node.
+ if( removeStartNode )
+ startNode.parentNode.removeChild( startNode ) ;
+
+ if( removeEndNode && endNode.parentNode )
+ endNode.parentNode.removeChild( endNode ) ;
+ },
+
+ cloneRange : function()
+ {
+ return FCKW3CRange.CreateFromRange( this._Document, this ) ;
+ },
+
+ toString : function()
+ {
+ var docFrag = this.cloneContents() ;
+
+ var tmpDiv = this._Document.createElement( 'div' ) ;
+ docFrag.AppendTo( tmpDiv ) ;
+
+ return tmpDiv.textContent || tmpDiv.innerText ;
+ }
+} ;
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckxml_gecko.js b/WebRoot/FCKeditor/editor/_source/classes/fckxml_gecko.js
new file mode 100644
index 0000000..6ff03b6
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckxml_gecko.js
@@ -0,0 +1,87 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKXml Class: class to load and manipulate XML files.
+ */
+
+var FCKXml = function()
+{}
+
+FCKXml.prototype.LoadUrl = function( urlToCall )
+{
+ this.Error = false ;
+ 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
+ this.DOMDocument = null ;
+
+ if ( this.DOMDocument == null || this.DOMDocument.firstChild == null )
+ {
+ this.Error = true ;
+ if (window.confirm( 'Error loading "' + urlToCall + '"\r\nDo you want to see more info?' ) )
+ alert( 'URL requested: "' + urlToCall + '"\r\n' +
+ 'Server response:\r\nStatus: ' + oXmlHttp.status + '\r\n' +
+ 'Response text:\r\n' + oXmlHttp.responseText ) ;
+
+ }
+}
+
+FCKXml.prototype.SelectNodes = function( xpath, contextNode )
+{
+ if ( this.Error )
+ return new Array() ;
+
+ 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 )
+{
+ if ( this.Error )
+ return null ;
+
+ 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 ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/classes/fckxml_ie.js b/WebRoot/FCKeditor/editor/_source/classes/fckxml_ie.js
new file mode 100644
index 0000000..31e91d9
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/classes/fckxml_ie.js
@@ -0,0 +1,90 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKXml Class: class to load and manipulate XML files.
+ * (IE specific implementation)
+ */
+
+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.DOMDocument = null ;
+ }
+
+ if ( this.DOMDocument == null || this.DOMDocument.firstChild == null )
+ {
+ this.Error = true ;
+ if (window.confirm( 'Error loading "' + urlToCall + '"\r\nDo you want to see more info?' ) )
+ alert( 'URL requested: "' + urlToCall + '"\r\n' +
+ 'Server response:\r\nStatus: ' + oXmlHttp.status + '\r\n' +
+ 'Response text:\r\n' + oXmlHttp.responseText ) ;
+ }
+}
+
+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 null ;
+
+ if ( contextNode )
+ return contextNode.selectSingleNode( xpath ) ;
+ else
+ return this.DOMDocument.selectSingleNode( xpath ) ;
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fck_othercommands.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fck_othercommands.js
new file mode 100644
index 0000000..64594f1
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fck_othercommands.js
@@ -0,0 +1,380 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Definition of other commands that are not available internaly in the
+ * browser (see FCKNamedCommand).
+ */
+
+// ### 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 ;
+
+ this.Resizable = false ;
+}
+
+FCKDialogCommand.prototype.Execute = function()
+{
+ FCKDialog.OpenDialog( 'FCKDialog_' + this.Name , this.Title, this.Url, this.Width, this.Height, null, null, this.Resizable ) ;
+}
+
+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, 10) ;
+
+ 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', '' ) ; + 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.GetParentForm() ; + + 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 ; +} + +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 = ' ' ; + + 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() +{ + var state = FCK.GetNamedCommandState( this.Name ) ; + + // Check that it isn't an anchor + if ( state == FCK_TRISTATE_OFF && FCK.EditMode == FCK_EDITMODE_WYSIWYG ) + { + var oLink = FCKSelection.MoveToAncestorNode( 'A' ) ; + var bIsAnchor = ( oLink && oLink.name.length > 0 && oLink.href.length == 0 ) ; + if ( bIsAnchor ) + state = FCK_TRISTATE_DISABLED ; + } + + return state ; +} + +// FCKSelectAllCommand +var FCKSelectAllCommand = function() +{ + this.Name = 'SelectAll' ; +} + +FCKSelectAllCommand.prototype.Execute = function() +{ + if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) + { + FCK.ExecuteNamedCommand( 'SelectAll' ) ; + } + else + { + // Select the contents of the textarea + var textarea = FCK.EditingArea.Textarea ; + if ( FCKBrowserInfo.IsIE ) + { + textarea.createTextRange().execCommand( 'SelectAll' ) ; + } + else + { + textarea.selectionStart = 0; + textarea.selectionEnd = textarea.value.length ; + } + textarea.focus() ; + } +} + +FCKSelectAllCommand.prototype.GetState = function() +{ + return FCK_TRISTATE_OFF ; +} + +// FCKPasteCommand +var FCKPasteCommand = function() +{ + this.Name = 'Paste' ; +} + +FCKPasteCommand.prototype = +{ + Execute : function() + { + if ( FCKBrowserInfo.IsIE ) + FCK.Paste() ; + else + FCK.ExecuteNamedCommand( 'Paste' ) ; + }, + + GetState : function() + { + return FCK.GetNamedCommandState( 'Paste' ) ; + } +} ; \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fckfitwindow.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fckfitwindow.js new file mode 100644 index 0000000..ef39712 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fckfitwindow.js @@ -0,0 +1,169 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Stretch the editor to full window size and back. + */ + +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 ; + var eParent ; + + // 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. + eParent = eEditorFrame ; + // The extra () is to avoid a warning with strict error checking. This is ok. + 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. + eParent = eEditorFrame ; + // The extra () is to avoid a warning with strict error checking. This is ok. + 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' ; +} diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fcknamedcommand.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fcknamedcommand.js new file mode 100644 index 0000000..7ce996e --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fcknamedcommand.js @@ -0,0 +1,37 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKNamedCommand Class: represents an internal browser command. + */ + +var FCKNamedCommand = function( commandName ) +{ + this.Name = commandName ; +} + +FCKNamedCommand.prototype.Execute = function() +{ + FCK.ExecuteNamedCommand( this.Name ) ; +} + +FCKNamedCommand.prototype.GetState = function() +{ + return FCK.GetNamedCommandState( this.Name ) ; +} diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fckpasteplaintextcommand.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fckpasteplaintextcommand.js new file mode 100644 index 0000000..d05bbc7 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fckpasteplaintextcommand.js @@ -0,0 +1,38 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKPastePlainTextCommand Class: represents the + * "Paste as Plain Text" command. + */ + +var FCKPastePlainTextCommand = function() +{ + this.Name = 'PasteText' ; +} + +FCKPastePlainTextCommand.prototype.Execute = function() +{ + FCK.PasteAsPlainText() ; +} + +FCKPastePlainTextCommand.prototype.GetState = function() +{ + return FCK.GetNamedCommandState( 'Paste' ) ; +} diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fckpastewordcommand.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fckpastewordcommand.js new file mode 100644 index 0000000..eb22cc9 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fckpastewordcommand.js @@ -0,0 +1,40 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKPasteWordCommand Class: represents the "Paste from Word" command. + */ + +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' ) ; +} diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_gecko.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_gecko.js new file mode 100644 index 0000000..0b60ef3 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_gecko.js @@ -0,0 +1,39 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKStyleCommand Class: represents the "Spell Check" command. + * (Gecko specific implementation) + */ + +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 ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_ie.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_ie.js new file mode 100644 index 0000000..30e5526 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fckspellcheckcommand_ie.js @@ -0,0 +1,67 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKStyleCommand Class: represents the "Spell Check" command. + * (IE specific implementation) + */ + +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 ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fckstylecommand.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fckstylecommand.js new file mode 100644 index 0000000..d976367 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fckstylecommand.js @@ -0,0 +1,99 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKStyleCommand Class: represents the "Style" command. + */ + +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 ) ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fcktablecommand.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fcktablecommand.js new file mode 100644 index 0000000..4d77098 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fcktablecommand.js @@ -0,0 +1,71 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKPastePlainTextCommand Class: represents the + * "Paste as Plain Text" command. + */ + +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 ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/commandclasses/fcktextcolorcommand.js b/WebRoot/FCKeditor/editor/_source/commandclasses/fcktextcolorcommand.js new file mode 100644 index 0000000..2d6e746 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/commandclasses/fcktextcolorcommand.js @@ -0,0 +1,175 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * FCKTextColorCommand Class: represents the text color comand. It shows the + * color selection panel. + */ + +// 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 = + '
| ' + FCKLang.ColorAutomatic + ' | \ +
' ;
+
+ 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 = '
| ' + FCKLang.ColorMoreColors + ' |
' ; +var GECKO_BOGUS = '
' ; + +var FCKTools = new Object() ; + +FCKTools.CreateBogusBR = function( targetDocument ) +{ + var eBR = targetDocument.createElement( 'br' ) ; +// eBR.setAttribute( '_moz_editor_bogus_node', 'TRUE' ) ; + eBR.setAttribute( 'type', '_moz' ) ; + return eBR ; +} + +// Returns a reference to the appended style sheet or an array with all the appended references +FCKTools.AppendStyleSheet = function( documentElement, cssFileUrlOrArray ) +{ + if ( typeof( cssFileUrlOrArray ) == 'string' ) + return this._AppendStyleSheet( documentElement, cssFileUrlOrArray ) ; + else + { + var aStyleSheeArray = new Array() ; + + for ( var i = 0 ; i < cssFileUrlOrArray.length ; i++ ) + aStyleSheeArray.push(this._AppendStyleSheet( documentElement, cssFileUrlOrArray[i] ) ) ; + + return aStyleSheeArray ; + } +} + +FCKTools.GetElementDocument = function ( element ) +{ + return element.ownerDocument || element.document ; +} + +// Get the window object where the element is placed in. +FCKTools.GetElementWindow = function( element ) +{ + return this.GetDocumentWindow( this.GetElementDocument( element ) ) ; +} + +FCKTools.GetDocumentWindow = function( document ) +{ + // With Safari, there is not way to retrieve the window from the document, so we must fix it. + if ( FCKBrowserInfo.IsSafari && !document.parentWindow ) + this.FixDocumentParentWindow( window.top ) ; + + return document.parentWindow || document.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.HTMLEncode = function( text ) +{ + if ( !text ) + return '' ; + + text = text.replace( /&/g, '&' ) ; + text = text.replace( //g, '>' ) ; + + return text ; +} + +FCKTools.HTMLDecode = function( text ) +{ + if ( !text ) + return '' ; + + text = text.replace( />/g, '>' ) ; + text = text.replace( /</g, '<' ) ; + text = text.replace( /&/g, '&' ) ; + + 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, 10 ) ; +} + +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.IsStrictMode = function( document ) +{ + // There is no compatMode in Safari, but it seams that it always behave as + // CSS1Compat, so let's assume it as the default. + return ( 'CSS1Compat' == ( document.compatMode || 'CSS1Compat' ) ) ; +} + +// Transforms a "arguments" object to an array. +FCKTools.ArgumentsToArray = function( args, startIndex, maxLength ) +{ + startIndex = startIndex || 0 ; + maxLength = maxLength || args.length ; + + var argsArray = new Array() ; + + for ( var i = startIndex ; i < startIndex + maxLength && i < args.length ; i++ ) + argsArray.push( args[i] ) ; + + return argsArray ; +} + +FCKTools.CloneObject = function( sourceObject ) +{ + var fCloneCreator = function() {} ; + fCloneCreator.prototype = sourceObject ; + return new fCloneCreator ; +} diff --git a/WebRoot/FCKeditor/editor/_source/internals/fcktools_gecko.js b/WebRoot/FCKeditor/editor/_source/internals/fcktools_gecko.js new file mode 100644 index 0000000..9b72e8f --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fcktools_gecko.js @@ -0,0 +1,235 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Utility functions. (Gecko version). + */ + +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 ; +} + +// Replaces a tag with its contents. For example "My tag" +// will be replaced with "My tag". +FCKTools.RemoveOuterTags = function( e ) +{ + var oFragment = e.ownerDocument.createDocumentFragment() ; + + for ( var i = 0 ; i < e.childNodes.length ; i++ ) + oFragment.appendChild( e.childNodes[i].cloneNode(true) ) ; + + 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 ) + { + el = oOwnerWindow.frameElement ; + if ( el ) + oOwnerWindow = FCKTools.GetElementWindow( el ) ; + } + else + { + c.X += el.scrollLeft ; + c.Y += el.scrollTop ; + break ; + } + } + } + + // Return the Coordinates object + return c ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fcktools_ie.js b/WebRoot/FCKeditor/editor/_source/internals/fcktools_ie.js new file mode 100644 index 0000000..60ca4ce --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fcktools_ie.js @@ -0,0 +1,214 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Utility functions. (IE version). + */ + +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 ; + } + return null ; +} + +FCKTools.DisableSelection = function( element ) +{ + element.unselectable = 'on' ; + + var e, i = 0 ; + // The extra () is to avoid a warning with strict error checking. This is ok. + 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 ) ) ; +} + +// This function may be used by Regex replacements. +FCKTools.ToLowerCase = function( strValue ) +{ + return strValue.toLowerCase() ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckundo_gecko.js b/WebRoot/FCKeditor/editor/_source/internals/fckundo_gecko.js new file mode 100644 index 0000000..1a06c64 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckundo_gecko.js @@ -0,0 +1,27 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Fake implementation to ignore calls on Gecko. + */ + +var FCKUndo = new Object() ; + +FCKUndo.SaveUndoStep = function() +{} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckundo_ie.js b/WebRoot/FCKeditor/editor/_source/internals/fckundo_ie.js new file mode 100644 index 0000000..832d698 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckundo_ie.js @@ -0,0 +1,123 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * IE specific implementation for the Undo/Redo system. + */ + +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 ; +} \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckurlparams.js b/WebRoot/FCKeditor/editor/_source/internals/fckurlparams.js new file mode 100644 index 0000000..8bfe252 --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckurlparams.js @@ -0,0 +1,39 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Defines the FCKURLParams object that is used to get all parameters + * passed by the URL QueryString (after the "?"). + */ + +// #### URLParams: holds all URL passed parameters (like ?Param1=Value1&Param2=Value2) +var FCKURLParams = new Object() ; + +(function() +{ + var aParams = document.location.search.substr(1).split('&') ; + for ( var i = 0 ; i < aParams.length ; i++ ) + { + var aParam = aParams[i].split('=') ; + var sParamName = decodeURIComponent( aParam[0] ) ; + var sParamValue = decodeURIComponent( aParam[1] ) ; + + FCKURLParams[ sParamName ] = sParamValue ; + } +})(); \ No newline at end of file diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckxhtml.js b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml.js new file mode 100644 index 0000000..c8aa1fe --- /dev/null +++ b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml.js @@ -0,0 +1,466 @@ +/* + * FCKeditor - The text editor for Internet - http://www.fckeditor.net + * Copyright (C) 2003-2007 Frederico Caldeira Knabben + * + * == BEGIN LICENSE == + * + * Licensed under the terms of any of the following licenses at your + * choice: + * + * - GNU General Public License Version 2 or later (the "GPL") + * http://www.gnu.org/licenses/gpl.html + * + * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") + * http://www.gnu.org/licenses/lgpl.html + * + * - Mozilla Public License Version 1.1 or later (the "MPL") + * http://www.mozilla.org/MPL/MPL-1.1.html + * + * == END LICENSE == + * + * Defines the FCKXHtml object, responsible for the XHTML operations. + */ + +var FCKXHtml = new Object() ; + +FCKXHtml.CurrentJobNum = 0 ; + +FCKXHtml.GetXHTML = function( node, includeNode, format ) +{ + FCKXHtmlEntities.Initialize() ; + + // Set the correct entity to use for empty blocks. + this._NbspEntity = ( FCKConfig.ProcessHTMLEntities? 'nbsp' : '#160' ) ; + + // 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
added by Gecko. + // REMOVE: Maybe the following is not anymore necessary because a similar + // check is made on _AppendNode + if ( FCKBrowserInfo.IsGecko ) + sXHTML = sXHTML.replace( /
->
+ 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 ) +{ + try + { + if ( attributeValue == undefined || attributeValue == null ) + attributeValue = '' ; + else if ( attributeValue.replace ) + { + if ( FCKConfig.ForceSimpleAmpersand ) + attributeValue = attributeValue.replace( /&/g, '___FCKAmp___' ) ; + + // Entities must be replaced in the attribute values. + attributeValue = attributeValue.replace( FCKXHtmlEntities.EntitiesRegex, FCKXHtml_GetEntity ) ; + } + + // Create the attribute. + var oXmlAtt = this.XML.createAttribute( attributeName ) ; + oXmlAtt.value = attributeValue ; + + // Set the attribute in the node. + xmlNode.attributes.setNamedItem( oXmlAtt ) ; + } + catch (e) + {} +} + +FCKXHtml._AppendChildNodes = function( xmlNode, htmlNode, isBlockElement ) +{ + // Trim block elements. This is also needed to avoid Firefox leaving extra + // BRs at the end of them. + if ( isBlockElement ) + FCKDomTools.TrimNode( htmlNode, true ) ; + + 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, this._NbspEntity ) ; + return xmlNode ; + } + + var sNodeName = xmlNode.nodeName ; + + // Some inline elements are required to have something inside (span, strong, etc...). + if ( FCKListsLib.InlineChildReqElements[ sNodeName ] ) + return null ; + + // We can't use short representation of empty elements that are not marked + // as empty in th XHTML DTD. + if ( !FCKListsLib.EmptyElements[ sNodeName ] ) + xmlNode.appendChild( this.XML.createTextNode('') ) ; + } + + return xmlNode ; +} + +FCKXHtml._AppendNode = function( xmlNode, htmlNode ) +{ + if ( !htmlNode ) + return false ; + + 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.tagName.toLowerCase() ; + + if ( FCKBrowserInfo.IsIE ) + { + // IE doens't include the scope name in the nodeName. So, add the namespace. + if ( htmlNode.scopeName && htmlNode.scopeName != 'HTML' && htmlNode.scopeName != 'FCK' ) + sNodeName = htmlNode.scopeName.toLowerCase() + ':' + sNodeName ; + } + else + { + if ( sNodeName.StartsWith( 'fck:' ) ) + sNodeName = sNodeName.Remove( 0,4 ) ; + } + + // 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 ; + + // Remove the
if it is a bogus node. + if ( sNodeName == 'br' && 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 ) ; + else + oNode = this._AppendChildNodes( oNode, htmlNode, Boolean( FCKListsLib.NonEmptyBlockElements[ sNodeName ] ) ) ; + + if ( !oNode ) + return false ; + + xmlNode.appendChild( oNode ) ; + + break ; + + // Text Node. + case 3 : + return this._AppendTextNode( xmlNode, htmlNode.nodeValue.ReplaceNewLineChars(' ') ) ; + + // Comment + case 8 : + // IE catches the 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 ) +{ + var bHadText = textValue.length > 0 ; + if ( bHadText ) + targetNode.appendChild( this.XML.createTextNode( textValue.replace( FCKXHtmlEntities.EntitiesRegex, FCKXHtml_GetEntity ) ) ) ; + return bHadText ; +} + +// 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 &. 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 + ';' ; +} + +// Remove part of an attribute from a node according to a regExp +FCKXHtml._RemoveAttribute = function( xmlNode, regX, sAttribute ) +{ + var oAtt = xmlNode.attributes.getNamedItem( sAttribute ) ; + + if ( oAtt && regX.test( oAtt.nodeValue ) ) + { + var sValue = oAtt.nodeValue.replace( regX, '' ) ; + + if ( sValue.length == 0 ) + xmlNode.attributes.removeNamedItem( sAttribute ) ; + else + oAtt.nodeValue = sValue ; + } +} + +// An object that hold tag specific operations. +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 ; + }, + + a : function( node, htmlNode ) + { + // Firefox may create empty tags when deleting the selection in some special cases (SF-BUG 1556878). + if ( htmlNode.innerHTML.Trim().length == 0 && !htmlNode.name ) + return false ; + + var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ; + if ( sSavedUrl != null ) + FCKXHtml._AppendAttribute( node, 'href', sSavedUrl ) ; + + + // Anchors with content has been marked with an additional class, now we must remove it. + if ( FCKBrowserInfo.IsIE ) + { + FCKXHtml._RemoveAttribute( node, FCKRegexLib.FCK_Class, 'class' ) ; + + // Buggy IE, doesn't copy the name of changed anchors. + if ( htmlNode.name ) + FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; + } + + node = FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; + + return node ; + }, + + 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 ; + }, + + 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 ; + }, + + title : function( node, htmlNode ) + { + node.appendChild( FCKXHtml.XML.createTextNode( FCK.EditorDocument.title ) ) ; + + return node ; + }, + + 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. + + if ( FCKBrowserInfo.IsIE ) + FCKXHtml._RemoveAttribute( node, FCKRegexLib.FCK_Class, 'class' ) ; + + node = FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; + + return node ; + }, + + // Fix nested
- and
- .
+ ol : function( node, htmlNode, targetNode )
+ {
+ if ( htmlNode.innerHTML.Trim().length == 0 )
+ return false ;
+
+ 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 false ;
+ }
+
+ node = FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+ return node ;
+ },
+
+ 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 ;
+
+ node = FCKXHtml._AppendChildNodes( node, htmlNode, false ) ;
+
+ return node ;
+ },
+
+ // IE loses contents of iframes, and Gecko does give it back HtmlEncoded
+ // Note: Opera does lose the content and doesn't provide it in the innerHTML string
+ iframe : function( node, htmlNode )
+ {
+ var sHtml = htmlNode.innerHTML ;
+
+ // Gecko does give back the encoded html
+ if ( FCKBrowserInfo.IsGecko )
+ sHtml = FCKTools.HTMLDecode( sHtml );
+
+ // Remove the saved urls here as the data won't be processed as nodes
+ sHtml = sHtml.replace( /\s_fcksavedurl="[^"]*"/g, '' ) ;
+
+ node.appendChild( FCKXHtml.XML.createTextNode( FCKXHtml._AppendSpecialItem( sHtml ) ) ) ;
+
+ return node ;
+ }
+} ;
+
+FCKXHtml.TagProcessors.ul = FCKXHtml.TagProcessors.ol ;
diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckxhtml_gecko.js b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml_gecko.js
new file mode 100644
index 0000000..9b3ba0e
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml_gecko.js
@@ -0,0 +1,66 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Defines the FCKXHtml object, responsible for the XHTML operations.
+ * Gecko specific.
+ */
+
+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 ) ;
+ }
+ }
+}
\ No newline at end of file
diff --git a/WebRoot/FCKeditor/editor/_source/internals/fckxhtml_ie.js b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml_ie.js
new file mode 100644
index 0000000..f199b54
--- /dev/null
+++ b/WebRoot/FCKeditor/editor/_source/internals/fckxhtml_ie.js
@@ -0,0 +1,194 @@
+/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2007 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * Defines the FCKXHtml object, responsible for the XHTML operations.
+ * IE specific.
+ */
+
+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.replace( FCKRegexLib.StyleProperties, FCKTools.ToLowerCase ) ;
+ // 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 ;
+ else
+ {
+ // We must use getAttribute to get it exactly as it is defined.
+ // There are some rare cases that IE throws an error here, so we must try/catch.
+ try
+ {
+ sAttValue = htmlNode.getAttribute( sAttName, 2 ) ;
+ }
+ catch (e) {}
+ }
+ this._AppendAttribute( node, sAttName, sAttValue || oAttribute.nodeValue ) ;
+ }
+ }
+}
+
+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 tags to .
+FCKXHtml.TagProcessors['font'] = function( node, htmlNode )
+{
+ if ( node.attributes.length == 0 )
+ node = FCKXHtml.XML.createDocumentFragment() ;
+
+ node = FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+ return node ;
+}
+
+// IE doens't see the value attribute as an attribute for the 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' ) ;
+
+ node = 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 sShape = htmlNode.getAttribute( 'shape', 2 ) ;
+ if ( sShape && sShape.length > 0 )
+ FCKXHtml._AppendAttribute( node, 'shape', sShape ) ;
+ }
+
+ return node ;
+}
+
+FCKXHtml.TagProcessors['label'] = function( node, htmlNode )
+{
+ if ( htmlNode.htmlFor.length > 0 )
+ FCKXHtml._AppendAttribute( node, 'for', htmlNode.htmlFor ) ;
+
+ node = 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 ) ;
+
+ node = FCKXHtml._AppendChildNodes( node, htmlNode ) ;
+
+ return node ;
+}
+
+// IE doens't hold the name attribute as an attribute for the
+
+ Document Description
+ +
+ Author
+
+
+ Copyright
+ +