diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenugroup.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenugroup.js
new file mode 100644
index 00000000..d5019178
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenugroup.js
@@ -0,0 +1,71 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckcontextmenugroup.js
+ * FCKContextMenuGroup Class: represents a group of items in the context
+ * menu. Generaly a group of items is directly dependent of the same rules.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKContextMenuGroup = function( addSeparator, contextMenu, firstItemCommand, firstItemLabel, hasIcon )
+{
+ this.IsVisible = true ;
+
+ // Array with all available context menu items of this group.
+ this.Items = new Array() ;
+
+ if ( addSeparator )
+ this.Add( new FCKContextMenuSeparator() ) ;
+
+ if ( contextMenu && firstItemCommand && firstItemLabel )
+ this.Add( new FCKContextMenuItem( contextMenu, firstItemCommand, firstItemLabel, hasIcon ) ) ;
+
+ // This OPTIONAL function checks if the group must be shown.
+ this.ValidationFunction = null ;
+}
+
+// Adds an item to the group's items collecion.
+FCKContextMenuGroup.prototype.Add = function( contextMenuItem )
+{
+ this.Items[ this.Items.length ] = contextMenuItem ;
+}
+
+// Creates the
elements that represent the item in a table (usually the rendered context menu).
+FCKContextMenuGroup.prototype.CreateTableRows = function( table )
+{
+ for ( var i = 0 ; i < this.Items.length ; i++ )
+ {
+ this.Items[i].CreateTableRow( table ) ;
+ }
+}
+
+FCKContextMenuGroup.prototype.SetVisible = function( isVisible )
+{
+ for ( var i = 0 ; i < this.Items.length ; i++ )
+ {
+ this.Items[i].SetVisible( isVisible ) ;
+ }
+
+ this.IsVisible = isVisible ;
+}
+
+FCKContextMenuGroup.prototype.RefreshState = function()
+{
+ if ( ! this.IsVisible ) return ;
+
+ for ( var i = 0 ; i < this.Items.length ; i++ )
+ {
+ this.Items[i].RefreshState() ;
+ }
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenuitem.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenuitem.js
new file mode 100644
index 00000000..b28471b5
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenuitem.js
@@ -0,0 +1,103 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckcontextmenuitem.js
+ * FCKContextMenuItem Class: represents a item in the context menu.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKContextMenuItem = function( contextMenu, commandName, label, hasIcon )
+{
+ this.ContextMenu = contextMenu ;
+ this.Command = FCKCommands.GetCommand( commandName ) ;
+ this.Label = label ? label : commandName ;
+ this.HasIcon = hasIcon ? true : false ;
+}
+
+function FCKContextMenuItem_OnMouseOver()
+{
+ if ( this.className != 'CM_Disabled' )
+ this.className = 'CM_Over' ;
+}
+
+function FCKContextMenuItem_OnMouseOut()
+{
+ if ( this.className != 'CM_Disabled' )
+ this.className = 'CM_Option' ;
+}
+
+function FCKContextMenuItem_OnClick()
+{
+ if ( this.className != 'CM_Disabled' )
+ {
+ this.FCKContextMenuItem.ContextMenu.Hide() ;
+ this.FCKContextMenuItem.Command.Execute() ;
+ }
+ return false ;
+}
+
+FCKContextMenuItem.prototype.CreateTableRow = function( targetTable )
+{
+ // Creates the
+*/
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenuseparator.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenuseparator.js
new file mode 100644
index 00000000..75c1bca2
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fckcontextmenuseparator.js
@@ -0,0 +1,57 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckcontextmenuseparator.js
+ * FCKContextMenuSeparator Class: represents a separator in the toolbar.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKContextMenuSeparator = function()
+{
+}
+
+FCKContextMenuSeparator.prototype.CreateTableRow = function( targetTable )
+{
+ // Creates the
' ;
+ } else
+ message = 'OutputObject : Object is "null".' ;
+
+ FCKDebug.Output( message, color, true ) ;
+ }
+}
+else
+{
+ FCKDebug.Output = function() {}
+ FCKDebug.OutputObject = function() {}
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog.js
new file mode 100644
index 00000000..041888b8
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog.js
@@ -0,0 +1,34 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckdialog.js
+ * Dialog windows operations.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKDialog = new Object() ;
+
+// This method opens a dialog window using the standard dialog template.
+FCKDialog.OpenDialog = function( dialogName, dialogTitle, dialogPage, width, height, customValue, parentWindow, resizable )
+{
+ // Setup the dialog info.
+ var oDialogInfo = new Object() ;
+ oDialogInfo.Title = dialogTitle ;
+ oDialogInfo.Page = dialogPage ;
+ oDialogInfo.Editor = window ;
+ oDialogInfo.CustomValue = customValue ; // Optional
+
+ var sUrl = FCKConfig.BasePath + 'fckdialog.html' ;
+ this.Show( oDialogInfo, dialogName, sUrl, width, height, parentWindow, resizable ) ;
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog_gecko.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog_gecko.js
new file mode 100644
index 00000000..e837c462
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog_gecko.js
@@ -0,0 +1,98 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckdialog_gecko.js
+ * Dialog windows operations. (Gecko specific implementations)
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKDialog.Show = function( dialogInfo, dialogName, pageUrl, dialogWidth, dialogHeight, parentWindow, resizable )
+{
+ var iTop = (FCKConfig.ScreenHeight - dialogHeight) / 2 ;
+ var iLeft = (FCKConfig.ScreenWidth - dialogWidth) / 2 ;
+
+ var sOption = "location=no,menubar=no,toolbar=no,dependent=yes,dialog=yes,minimizable=no,modal=yes,alwaysRaised=yes" +
+ ",resizable=" + ( resizable ? 'yes' : 'no' ) +
+ ",width=" + dialogWidth +
+ ",height=" + dialogHeight +
+ ",top=" + iTop +
+ ",left=" + iLeft ;
+
+ if ( !parentWindow )
+ parentWindow = window ;
+
+ var oWindow = parentWindow.open( '', 'FCKeditorDialog_' + dialogName, sOption, true ) ;
+
+ if ( !oWindow )
+ {
+ alert( FCKLang.DialogBlocked ) ;
+ return ;
+ }
+
+ oWindow.moveTo( iLeft, iTop ) ;
+ oWindow.resizeTo( dialogWidth, dialogHeight ) ;
+ oWindow.focus() ;
+ oWindow.location.href = pageUrl ;
+
+ oWindow.dialogArguments = dialogInfo ;
+
+ // On some Gecko browsers (probably over slow connections) the
+ // "dialogArguments" are not set to the target window so we must
+ // put it in the opener window so it can be used by the target one.
+ parentWindow.FCKLastDialogInfo = dialogInfo ;
+
+ this.Window = oWindow ;
+
+ // Try/Catch must be used to avoit an error when using a frameset
+ // on a different domain:
+ // "Permission denied to get property Window.releaseEvents".
+ try
+ {
+ window.top.captureEvents( Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS ) ;
+ window.top.parent.addEventListener( 'mousedown', this.CheckFocus, true ) ;
+ window.top.parent.addEventListener( 'mouseup', this.CheckFocus, true ) ;
+ window.top.parent.addEventListener( 'click', this.CheckFocus, true ) ;
+ window.top.parent.addEventListener( 'focus', this.CheckFocus, true ) ;
+ }
+ catch (e)
+ {}
+}
+
+FCKDialog.CheckFocus = function()
+{
+ // It is strange, but we have to check the FCKDialog existence to avoid a
+ // random error: "FCKDialog is not defined".
+ if ( typeof( FCKDialog ) != "object" )
+ return false ;
+
+ if ( FCKDialog.Window && !FCKDialog.Window.closed )
+ FCKDialog.Window.focus() ;
+ else
+ {
+ // Try/Catch must be used to avoit an error when using a frameset
+ // on a different domain:
+ // "Permission denied to get property Window.releaseEvents".
+ try
+ {
+ window.top.releaseEvents(Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS) ;
+ window.top.parent.removeEventListener( 'onmousedown', FCKDialog.CheckFocus, true ) ;
+ window.top.parent.removeEventListener( 'mouseup', FCKDialog.CheckFocus, true ) ;
+ window.top.parent.removeEventListener( 'click', FCKDialog.CheckFocus, true ) ;
+ window.top.parent.removeEventListener( 'onfocus', FCKDialog.CheckFocus, true ) ;
+ }
+ catch (e)
+ {}
+ }
+ return false ;
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog_ie.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog_ie.js
new file mode 100644
index 00000000..76ec61bb
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckdialog_ie.js
@@ -0,0 +1,30 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckdialog_ie.js
+ * Dialog windows operations. (IE specific implementations)
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKDialog.Show = function( dialogInfo, dialogName, pageUrl, dialogWidth, dialogHeight, parentWindow )
+{
+ if ( !parentWindow )
+ parentWindow = window ;
+
+ this.IsOpened = true ;
+
+ parentWindow.showModalDialog( pageUrl, dialogInfo, "dialogWidth:" + dialogWidth + "px;dialogHeight:" + dialogHeight + "px;help:no;scroll:no;status:no") ;
+
+ this.IsOpened = false ;
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcklanguagemanager.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcklanguagemanager.js
new file mode 100644
index 00000000..41251512
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcklanguagemanager.js
@@ -0,0 +1,95 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcklanguagemanager.js
+ * Defines the FCKLanguageManager object that is used for language
+ * operations.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKLanguageManager.GetActiveLanguage = function()
+{
+ if ( FCKConfig.AutoDetectLanguage )
+ {
+ var sUserLang ;
+
+ // IE accepts "navigator.userLanguage" while Gecko "navigator.language".
+ if ( navigator.userLanguage )
+ sUserLang = navigator.userLanguage.toLowerCase() ;
+ else if ( navigator.language )
+ sUserLang = navigator.language.toLowerCase() ;
+ else
+ {
+ // Firefox 1.0 PR has a bug: it doens't support the "language" property.
+ return FCKConfig.DefaultLanguage ;
+ }
+
+ // Some language codes are set in 5 characters,
+ // like "pt-br" for Brasilian Portuguese.
+ if ( sUserLang.length >= 5 )
+ {
+ sUserLang = sUserLang.substr(0,5) ;
+ if ( this.AvailableLanguages[sUserLang] ) return sUserLang ;
+ }
+
+ // If the user's browser is set to, for example, "pt-br" but only the
+ // "pt" language file is available then get that file.
+ if ( sUserLang.length >= 2 )
+ {
+ sUserLang = sUserLang.substr(0,2) ;
+ if ( this.AvailableLanguages[sUserLang] ) return sUserLang ;
+ }
+ }
+
+ return this.DefaultLanguage ;
+}
+
+FCKLanguageManager.TranslateElements = function( targetDocument, tag, propertyToSet )
+{
+ var e = targetDocument.getElementsByTagName(tag) ;
+
+ for ( var i = 0 ; i < e.length ; i++ )
+ {
+ var sKey = e[i].getAttribute( 'fckLang' ) ;
+
+ if ( sKey )
+ {
+ var s = FCKLang[ sKey ] ;
+ if ( s )
+ eval( 'e[i].' + propertyToSet + ' = s' ) ;
+ }
+ }
+}
+
+FCKLanguageManager.TranslatePage = function( targetDocument )
+{
+ this.TranslateElements( targetDocument, 'INPUT', 'value' ) ;
+ this.TranslateElements( targetDocument, 'SPAN', 'innerHTML' ) ;
+ this.TranslateElements( targetDocument, 'LABEL', 'innerHTML' ) ;
+ this.TranslateElements( targetDocument, 'OPTION', 'innerHTML' ) ;
+}
+
+if ( FCKLanguageManager.AvailableLanguages[ FCKConfig.DefaultLanguage ] )
+ FCKLanguageManager.DefaultLanguage = FCKConfig.DefaultLanguage ;
+else
+ FCKLanguageManager.DefaultLanguage = 'en' ;
+
+FCKLanguageManager.ActiveLanguage = new Object() ;
+FCKLanguageManager.ActiveLanguage.Code = FCKLanguageManager.GetActiveLanguage() ;
+FCKLanguageManager.ActiveLanguage.Name = FCKLanguageManager.AvailableLanguages[ FCKLanguageManager.ActiveLanguage.Code ] ;
+
+FCK.Language = FCKLanguageManager ;
+
+// Load the language file and start the editor.
+LoadLanguageFile() ;
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcknamespace.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcknamespace.js
new file mode 100644
index 00000000..0de0b5bd
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcknamespace.js
@@ -0,0 +1,27 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcknamespace.js
+ * This file declares the namespace (object holder) where the common editor
+ * objects and classes are defined.
+ * The namespace is located in the page the editor is running on, so it is
+ * shared by all editor instances.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var NS ;
+
+if ( !( NS = window.parent.__FCKeditorNS ) )
+ NS = window.parent.__FCKeditorNS = new Object() ;
+
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckplugins.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckplugins.js
new file mode 100644
index 00000000..d207df46
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckplugins.js
@@ -0,0 +1,44 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckplugins.js
+ * Defines the FCKPlugins object that is responsible for loading the Plugins.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKPlugins = FCK.Plugins = new Object() ;
+FCKPlugins.ItemsCount = 0 ;
+FCKPlugins.Loaded = false ;
+FCKPlugins.Items = new Object() ;
+
+// Set the defined plugins scripts paths.
+for ( var i = 0 ; i < FCKConfig.Plugins.Items.length ; i++ )
+{
+ var oItem = FCKConfig.Plugins.Items[i] ;
+ FCKPlugins.Items[ oItem[0] ] = new FCKPlugin( oItem[0], oItem[1], oItem[2] ) ;
+ FCKPlugins.ItemsCount++ ;
+}
+
+FCKPlugins.Load = function()
+{
+ // Load all items.
+ for ( var s in this.Items )
+ this.Items[s].Load() ;
+
+ // Mark as loaded.
+ this.Loaded = true ;
+
+ // This is a self destroyable function (must be called once).
+ FCKPlugins.Load = null ;
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckregexlib.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckregexlib.js
new file mode 100644
index 00000000..a7752761
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckregexlib.js
@@ -0,0 +1,98 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckregexlib.js
+ * These are some Regular Expresions used by the editor.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKRegexLib = new Object() ;
+
+// This is the Regular expression used by the SetHTML method for the "'" entity.
+FCKRegexLib.AposEntity = /'/gi ;
+
+// Used by the Styles combo to identify styles that can't be applied to text.
+FCKRegexLib.ObjectElements = /^(?:IMG|TABLE|TR|TD|TH|INPUT|SELECT|TEXTAREA|HR|OBJECT|A|UL|OL|LI)$/i ;
+
+// START iCM MODIFICATIONS
+// Added TABLE and CAPTION to the block elements for ENTER key handling
+// Block Elements.
+/*
+FCKRegexLib.BlockElements = /^(?:P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TD|TABLE|CAPTION)$/i ;
+*/
+// END iCM MODIFICATIONS
+FCKRegexLib.BlockElements = /^(?:P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TD|TH)$/i ;
+
+// Elements marked as empty "Empty" in the XHTML DTD.
+FCKRegexLib.EmptyElements = /^(?:BASE|META|LINK|HR|BR|PARAM|IMG|AREA|INPUT)$/i ;
+
+// List all named commands (commands that can be interpreted by the browser "execCommand" method.
+FCKRegexLib.NamedCommands = /^(?:Cut|Copy|Paste|Print|SelectAll|RemoveFormat|Unlink|Undo|Redo|Bold|Italic|Underline|StrikeThrough|Subscript|Superscript|JustifyLeft|JustifyCenter|JustifyRight|JustifyFull|Outdent|Indent|InsertOrderedList|InsertUnorderedList|InsertHorizontalRule)$/i ;
+
+FCKRegexLib.BodyContents = /([\s\S]*\]*\>)([\s\S]*)(\<\/body\>[\s\S]*)/i ;
+
+// Temporary text used to solve some browser specific limitations.
+FCKRegexLib.ToReplace = /___fcktoreplace:([\w]+)/ig ;
+
+// Get the META http-equiv attribute from the tag.
+FCKRegexLib.MetaHttpEquiv = /http-equiv\s*=\s*["']?([^"' ]+)/i ;
+
+FCKRegexLib.HasBaseTag = /]*>/i ;
+FCKRegexLib.HeadCloser = /<\/head\s*>/i ;
+
+FCKRegexLib.TableBorderClass = /\s*FCK__ShowTableBorders\s*/ ;
+
+// Validate element names.
+FCKRegexLib.ElementName = /^[A-Za-z_:][\w.\-:]*$/ ;
+
+// Used in conjuction with the FCKConfig.ForceSimpleAmpersand configuration option.
+FCKRegexLib.ForceSimpleAmpersand = /___FCKAmp___/g ;
+
+// Get the closing parts of the tags with no closing tags, like ... gets the "/>" part.
+FCKRegexLib.SpaceNoClose = /\/>/g ;
+
+FCKRegexLib.EmptyParagraph = /^<(p|div)>\s*<\/\1>$/i ;
+
+FCKRegexLib.TagBody = />]*>\s*<\/\1>/gi ;
+*/
+// END iCM MODIFICATIONS
+
+FCKRegexLib.StrongOpener = /])/gi ;
+FCKRegexLib.StrongCloser = /<\/STRONG>/gi ;
+FCKRegexLib.EmOpener = /])/gi ;
+FCKRegexLib.EmCloser = /<\/EM>/gi ;
+
+FCKRegexLib.GeckoEntitiesMarker = /#\?-\:/g ;
+
+FCKRegexLib.ProtectUrlsAApo = /(]+)/gi ;
+
+FCKRegexLib.ProtectUrlsImgApo = /(]+)/gi ;
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckscriptloader.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckscriptloader.js
new file mode 100644
index 00000000..50182c80
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckscriptloader.js
@@ -0,0 +1,119 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckscriptloader.js
+ * Defines the FCKScriptLoader object that is used to dynamically load
+ * scripts in the editor.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// This object is used to download scripts and css files sequentialy.
+// A file download is not started until the previous file was not completelly
+// downloaded.
+var FCKScriptLoader = new Object() ;
+FCKScriptLoader.IsLoading = false ;
+FCKScriptLoader.Queue = new Array() ;
+
+// Adds a script or css to the queue.
+FCKScriptLoader.AddScript = function( scriptPath )
+{
+ FCKScriptLoader.Queue[ FCKScriptLoader.Queue.length ] = scriptPath ;
+
+ if ( !this.IsLoading )
+ this.CheckQueue() ;
+}
+
+// Checks the queue to see if there is something to load.
+// This function should not be called by code. It's a internal function
+// that's called recursively.
+FCKScriptLoader.CheckQueue = function()
+{
+ // Check if the queue is not empty.
+ if ( this.Queue.length > 0 )
+ {
+ this.IsLoading = true ;
+
+ // Get the first item in the queue
+ var sScriptPath = this.Queue[0] ;
+
+ // Removes the first item from the queue
+ var oTempArray = new Array() ;
+ for ( i = 1 ; i < this.Queue.length ; i++ )
+ oTempArray[ i - 1 ] = this.Queue[ i ] ;
+ this.Queue = oTempArray ;
+
+ this.LoadFile( sScriptPath ) ;
+ }
+ else
+ {
+ this.IsLoading = false ;
+
+ // Call the "OnEmpty" event.
+ if ( this.OnEmpty )
+ this.OnEmpty() ;
+ }
+}
+
+FCKScriptLoader.LoadFile = function( filePath )
+{
+ //window.status = ( 'Loading ' + filePath + '...' ) ;
+
+ // Dynamically load the file (it can be a CSS or a JS)
+ var e ;
+
+ // If it is a CSS
+ if ( filePath.lastIndexOf( '.css' ) > 0 )
+ {
+ e = document.createElement( 'LINK' ) ;
+ e.rel = 'stylesheet' ;
+ e.type = 'text/css' ;
+ }
+ // It it is a JS
+ else
+ {
+ e = document.createElement( "script" ) ;
+ e.type = "text/javascript" ;
+ }
+
+ // Add the new object to the HEAD.
+ document.getElementsByTagName("head")[0].appendChild( e ) ;
+
+ // Start downloading it.
+ if ( e.tagName == 'LINK' )
+ {
+ // IE must wait for the file to be downloaded.
+ if ( FCKBrowserInfo.IsIE )
+ e.onload = FCKScriptLoader_OnLoad ;
+ // Gecko doens't fire any event when the CSS is loaded, so we
+ // can't wait for it.
+ else
+ FCKScriptLoader.CheckQueue() ;
+
+ e.href = filePath ;
+ }
+ else
+ {
+ // Gecko fires the "onload" event and IE fires "onreadystatechange"
+ e.onload = e.onreadystatechange = FCKScriptLoader_OnLoad ;
+ e.src = filePath ;
+ }
+}
+
+function FCKScriptLoader_OnLoad()
+{
+ // Gecko doesn't have a "readyState" property
+ if ( this.tagName == 'LINK' || !this.readyState || this.readyState == 'loaded' )
+ // Load the next script available in the queue
+ FCKScriptLoader.CheckQueue() ;
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection.js
new file mode 100644
index 00000000..15a97ba8
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection.js
@@ -0,0 +1,22 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckselection.js
+ * Active selection functions.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKSelection = new Object() ;
+
+FCK.Selection = FCKSelection ;
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection_gecko.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection_gecko.js
new file mode 100644
index 00000000..148bd46d
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection_gecko.js
@@ -0,0 +1,168 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckselection_gecko.js
+ * Active selection functions. (Gecko specific implementation)
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Get the selection type (like document.select.type in IE).
+FCKSelection.GetType = function()
+{
+// if ( ! this._Type )
+// {
+ // By default set the type to "Text".
+ this._Type = 'Text' ;
+
+ // Check if the actual selection is a Control (IMG, TABLE, HR, etc...).
+ var oSel ;
+ try { oSel = FCK.EditorWindow.getSelection() ; }
+ catch (e) {}
+
+ if ( oSel && oSel.rangeCount == 1 )
+ {
+ var oRange = oSel.getRangeAt(0) ;
+ if ( oRange.startContainer == oRange.endContainer && (oRange.endOffset - oRange.startOffset) == 1 )
+ this._Type = 'Control' ;
+ }
+// }
+ return this._Type ;
+}
+
+// Retrieves the selected element (if any), just in the case that a single
+// element (object like and image or a table) is selected.
+FCKSelection.GetSelectedElement = function()
+{
+ if ( this.GetType() == 'Control' )
+ {
+ var oSel = FCK.EditorWindow.getSelection() ;
+ return oSel.anchorNode.childNodes[ oSel.anchorOffset ] ;
+ }
+}
+
+FCKSelection.GetParentElement = function()
+{
+ if ( this.GetType() == 'Control' )
+ return FCKSelection.GetSelectedElement().parentNode ;
+ else
+ {
+ var oSel = FCK.EditorWindow.getSelection() ;
+ if ( oSel )
+ {
+ var oNode = oSel.anchorNode ;
+
+ while ( oNode && oNode.nodeType != 1 )
+ oNode = oNode.parentNode ;
+
+ return oNode ;
+ }
+ }
+}
+
+FCKSelection.SelectNode = function( element )
+{
+ FCK.Focus() ;
+
+ var oRange = FCK.EditorDocument.createRange() ;
+ oRange.selectNode( element ) ;
+
+ var oSel = FCK.EditorWindow.getSelection() ;
+ oSel.removeAllRanges() ;
+ oSel.addRange( oRange ) ;
+}
+
+FCKSelection.Collapse = function( toStart )
+{
+ var oSel = FCK.EditorWindow.getSelection() ;
+
+ if ( toStart == null || toStart === true )
+ oSel.collapseToStart() ;
+ else
+ oSel.collapseToEnd() ;
+}
+
+// The "nodeTagName" parameter must be Upper Case.
+FCKSelection.HasAncestorNode = function( nodeTagName )
+{
+ var oContainer = this.GetSelectedElement() ;
+ if ( ! oContainer && FCK.EditorWindow )
+ {
+ try { oContainer = FCK.EditorWindow.getSelection().getRangeAt(0).startContainer ; }
+ catch(e){}
+ }
+
+ while ( oContainer )
+ {
+ if ( oContainer.nodeType == 1 && oContainer.tagName == nodeTagName ) return true ;
+ oContainer = oContainer.parentNode ;
+ }
+
+ return false ;
+}
+
+// The "nodeTagName" parameter must be Upper Case.
+FCKSelection.MoveToAncestorNode = function( nodeTagName )
+{
+ var oNode ;
+
+ var oContainer = this.GetSelectedElement() ;
+ if ( ! oContainer )
+ oContainer = FCK.EditorWindow.getSelection().getRangeAt(0).startContainer ;
+
+ while ( oContainer )
+ {
+ if ( oContainer.tagName == nodeTagName )
+ return oContainer ;
+ oContainer = oContainer.parentNode ;
+ }
+ return null ;
+}
+
+FCKSelection.Delete = function()
+{
+ // Gets the actual selection.
+ var oSel = FCK.EditorWindow.getSelection() ;
+
+ // Deletes the actual selection contents.
+ for ( var i = 0 ; i < oSel.rangeCount ; i++ )
+ {
+ oSel.getRangeAt(i).deleteContents() ;
+ }
+
+ return oSel ;
+}
+
+// START iCM MODIFICATIONS
+/*
+// Move the cursor position (the selection point) to a specific offset within a specific node
+// If no offset specified, the start of the node is assumed
+FCKSelection.SetCursorPosition = function ( oNode, nOffset )
+{
+ if ( typeof nOffset == "undefined" ) nOffset = 0 ;
+
+ var oSel = FCK.EditorWindow.getSelection() ;
+ var oRange = FCK.EditorDocument.createRange() ;
+
+ oRange.setStart( oNode, nOffset ) ;
+ oRange.collapse( true ) ;
+
+ oSel.removeAllRanges() ;
+ oSel.addRange( oRange );
+
+ if ( oNode.scrollIntoView )
+ oNode.scrollIntoView( false );
+}
+*/
+// END iCM MODIFICATIONS
+
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection_ie.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection_ie.js
new file mode 100644
index 00000000..fe8a0524
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckselection_ie.js
@@ -0,0 +1,150 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckselection_ie.js
+ * Active selection functions. (IE specific implementation)
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Get the selection type.
+FCKSelection.GetType = function()
+{
+ return FCK.EditorDocument.selection.type ;
+}
+
+// Retrieves the selected element (if any), just in the case that a single
+// element (object like and image or a table) is selected.
+FCKSelection.GetSelectedElement = function()
+{
+ if ( this.GetType() == 'Control' )
+ {
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+
+ if ( oRange && oRange.item )
+ return FCK.EditorDocument.selection.createRange().item(0) ;
+ }
+}
+
+FCKSelection.GetParentElement = function()
+{
+ switch ( this.GetType() )
+ {
+ case 'Control' :
+ return FCKSelection.GetSelectedElement().parentElement ;
+ case 'None' :
+ return ;
+ default :
+ return FCK.EditorDocument.selection.createRange().parentElement() ;
+ }
+}
+
+FCKSelection.SelectNode = function( node )
+{
+ FCK.Focus() ;
+ FCK.EditorDocument.selection.empty() ;
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+ oRange.moveToElementText( node ) ;
+ oRange.select() ;
+}
+
+FCKSelection.Collapse = function( toStart )
+{
+ FCK.Focus() ;
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+ oRange.collapse( toStart == null || toStart === true ) ;
+ oRange.select() ;
+}
+
+// The "nodeTagName" parameter must be Upper Case.
+FCKSelection.HasAncestorNode = function( nodeTagName )
+{
+ var oContainer ;
+
+ if ( FCK.EditorDocument.selection.type == "Control" )
+ {
+ oContainer = this.GetSelectedElement() ;
+ }
+ else
+ {
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+ oContainer = oRange.parentElement() ;
+ }
+
+ while ( oContainer )
+ {
+ if ( oContainer.tagName == nodeTagName ) return true ;
+ oContainer = oContainer.parentNode ;
+ }
+
+ return false ;
+}
+
+// The "nodeTagName" parameter must be UPPER CASE.
+FCKSelection.MoveToAncestorNode = function( nodeTagName )
+{
+ var oNode ;
+
+ if ( FCK.EditorDocument.selection.type == "Control" )
+ {
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+ for ( i = 0 ; i < oRange.length ; i++ )
+ {
+ if (oRange(i).parentNode)
+ {
+ oNode = oRange(i).parentNode ;
+ break ;
+ }
+ }
+ }
+ else
+ {
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+ oNode = oRange.parentElement() ;
+ }
+
+ while ( oNode && oNode.nodeName != nodeTagName )
+ oNode = oNode.parentNode ;
+
+ return oNode ;
+}
+
+FCKSelection.Delete = function()
+{
+ // Gets the actual selection.
+ var oSel = FCK.EditorDocument.selection ;
+
+ // Deletes the actual selection contents.
+ if ( oSel.type.toLowerCase() != "none" )
+ {
+ oSel.clear() ;
+ }
+
+ return oSel ;
+}
+// START iCM Modifications
+/*
+// Move the cursor position (the selection point) to a specific offset within a specific node
+// If no offset specified, the start of the node is assumed
+FCKSelection.SetCursorPosition = function ( oNode, nOffset )
+{
+ if ( typeof nOffset == "undefined" ) nOffset = 0 ;
+
+ FCK.Selection.SelectNode( oNode ) ; // Doesn't handle offsets currently but offset always zero at mo
+ FCK.Selection.Collapse( true ) ;
+
+ oNode.scrollIntoView( false );
+}
+*/
+// END iCM Modifications
+
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler.js
new file mode 100644
index 00000000..6f4700d2
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler.js
@@ -0,0 +1,364 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktablehandler.js
+ * Manage table operations.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKTableHandler = new Object() ;
+
+FCKTableHandler.InsertRow = function()
+{
+ // Get the row where the selection is placed in.
+ var oRow = FCKSelection.MoveToAncestorNode("TR") ;
+ if ( !oRow ) return ;
+
+ // Create a clone of the row.
+ var oNewRow = oRow.cloneNode( true ) ;
+
+ // Insert the new row (copy) before of it.
+ oRow.parentNode.insertBefore( oNewRow, oRow ) ;
+
+ // Clean the row (it seems that the new row has been added after it).
+ FCKTableHandler.ClearRow( oRow ) ;
+}
+
+FCKTableHandler.DeleteRows = function( row )
+{
+ // If no row has been passed as a parameer,
+ // then get the row where the selection is placed in.
+ if ( !row )
+ row = FCKSelection.MoveToAncestorNode("TR") ;
+ if ( !row ) return ;
+
+ // Get the row's table.
+ var oTable = FCKTools.GetElementAscensor( row, 'TABLE' ) ;
+
+ // If just one row is available then delete the entire table.
+ if ( oTable.rows.length == 1 )
+ {
+ FCKTableHandler.DeleteTable( oTable ) ;
+ return ;
+ }
+
+ // Delete the row.
+ row.parentNode.removeChild( row ) ;
+}
+
+FCKTableHandler.DeleteTable = function( table )
+{
+ // If no table has been passed as a parameer,
+ // then get the table where the selection is placed in.
+ if ( !table )
+ {
+ var table = FCKSelection.GetSelectedElement() ;
+ if ( !table || table.tagName != 'TABLE' )
+ table = FCKSelection.MoveToAncestorNode("TABLE") ;
+ }
+ if ( !table ) return ;
+
+ // Delete the table.
+ FCKSelection.SelectNode( table ) ;
+ FCKSelection.Collapse();
+ table.parentNode.removeChild( table ) ;
+}
+
+FCKTableHandler.InsertColumn = function()
+{
+ // Get the cell where the selection is placed in.
+ var oCell = FCKSelection.MoveToAncestorNode("TD") ;
+ if ( !oCell )
+ oCell = FCKSelection.MoveToAncestorNode("TH") ;
+
+ if ( !oCell ) return ;
+
+ // Get the cell's table.
+ var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;
+
+ // Get the index of the column to be created (based on the cell).
+ var iIndex = oCell.cellIndex + 1 ;
+
+ // Loop throw all rows available in the table.
+ for ( var i = 0 ; i < oTable.rows.length ; i++ )
+ {
+ // Get the row.
+ var oRow = oTable.rows[i] ;
+
+ // If the row doens't have enought cells, ignore it.
+ if ( oRow.cells.length < iIndex )
+ continue ;
+
+ oCell = oRow.cells[iIndex-1].cloneNode(false) ;
+
+ if ( FCKBrowserInfo.IsGecko )
+ oCell.innerHTML = FCKBrowserInfo.IsGecko ? GECKO_BOGUS : '' ;
+
+ // Get the cell that is placed in the new cell place.
+ var oBaseCell = oRow.cells[iIndex] ;
+
+ // If the cell is available (we are not in the last cell of the row).
+ if ( oBaseCell )
+ oRow.insertBefore( oCell, oBaseCell ) ; // Insert the new cell just before of it.
+ else
+ oRow.appendChild( oCell ) ; // Append the cell at the end of the row.
+ }
+}
+
+FCKTableHandler.DeleteColumns = function()
+{
+ // Get the cell where the selection is placed in.
+ var oCell = FCKSelection.MoveToAncestorNode('TD') || FCKSelection.MoveToAncestorNode('TH') ;
+
+ if ( !oCell ) return ;
+
+ // Get the cell's table.
+ var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;
+
+ // Get the cell index.
+ var iIndex = oCell.cellIndex ;
+
+ // Loop throw all rows (from down to up, because it's possible that some
+ // rows will be deleted).
+ for ( var i = oTable.rows.length - 1 ; i >= 0 ; i-- )
+ {
+ // Get the row.
+ var oRow = oTable.rows[i] ;
+
+ // If the cell to be removed is the first one and the row has just one cell.
+ if ( iIndex == 0 && oRow.cells.length == 1 )
+ {
+ // Remove the entire row.
+ FCKTableHandler.DeleteRows( oRow ) ;
+ continue ;
+ }
+
+ // If the cell to be removed exists the delete it.
+ if ( oRow.cells[iIndex] )
+ oRow.removeChild( oRow.cells[iIndex] ) ;
+ }
+}
+
+FCKTableHandler.InsertCell = function( cell )
+{
+ // Get the cell where the selection is placed in.
+ var oCell = cell ? cell : FCKSelection.MoveToAncestorNode("TD") ;
+ if ( !oCell ) return ;
+
+ // Create the new cell element to be added.
+ var oNewCell = FCK.EditorDocument.createElement("TD");
+ if ( FCKBrowserInfo.IsGecko )
+ oNewCell.innerHTML = GECKO_BOGUS ;
+// oNewCell.innerHTML = " " ;
+
+ // If it is the last cell in the row.
+ if ( oCell.cellIndex == oCell.parentNode.cells.length - 1 )
+ {
+ // Add the new cell at the end of the row.
+ oCell.parentNode.appendChild( oNewCell ) ;
+ }
+ else
+ {
+ // Add the new cell before the next cell (after the active one).
+ oCell.parentNode.insertBefore( oNewCell, oCell.nextSibling ) ;
+ }
+
+ return oNewCell ;
+}
+
+FCKTableHandler.DeleteCell = function( cell )
+{
+ // If this is the last cell in the row.
+ if ( cell.parentNode.cells.length == 1 )
+ {
+ // Delete the entire row.
+ FCKTableHandler.DeleteRows( FCKTools.GetElementAscensor( cell, 'TR' ) ) ;
+ return ;
+ }
+
+ // Delete the cell from the row.
+ cell.parentNode.removeChild( cell ) ;
+}
+
+FCKTableHandler.DeleteCells = function()
+{
+ var aCells = FCKTableHandler.GetSelectedCells() ;
+
+ for ( var i = aCells.length - 1 ; i >= 0 ; i-- )
+ {
+ FCKTableHandler.DeleteCell( aCells[i] ) ;
+ }
+}
+
+FCKTableHandler.MergeCells = function()
+{
+ // Get all selected cells.
+ var aCells = FCKTableHandler.GetSelectedCells() ;
+
+ // At least 2 cells must be selected.
+ if ( aCells.length < 2 )
+ return ;
+
+ // The merge can occour only if the selected cells are from the same row.
+ if ( aCells[0].parentNode != aCells[aCells.length-1].parentNode )
+ return ;
+
+ // Calculate the new colSpan for the first cell.
+ var iColSpan = isNaN( aCells[0].colSpan ) ? 1 : aCells[0].colSpan ;
+
+ var sHtml = '' ;
+
+ for ( var i = aCells.length - 1 ; i > 0 ; i-- )
+ {
+ iColSpan += isNaN( aCells[i].colSpan ) ? 1 : aCells[i].colSpan ;
+
+ // Append the HTML of each cell.
+ sHtml = aCells[i].innerHTML + sHtml ;
+
+ // Delete the cell.
+ FCKTableHandler.DeleteCell( aCells[i] ) ;
+ }
+
+ // Set the innerHTML of the remaining cell (the first one).
+ aCells[0].colSpan = iColSpan ;
+ aCells[0].innerHTML += sHtml ;
+}
+
+FCKTableHandler.SplitCell = function()
+{
+ // Check that just one cell is selected, otherwise return.
+ var aCells = FCKTableHandler.GetSelectedCells() ;
+ if ( aCells.length != 1 )
+ return ;
+
+ var aMap = this._CreateTableMap( aCells[0].parentNode.parentNode ) ;
+ var iCellIndex = FCKTableHandler._GetCellIndexSpan( aMap, aCells[0].parentNode.rowIndex , aCells[0] ) ;
+
+ var aCollCells = this._GetCollumnCells( aMap, iCellIndex ) ;
+
+ for ( var i = 0 ; i < aCollCells.length ; i++ )
+ {
+ if ( aCollCells[i] == aCells[0] )
+ {
+ var oNewCell = this.InsertCell( aCells[0] ) ;
+ if ( !isNaN( aCells[0].rowSpan ) && aCells[0].rowSpan > 1 )
+ oNewCell.rowSpan = aCells[0].rowSpan ;
+ }
+ else
+ {
+ if ( isNaN( aCollCells[i].colSpan ) )
+ aCollCells[i].colSpan = 2 ;
+ else
+ aCollCells[i].colSpan += 1 ;
+ }
+ }
+}
+
+// Get the cell index from a TableMap.
+FCKTableHandler._GetCellIndexSpan = function( tableMap, rowIndex, cell )
+{
+ if ( tableMap.length < rowIndex + 1 )
+ return null ;
+
+ var oRow = tableMap[ rowIndex ] ;
+
+ for ( var c = 0 ; c < oRow.length ; c++ )
+ {
+ if ( oRow[c] == cell )
+ return c ;
+ }
+
+ return null ;
+}
+
+// Get the cells available in a collumn of a TableMap.
+FCKTableHandler._GetCollumnCells = function( tableMap, collumnIndex )
+{
+ var aCollCells = new Array() ;
+
+ for ( var r = 0 ; r < tableMap.length ; r++ )
+ {
+ var oCell = tableMap[r][collumnIndex] ;
+ if ( oCell && ( aCollCells.length == 0 || aCollCells[ aCollCells.length - 1 ] != oCell ) )
+ aCollCells[ aCollCells.length ] = oCell ;
+ }
+
+ return aCollCells ;
+}
+
+// This function is quite hard to explain. It creates a matrix representing all cells in a table.
+// The difference here is that the "spanned" cells (colSpan and rowSpan) are duplicated on the matrix
+// cells that are "spanned". For example, a row with 3 cells where the second cell has colSpan=2 and rowSpan=3
+// will produce a bi-dimensional matrix with the following values (representing the cells):
+// Cell1, Cell2, Cell2, Cell 3
+// Cell4, Cell2, Cell2, Cell 5
+FCKTableHandler._CreateTableMap = function( table )
+{
+ var aRows = table.rows ;
+
+ // Row and Collumn counters.
+ var r = -1 ;
+
+ var aMap = new Array() ;
+
+ for ( var i = 0 ; i < aRows.length ; i++ )
+ {
+ r++ ;
+ if ( !aMap[r] )
+ aMap[r] = new Array() ;
+
+ var c = -1 ;
+
+ for ( var j = 0 ; j < aRows[i].cells.length ; j++ )
+ {
+ var oCell = aRows[i].cells[j] ;
+
+ c++ ;
+ while ( aMap[r][c] )
+ c++ ;
+
+ var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ;
+ var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ;
+
+ for ( var rs = 0 ; rs < iRowSpan ; rs++ )
+ {
+ if ( !aMap[r + rs] )
+ aMap[r + rs] = new Array() ;
+
+ for ( var cs = 0 ; cs < iColSpan ; cs++ )
+ {
+ aMap[r + rs][c + cs] = aRows[i].cells[j] ;
+ }
+ }
+
+ c += iColSpan - 1 ;
+ }
+ }
+ return aMap ;
+}
+
+FCKTableHandler.ClearRow = function( tr )
+{
+ // Get the array of row's cells.
+ var aCells = tr.cells ;
+
+ // Replace the contents of each cell with "nothing".
+ for ( var i = 0 ; i < aCells.length ; i++ )
+ {
+ if ( FCKBrowserInfo.IsGecko )
+ aCells[i].innerHTML = GECKO_BOGUS ;
+ else
+ aCells[i].innerHTML = '' ;
+ }
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler_gecko.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler_gecko.js
new file mode 100644
index 00000000..d534d53d
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler_gecko.js
@@ -0,0 +1,48 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktablehandler_gecko.js
+ * Manage table operations (IE specific).
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKTableHandler.GetSelectedCells = function()
+{
+ var aCells = new Array() ;
+
+ var oSelection = FCK.EditorWindow.getSelection() ;
+
+ // If the selection is a text.
+ if ( oSelection.rangeCount == 1 && oSelection.anchorNode.nodeType == 3 )
+ {
+ var oParent = FCKTools.GetElementAscensor( oSelection.anchorNode, 'TD' ) ;
+
+ if ( oParent )
+ {
+ aCells[0] = oParent ;
+ return aCells ;
+ }
+ }
+
+ for ( var i = 0 ; i < oSelection.rangeCount ; i++ )
+ {
+ var oRange = oSelection.getRangeAt(i) ;
+ var oCell = oRange.startContainer.childNodes[ oRange.startOffset ] ;
+
+ if ( oCell.tagName == 'TD' )
+ aCells[aCells.length] = oCell ;
+ }
+
+ return aCells ;
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler_ie.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler_ie.js
new file mode 100644
index 00000000..cb0592d7
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktablehandler_ie.js
@@ -0,0 +1,54 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktablehandler_ie.js
+ * Manage table operations (IE specific).
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+FCKTableHandler.GetSelectedCells = function()
+{
+ var aCells = new Array() ;
+
+ var oRange = FCK.EditorDocument.selection.createRange() ;
+// var oParent = oRange.parentElement() ;
+ var oParent = FCKSelection.GetParentElement() ;
+
+ if ( oParent && oParent.tagName == "TD" )
+ aCells[0] = oParent ;
+ else
+ {
+ var oParent = FCKSelection.MoveToAncestorNode( "TABLE" ) ;
+
+ if ( oParent )
+ {
+ // Loops throw all cells checking if the cell is, or part of it, is inside the selection
+ // and then add it to the selected cells collection.
+ for ( var i = 0 ; i < oParent.cells.length ; i++ )
+ {
+ var oCellRange = FCK.EditorDocument.selection.createRange() ;
+ oCellRange.moveToElementText( oParent.cells[i] ) ;
+
+ if ( oRange.inRange( oCellRange )
+ || ( oRange.compareEndPoints('StartToStart',oCellRange) >= 0 && oRange.compareEndPoints('StartToEnd',oCellRange) <= 0 )
+ || ( oRange.compareEndPoints('EndToStart',oCellRange) >= 0 && oRange.compareEndPoints('EndToEnd',oCellRange) <= 0 ) )
+ {
+ aCells[aCells.length] = oParent.cells[i] ;
+ }
+ }
+ }
+ }
+
+ return aCells ;
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktoolbaritems.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktoolbaritems.js
new file mode 100644
index 00000000..90d3833e
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktoolbaritems.js
@@ -0,0 +1,117 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktoolbaritems.js
+ * Toolbar items definitions.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarItems = new Object() ;
+FCKToolbarItems.LoadedItems = new Object() ;
+
+FCKToolbarItems.RegisterItem = function( itemName, item )
+{
+ this.LoadedItems[ itemName ] = item ;
+}
+
+FCKToolbarItems.GetItem = function( itemName )
+{
+ var oItem = FCKToolbarItems.LoadedItems[ itemName ] ;
+
+ if ( oItem )
+ return oItem ;
+
+ switch ( itemName )
+ {
+ case 'Source' : oItem = new FCKToolbarButton( 'Source' , FCKLang.Source, null, FCK_TOOLBARITEM_ICONTEXT, true, true ) ; break ;
+ case 'DocProps' : oItem = new FCKToolbarButton( 'DocProps' , FCKLang.DocProps ) ; break ;
+ case 'Templates' : oItem = new FCKToolbarButton( 'Templates' , FCKLang.Templates ) ; break ;
+ case 'Save' : oItem = new FCKToolbarButton( 'Save' , FCKLang.Save, null, null, true ) ; break ;
+ case 'NewPage' : oItem = new FCKToolbarButton( 'NewPage' , FCKLang.NewPage, null, null, true ) ; break ;
+ case 'Preview' : oItem = new FCKToolbarButton( 'Preview' , FCKLang.Preview, null, null, true ) ; break ;
+ case 'About' : oItem = new FCKToolbarButton( 'About' , FCKLang.About, null, null, true ) ; break ;
+
+ case 'Cut' : oItem = new FCKToolbarButton( 'Cut' , FCKLang.Cut, null, null, false, true ) ; break ;
+ case 'Copy' : oItem = new FCKToolbarButton( 'Copy' , FCKLang.Copy, null, null, false, true ) ; break ;
+ case 'Paste' : oItem = new FCKToolbarButton( 'Paste' , FCKLang.Paste, null, null, false, true ) ; break ;
+ case 'PasteText' : oItem = new FCKToolbarButton( 'PasteText' , FCKLang.PasteText, null, null, false, true ) ; break ;
+ case 'PasteWord' : oItem = new FCKToolbarButton( 'PasteWord' , FCKLang.PasteWord, null, null, false, true ) ; break ;
+ case 'Print' : oItem = new FCKToolbarButton( 'Print' , FCKLang.Print, null, null, false, true ) ; break ;
+ case 'SpellCheck' : oItem = new FCKToolbarButton( 'SpellCheck', FCKLang.SpellCheck ) ; break ;
+ case 'Undo' : oItem = new FCKToolbarButton( 'Undo' , FCKLang.Undo, null, null, false, true ) ; break ;
+ case 'Redo' : oItem = new FCKToolbarButton( 'Redo' , FCKLang.Redo, null, null, false, true ) ; break ;
+ case 'SelectAll' : oItem = new FCKToolbarButton( 'SelectAll' , FCKLang.SelectAll ) ; break ;
+ case 'RemoveFormat' : oItem = new FCKToolbarButton( 'RemoveFormat', FCKLang.RemoveFormat, null, null, false, true ) ; break ;
+
+ case 'Bold' : oItem = new FCKToolbarButton( 'Bold' , FCKLang.Bold, null, null, false, true ) ; break ;
+ case 'Italic' : oItem = new FCKToolbarButton( 'Italic' , FCKLang.Italic, null, null, false, true ) ; break ;
+ case 'Underline' : oItem = new FCKToolbarButton( 'Underline' , FCKLang.Underline, null, null, false, true ) ; break ;
+ case 'StrikeThrough' : oItem = new FCKToolbarButton( 'StrikeThrough' , FCKLang.StrikeThrough, null, null, false, true ) ; break ;
+ case 'Subscript' : oItem = new FCKToolbarButton( 'Subscript' , FCKLang.Subscript, null, null, false, true ) ; break ;
+ case 'Superscript' : oItem = new FCKToolbarButton( 'Superscript' , FCKLang.Superscript, null, null, false, true ) ; break ;
+
+ case 'OrderedList' : oItem = new FCKToolbarButton( 'InsertOrderedList' , FCKLang.NumberedListLbl, FCKLang.NumberedList, null, false, true ) ; break ;
+ case 'UnorderedList' : oItem = new FCKToolbarButton( 'InsertUnorderedList' , FCKLang.BulletedListLbl, FCKLang.BulletedList, null, false, true ) ; break ;
+ case 'Outdent' : oItem = new FCKToolbarButton( 'Outdent' , FCKLang.DecreaseIndent, null, null, false, true ) ; break ;
+ case 'Indent' : oItem = new FCKToolbarButton( 'Indent' , FCKLang.IncreaseIndent, null, null, false, true ) ; break ;
+
+ case 'Link' : oItem = new FCKToolbarButton( 'Link' , FCKLang.InsertLinkLbl, FCKLang.InsertLink, null, false, true ) ; break ;
+ case 'Unlink' : oItem = new FCKToolbarButton( 'Unlink' , FCKLang.RemoveLink, null, null, false, true ) ; break ;
+ case 'Anchor' : oItem = new FCKToolbarButton( 'Anchor' , FCKLang.Anchor ) ; break ;
+
+ case 'Image' : oItem = new FCKToolbarButton( 'Image' , FCKLang.InsertImageLbl, FCKLang.InsertImage ) ; break ;
+ case 'Flash' : oItem = new FCKToolbarButton( 'Flash' , FCKLang.InsertFlashLbl, FCKLang.InsertFlash ) ; break ;
+ case 'Table' : oItem = new FCKToolbarButton( 'Table' , FCKLang.InsertTableLbl, FCKLang.InsertTable ) ; break ;
+ case 'SpecialChar' : oItem = new FCKToolbarButton( 'SpecialChar' , FCKLang.InsertSpecialCharLbl, FCKLang.InsertSpecialChar ) ; break ;
+ case 'Smiley' : oItem = new FCKToolbarButton( 'Smiley' , FCKLang.InsertSmileyLbl, FCKLang.InsertSmiley ) ; break ;
+ case 'PageBreak' : oItem = new FCKToolbarButton( 'PageBreak' , FCKLang.PageBreakLbl, FCKLang.PageBreak ) ; break ;
+ case 'UniversalKey' : oItem = new FCKToolbarButton( 'UniversalKey' , FCKLang.UniversalKeyboard ) ; break ;
+
+ case 'Rule' : oItem = new FCKToolbarButton( 'InsertHorizontalRule', FCKLang.InsertLineLbl, FCKLang.InsertLine, null, false, true ) ; break ;
+
+ case 'JustifyLeft' : oItem = new FCKToolbarButton( 'JustifyLeft' , FCKLang.LeftJustify, null, null, false, true ) ; break ;
+ case 'JustifyCenter' : oItem = new FCKToolbarButton( 'JustifyCenter' , FCKLang.CenterJustify, null, null, false, true ) ; break ;
+ case 'JustifyRight' : oItem = new FCKToolbarButton( 'JustifyRight' , FCKLang.RightJustify, null, null, false, true ) ; break ;
+ case 'JustifyFull' : oItem = new FCKToolbarButton( 'JustifyFull' , FCKLang.BlockJustify, null, null, false, true ) ; break ;
+
+ case 'Style' : oItem = new FCKToolbarStyleCombo() ; break ;
+ case 'FontName' : oItem = new FCKToolbarFontsCombo() ; break ;
+ case 'FontSize' : oItem = new FCKToolbarFontSizeCombo() ; break ;
+ case 'FontFormat' : oItem = new FCKToolbarFontFormatCombo() ; break ;
+
+ case 'TextColor' : oItem = new FCKToolbarPanelButton( 'TextColor', FCKLang.TextColor ) ; break ;
+ case 'BGColor' : oItem = new FCKToolbarPanelButton( 'BGColor' , FCKLang.BGColor ) ; break ;
+
+ case 'Find' : oItem = new FCKToolbarButton( 'Find' , FCKLang.Find ) ; break ;
+ case 'Replace' : oItem = new FCKToolbarButton( 'Replace' , FCKLang.Replace ) ; break ;
+
+ case 'Form' : oItem = new FCKToolbarButton( 'Form' , FCKLang.Form ) ; break ;
+ case 'Checkbox' : oItem = new FCKToolbarButton( 'Checkbox' , FCKLang.Checkbox ) ; break ;
+ case 'Radio' : oItem = new FCKToolbarButton( 'Radio' , FCKLang.RadioButton ) ; break ;
+ case 'TextField' : oItem = new FCKToolbarButton( 'TextField' , FCKLang.TextField ) ; break ;
+ case 'Textarea' : oItem = new FCKToolbarButton( 'Textarea' , FCKLang.Textarea ) ; break ;
+ case 'HiddenField' : oItem = new FCKToolbarButton( 'HiddenField' , FCKLang.HiddenField ) ; break ;
+ case 'Button' : oItem = new FCKToolbarButton( 'Button' , FCKLang.Button ) ; break ;
+ case 'Select' : oItem = new FCKToolbarButton( 'Select' , FCKLang.SelectionField ) ; break ;
+ case 'ImageButton' : oItem = new FCKToolbarButton( 'ImageButton' , FCKLang.ImageButton ) ; break ;
+
+ default:
+ alert( FCKLang.UnknownToolbarItem.replace( /%1/g, itemName ) ) ;
+ return null ;
+ }
+
+ FCKToolbarItems.LoadedItems[ itemName ] = oItem ;
+
+ return oItem ;
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktoolbarset.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktoolbarset.js
new file mode 100644
index 00000000..7e168cfc
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktoolbarset.js
@@ -0,0 +1,166 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktoolbarset.js
+ * Defines the FCKToolbarSet object that is used to load and draw the
+ * toolbar.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarSet = FCK.ToolbarSet = new Object() ;
+
+document.getElementById( 'ExpandHandle' ).title = FCKLang.ToolbarExpand ;
+document.getElementById( 'CollapseHandle' ).title = FCKLang.ToolbarCollapse ;
+
+FCKToolbarSet.Toolbars = new Array() ;
+
+// Array of toolbat items that are active only on WYSIWYG mode.
+FCKToolbarSet.ItemsWysiwygOnly = new Array() ;
+
+// Array of toolbar items that are sensitive to the cursor position.
+FCKToolbarSet.ItemsContextSensitive = new Array() ;
+
+FCKToolbarSet.Expand = function()
+{
+ document.getElementById( 'Collapsed' ).style.display = 'none' ;
+ document.getElementById( 'Expanded' ).style.display = '' ;
+
+ if ( ! FCKBrowserInfo.IsIE )
+ {
+ // I had to use "setTimeout" because Gecko was not responding in a right
+ // way when calling window.onresize() directly.
+ window.setTimeout( "window.onresize()", 1 ) ;
+ }
+}
+
+FCKToolbarSet.Collapse = function()
+{
+ document.getElementById( 'Collapsed' ).style.display = '' ;
+ document.getElementById( 'Expanded' ).style.display = 'none' ;
+
+ if ( ! FCKBrowserInfo.IsIE )
+ {
+ // I had to use "setTimeout" because Gecko was not responding in a right
+ // way when calling window.onresize() directly.
+ window.setTimeout( "window.onresize()", 1 ) ;
+ }
+}
+
+FCKToolbarSet.Restart = function()
+{
+ if ( !FCKConfig.ToolbarCanCollapse || FCKConfig.ToolbarStartExpanded )
+ this.Expand() ;
+ else
+ this.Collapse() ;
+
+ document.getElementById( 'CollapseHandle' ).style.display = FCKConfig.ToolbarCanCollapse ? '' : 'none' ;
+}
+
+FCKToolbarSet.Load = function( toolbarSetName )
+{
+ this.DOMElement = document.getElementById( 'eToolbar' ) ;
+
+ 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 ) ;
+
+ if ( !oItem.SourceView )
+ this.ItemsWysiwygOnly[this.ItemsWysiwygOnly.length] = oItem ;
+
+ if ( oItem.ContextSensitive )
+ this.ItemsContextSensitive[this.ItemsContextSensitive.length] = oItem ;
+ }
+ }
+ }
+
+ oToolbar.AddTerminator() ;
+ }
+
+ this.Toolbars[ this.Toolbars.length ] = oToolbar ;
+ }
+}
+
+FCKToolbarSet.RefreshModeState = function()
+{
+ if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG )
+ {
+ // Enable all buttons that are available on WYSIWYG mode only.
+ for ( var i = 0 ; i < FCKToolbarSet.ItemsWysiwygOnly.length ; i++ )
+ FCKToolbarSet.ItemsWysiwygOnly[i].Enable() ;
+
+ // Refresh the buttons state.
+ FCKToolbarSet.RefreshItemsState() ;
+ }
+ else
+ {
+ // Refresh the buttons state.
+ FCKToolbarSet.RefreshItemsState() ;
+
+ // Disable all buttons that are available on WYSIWYG mode only.
+ for ( var i = 0 ; i < FCKToolbarSet.ItemsWysiwygOnly.length ; i++ )
+ FCKToolbarSet.ItemsWysiwygOnly[i].Disable() ;
+ }
+}
+
+FCKToolbarSet.RefreshItemsState = function()
+{
+
+ for ( var i = 0 ; i < FCKToolbarSet.ItemsContextSensitive.length ; i++ )
+ FCKToolbarSet.ItemsContextSensitive[i].RefreshState() ;
+/*
+ TODO: Delete this commented block on stable version.
+ for ( var i = 0 ; i < FCKToolbarSet.Toolbars.length ; i++ )
+ {
+ var oToolbar = FCKToolbarSet.Toolbars[i] ;
+ for ( var j = 0 ; j < oToolbar.Items.length ; j++ )
+ {
+ oToolbar.Items[j].RefreshState() ;
+ }
+ }
+*/
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools.js
new file mode 100644
index 00000000..4cbc92b6
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools.js
@@ -0,0 +1,328 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktools.js
+ * Utility functions.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKTools = new Object() ;
+
+//**
+// FCKTools.GetLinkedFieldValue: Gets the value of the hidden INPUT element
+// that is associated to the editor. This element has its ID set to the
+// editor's instance name so the user reffers to the instance name when getting
+// the posted data.
+FCKTools.GetLinkedFieldValue = function()
+{
+ return FCK.LinkedField.value ;
+}
+
+//**
+// FCKTools.AttachToLinkedFieldFormSubmit: attaches a function call to the
+// submit event of the linked field form. This function us generally used to
+// update the linked field value before submitting the form.
+FCKTools.AttachToLinkedFieldFormSubmit = function( functionPointer )
+{
+ // Gets the linked field form
+ var oForm = FCK.LinkedField.form ;
+
+ // Return now if no form is available
+ if (!oForm) return ;
+
+ // Attaches the functionPointer call to the onsubmit event
+ if ( FCKBrowserInfo.IsIE )
+ oForm.attachEvent( "onsubmit", functionPointer ) ;
+ else
+ oForm.addEventListener( 'submit', functionPointer, true ) ;
+
+ //**
+ // Attaches the functionPointer call to the submit method
+ // This is done because IE doesn't fire onsubmit when the submit method is called
+ // BEGIN --
+
+ // Creates a Array in the form object that will hold all Attached function call
+ // (in the case there are more than one editor in the same page)
+ if (! oForm.updateFCKeditor) oForm.updateFCKeditor = new Array() ;
+
+ // Adds the function pointer to the array of functions to call when "submit" is called
+ oForm.updateFCKeditor[oForm.updateFCKeditor.length] = functionPointer ;
+
+ // Switches the original submit method with a new one that first call all functions
+ // on the above array and the call the original submit
+ // IE sees it oForm.submit function as an 'object'.
+ if (! oForm.originalSubmit && ( typeof( oForm.submit ) == 'function' || ( !oForm.submit.tagName && !oForm.submit.length ) ) )
+ {
+ // Creates a copy of the original submit
+ oForm.originalSubmit = oForm.submit ;
+
+ // Creates our replacement for the submit
+ oForm.submit = FCKTools_SubmitReplacer ;
+ }
+ // END --
+}
+
+function FCKTools_SubmitReplacer()
+{
+ if (this.updateFCKeditor)
+ {
+ // Calls all functions in the functions array
+ for (var i = 0 ; i < this.updateFCKeditor.length ; i++)
+ this.updateFCKeditor[i]() ;
+ }
+ // Calls the original "submit"
+ this.originalSubmit() ;
+}
+
+//**
+// FCKTools.AddSelectOption: Adds a option to a SELECT element.
+FCKTools.AddSelectOption = function( targetDocument, selectElement, optionText, optionValue )
+{
+ var oOption = targetDocument.createElement("OPTION") ;
+
+ oOption.text = optionText ;
+ oOption.value = optionValue ;
+
+ selectElement.options.add(oOption) ;
+
+ return oOption ;
+}
+/*
+FCKTools.RemoveAllSelectOptions = function( selectElement )
+{
+ for ( var i = selectElement.options.length - 1 ; i >= 0 ; i-- )
+ {
+ selectElement.options.remove(i) ;
+ }
+}
+
+FCKTools.SelectNoCase = function( selectElement, value, defaultValue )
+{
+ var sNoCaseValue = value.toString().toLowerCase() ;
+
+ for ( var i = 0 ; i < selectElement.options.length ; i++ )
+ {
+ if ( sNoCaseValue == selectElement.options[i].value.toLowerCase() )
+ {
+ selectElement.selectedIndex = i ;
+ return ;
+ }
+ }
+
+ if ( defaultValue != null ) FCKTools.SelectNoCase( selectElement, defaultValue ) ;
+}
+*/
+FCKTools.HTMLEncode = function( text )
+{
+ if ( !text )
+ return '' ;
+
+ text = text.replace( /&/g, "&" ) ;
+ text = text.replace( /"/g, """ ) ;
+ text = text.replace( //g, ">" ) ;
+ text = text.replace( /'/g, "'" ) ;
+
+ return text ;
+}
+/*
+//**
+// FCKTools.GetResultingArray: Gets a array from a string (where the elements
+// are separated by a character), a fuction (that returns a array) or a array.
+FCKTools.GetResultingArray = function( arraySource, separator )
+{
+ switch ( typeof( arraySource ) )
+ {
+ case "string" :
+ return arraySource.split( separator ) ;
+ case "function" :
+ return separator() ;
+ default :
+ if ( isArray( arraySource ) ) return arraySource ;
+ else return new Array() ;
+ }
+}
+*/
+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 ;
+
+ // Loop throw the offset chain.
+ while ( el )
+ {
+ c.X += el.offsetLeft ;
+ c.Y += el.offsetTop ;
+
+ if ( el.offsetParent == null )
+ {
+ var oOwnerWindow = FCKTools.GetElementWindow( el ) ;
+
+ if ( oOwnerWindow != oWindow )
+ el = oOwnerWindow.frameElement ;
+ else
+ break ;
+ }
+ else
+ el = el.offsetParent ;
+ }
+
+ // Return the Coordinates object
+ return c ;
+}
+
+// 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.Pause = function( miliseconds )
+{
+ var oStart = new Date() ;
+
+ while (true)
+ {
+ var oNow = new Date() ;
+ if ( miliseconds < oNow - oStart )
+ return ;
+ }
+}
+
+FCKTools.ConvertStyleSizeToHtml = function( size )
+{
+ return size.endsWith( '%' ) ? size : parseInt( size ) ;
+}
+
+FCKTools.ConvertHtmlSizeToStyle = function( size )
+{
+ return size.endsWith( '%' ) ? size : ( size + 'px' ) ;
+}
+
+// Get the window object where the element is placed in.
+FCKTools.GetElementWindow = function( element )
+{
+ var oDocument = element.ownerDocument || element.document ;
+
+ // With Safari, there is not way to retrieve the window from the document, so we must fix it.
+ if ( FCKBrowserInfo.IsSafari && !oDocument.parentWindow )
+ FCKTools._FixDocumentParentWindow( window.top ) ;
+
+ return oDocument.parentWindow || oDocument.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.CancelEvent = function( e )
+{
+ return false ;
+}
+
+// START iCM MODIFICATIONS
+/*
+// Transfers the supplied attributes to the supplied node
+FCKTools.SetElementAttributes = function( oElement, oAttributes )
+{
+ for ( var i = 0; i < oAttributes.length; i++ )
+ {
+ if ( oAttributes[i].specified ) // Needed for IE which always returns all attributes whether set or not
+ oElement.setAttribute( oAttributes[i].nodeName, oAttributes[i].nodeValue, 0 ) ;
+ }
+}
+
+// Get immediate block node (P, H1, for example) for the supplied node - the supplied node may itself be a block node in which
+// case it will be returned. If no block node found, returns null.
+FCKTools.GetParentBlockNode = function( oNode )
+{
+ if ( oNode.nodeName.toUpperCase() == "BODY" )
+ return null ;
+ else if ( oNode.nodeType == 1 && FCKRegexLib.BlockElements.test(oNode.tagName) )
+ return oNode ;
+ else
+ return FCKTools.GetParentBlockNode( oNode.parentNode ) ;
+}
+
+// Run through any children of the supplied node. If there are none, or they only comprise
+// empty text nodes and BR nodes, then the node is effectively empty.
+// Sometimes (on Gecko) a seemingly empty node is coming back with several children that are solely
+// empty text nodes and BRs e.g. the first item in an OL list, for example, when
+// UseBROnCarriageReturn is set to false.
+// Seems to be due to the use of the (GECKO_BOGUS) as fillers both
+// in fck_gecko_1.js when html is empty and in ENTER key handler ? If normal BR tags are
+// used instead this doesn't seem to happen....
+FCKTools.NodeIsEmpty = function( oNode )
+{
+ var oSibling = oNode.childNodes[0] ;
+ while ( oSibling )
+ {
+ if ( ( oSibling.nodeType != 1 && oSibling.nodeType != 3 ) || ( oSibling.nodeType == 1 && oSibling.nodeName.toUpperCase() != "BR" ) || ( oSibling.nodeType == 3 && oSibling.nodeValue && oSibling.nodeValue.trim() != '' ) )
+ return false ;
+
+ oSibling = oSibling.nextSibling ;
+ }
+
+ return true ;
+}
+
+// Returns a document fragment that contains a copy of the specified range of nodes
+FCKTools.GetDocumentFragment = function( oParentNode, oFromNode, oToNode, bIncludeFromNode, bIncludeToNode, bClone )
+{
+ if ( typeof bIncludeFromNode == "undefined" ) bIncludeFromNode = true ;
+ if ( typeof bIncludeToNode == "undefined" ) bIncludeToNode = true ;
+ if ( typeof bClone == "undefined" ) bClone = true ;
+
+ var oFragment = FCK.EditorDocument.createDocumentFragment() ;
+
+ var oNode = oFromNode ;
+ while ( oNode && oNode != oToNode )
+ {
+ if ( oNode != oFromNode || bIncludeFromNode )
+ oFragment.appendChild( bClone ? oNode.cloneNode( true ) : oNode ) ;
+
+ oNode = oNode.nextSibling ;
+ }
+
+ if ( oNode && (oFromNode != oToNode && bIncludeToNode) )
+ oFragment.appendChild( bClone ? oNode.cloneNode( true ) : oNode ) ; // Include To Node
+
+ return oFragment ;
+}
+*/
+// END iCM MODIFICATIONS
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools_gecko.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools_gecko.js
new file mode 100644
index 00000000..68b0bb61
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools_gecko.js
@@ -0,0 +1,261 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktools_gecko.js
+ * Utility functions. (Gecko version).
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Constant for the Gecko Bogus Node.
+var GECKO_BOGUS = ' ' ;
+
+// Appends a CSS file to a document.
+FCKTools.AppendStyleSheet = function( documentElement, cssFileUrl )
+{
+ var e = documentElement.createElement( 'LINK' ) ;
+ e.rel = 'stylesheet' ;
+ e.type = 'text/css' ;
+ e.href = cssFileUrl ;
+ documentElement.getElementsByTagName("HEAD")[0].appendChild( e ) ;
+ return e ;
+}
+
+// Removes all attributes and values from the element.
+FCKTools.ClearElementAttributes = function( element )
+{
+ // Loop throw all attributes in the element
+ for ( var i = 0 ; i < element.attributes.length ; i++ )
+ {
+ // Remove the element by name.
+ element.removeAttribute( element.attributes[i].name, 0 ) ; // 0 : Case Insensitive
+ }
+}
+
+// Returns an Array of strings with all defined in the elements inside another element.
+FCKTools.GetAllChildrenIds = function( parentElement )
+{
+ // Create the array that will hold all Ids.
+ var aIds = new Array() ;
+
+ // Define a recursive function that search for the Ids.
+ var fGetIds = function( parent )
+ {
+ for ( var i = 0 ; i < parent.childNodes.length ; i++ )
+ {
+ var sId = parent.childNodes[i].id ;
+
+ // Check if the Id is defined for the element.
+ if ( sId && sId.length > 0 ) aIds[ aIds.length ] = sId ;
+
+ // Recursive call.
+ fGetIds( parent.childNodes[i] ) ;
+ }
+ }
+
+ // Start the recursive calls.
+ fGetIds( parentElement ) ;
+
+ return aIds ;
+}
+
+FCKTools.RemoveOuterTags = function( e )
+{
+ var oFragment = e.ownerDocument.createDocumentFragment() ;
+
+ for ( var i = 0 ; i < e.childNodes.length ; i++ )
+ oFragment.appendChild( e.childNodes[i] ) ;
+
+ e.parentNode.replaceChild( oFragment, e ) ;
+}
+
+FCKTools.CreateXmlObject = function( object )
+{
+ switch ( object )
+ {
+ case 'XmlHttp' :
+ return new XMLHttpRequest() ;
+ case 'DOMDocument' :
+ return document.implementation.createDocument( '', '', null ) ;
+ }
+ return null ;
+}
+
+FCKTools.DisableSelection = function( element )
+{
+ element.style.MozUserSelect = 'none' ; // Gecko only.
+ // element.style.userSelect = 'none' ; // CSS3 (not supported yet).
+}
+
+// START iCM Modifications
+/*
+// Starting at the specified node, find the first inline node of the sequence
+// For example, assume we have the following elements :
Some text some more text and some link yet some more text
+// If the "some link" text node is the one specified, then the "Some text" text node will be the first inline node returned.
+FCKTools.GetFirstInlineNode = function( oNode )
+{
+ if ( FCKRegexLib.BlockElements.test( oNode.nodeName ) )
+ return oNode ;
+ else if ( oNode.previousSibling && !FCKRegexLib.BlockElements.test( oNode.previousSibling.nodeName ) )
+ return FCKTools.GetFirstInlineNode( oNode.previousSibling ) ;
+ else if ( oNode.parentNode && !FCKRegexLib.BlockElements.test( oNode.parentNode.nodeName ) && oNode.parentNode.nodeName.toUpperCase() != "BODY" )
+ return FCKTools.GetFirstInlineNode( oNode.parentNode ) ;
+ else
+ return oNode ;
+}
+
+// Starting at the specified node, find the last inline node of the sequence
+// For example, assume we have the following elements :
Some text some more text and some link yet some more text
+// If the "some link" text node is the one specified, then the " yet some more text" text node will be the last inline node returned.
+FCKTools.GetLastInlineNode = function( oNode )
+{
+ if ( FCKRegexLib.BlockElements.test( oNode.nodeName ) )
+ return oNode ;
+ else if ( oNode.nextSibling && !FCKRegexLib.BlockElements.test( oNode.nextSibling.nodeName ) )
+ return FCKTools.GetLastInlineNode( oNode.nextSibling ) ;
+ else if ( oNode.parentNode && !FCKRegexLib.BlockElements.test( oNode.parentNode.nodeName ) && oNode.parentNode.nodeName.toUpperCase() != "BODY" )
+ return FCKTools.GetLastInlineNode( oNode.parentNode ) ;
+ else
+ return oNode ;
+}
+
+
+// Split the supplied parent at the specified child and (optionally) offset.
+// Ensure that enclosing block elements are created where missing but that existing
+// block elements (table for example) don't get incorrectly nested.
+FCKTools.SplitNode = function( oParentBlockNode, oChildNode, nOffset )
+{
+ if ( typeof nOffset == "undefined" ) nOffset = 0 ;
+
+ var oFragment = FCK.EditorDocument.createDocumentFragment() ;
+ var oRange = FCK.EditorDocument.createRange() ;
+
+ if ( FCKRegexLib.ListElements.test( oParentBlockNode.nodeName ) )
+ {
+ // Treat OL/UL parents differently as want to split at the specified
+ // child LI node to create to OL/UL lists.
+ oStartNode = oParentBlockNode.firstChild ;
+ oEndNode = oParentBlockNode.lastChild ;
+ }
+ else
+ {
+ // Locate the inline nodes adjacent to the specified child node so that these can
+ // be kept together.
+ oStartNode = FCKTools.GetFirstInlineNode( oChildNode ) ;
+ oEndNode = FCKTools.GetLastInlineNode( oChildNode ) ;
+ }
+
+ // Create a new tag which holds the content of the affected node(s) located before (but not including) the child node and offset
+ if ( FCKRegexLib.BlockElements.test( oStartNode.nodeName ) && !FCKRegexLib.ListElements.test( oParentBlockNode.nodeName ) )
+ {
+ // First element of the bunch is already a block element so we don't want to wrap it with a new block element.
+ // Just use this first node provided it is not the same as the last node (to prevent duplication), otherwise
+ // create a new empty P element.
+ if ( oStartNode != oEndNode )
+ {
+ oBlockNode1 = oStartNode.cloneNode( true ) ;
+ }
+ else
+ {
+ oBlockNode1 = FCK.EditorDocument.createElement( "P" ) ;
+ oBlockNode1.innerHTML = GECKO_BOGUS ;
+
+ if ( !FCKRegexLib.SpecialBlockElements.test( oParentBlockNode.nodeName ) )
+ FCKTools.SetElementAttributes( oBlockNode1, oParentBlockNode.attributes ) ; // Transfer across any class attributes, etc
+ }
+ }
+ else
+ {
+ // First element of the bunch is not a block element (or it is a LI element which is a special case).
+ // So ensure all of the inline nodes before the selection are wrapped with a suitable block element.
+ var oBlockNode1 = FCK.EditorDocument.createElement( FCKRegexLib.SpecialBlockElements.test( oParentBlockNode.nodeName ) ? "P" : oParentBlockNode.tagName ) ;
+ oRange.setStartBefore( oStartNode ) ;
+ if ( nOffset == 0 )
+ oRange.setEndBefore( oChildNode ) ;
+ else
+ oRange.setEnd( oChildNode, nOffset ) ;
+ oBlockNode1.appendChild( oRange.cloneContents() ) ;
+ oBlockNode1.innerHTML = oBlockNode1.innerHTML.replace(/[\x00-\x1F]/g, "") ; // Prevent any control characters returned within the innerHTML from causing problems
+ if ( FCKTools.NodeIsEmpty( oBlockNode1 ) )
+ oBlockNode1.innerHTML = GECKO_BOGUS ; // Ensure it has some content, required for Gecko
+ else
+ oBlockNode1.innerHTML = oBlockNode1.innerHTML.replace( FCKRegexLib.EmptyElement, "" ) ; // Strip out any empty tags that may have been generated by the split
+ if ( !FCKRegexLib.SpecialBlockElements.test( oParentBlockNode.nodeName ) )
+ FCKTools.SetElementAttributes( oBlockNode1, oParentBlockNode.attributes ) ; // Transfer across any class attributes, etc
+ }
+
+ // Create a new tag which holds the content of the affected node(s) located after (and including) the child node
+ if ( FCKRegexLib.BlockElements.test( oEndNode.nodeName ) && !FCKRegexLib.ListElements.test( oParentBlockNode.nodeName ) )
+ {
+ // Last element of the bunch is already a block element so we don't want to wrap it with a new block element.
+ oBlockNode2 = oEndNode.cloneNode( true ) ;
+ }
+ else
+ {
+ // Last element of the bunch is not a block element (or it is a LI element which is a special case).
+ // So ensure all of the inline nodes after and including the child/offset are wrapped with a suitable block element.
+ var oBlockNode2 = FCK.EditorDocument.createElement( FCKRegexLib.SpecialBlockElements.test( oParentBlockNode.nodeName ) ? "P" : oParentBlockNode.tagName );
+ oRange.setEndAfter( oEndNode );
+ if ( nOffset == 0 )
+ oRange.setStartBefore( oChildNode ) ;
+ else
+ oRange.setStart( oChildNode, nOffset );
+ oBlockNode2.appendChild( oRange.cloneContents() ) ;
+ oBlockNode2.innerHTML = oBlockNode2.innerHTML.replace(/[\x00-\x1F]/g, "") ; // Prevent any control characters returned within the innerHTML from causing problems
+ if ( FCKTools.NodeIsEmpty( oBlockNode2 ) )
+ oBlockNode2.innerHTML = GECKO_BOGUS ; // Ensure it has some content, required for Gecko
+ else
+ oBlockNode2.innerHTML = oBlockNode2.innerHTML.replace( FCKRegexLib.EmptyElement, "" ) ; // Strip out any empty tags that may have been generated by the split
+ if ( !FCKRegexLib.SpecialBlockElements.test( oParentBlockNode.nodeName ) )
+ FCKTools.SetElementAttributes( oBlockNode2, oParentBlockNode.attributes ) ; // Transfer across any class attributes, etc
+ }
+
+ // Insert the resulting nodes into a document fragment
+ oFragment.appendChild( oBlockNode1 );
+ oFragment.appendChild( oBlockNode2 );
+
+ // Replace the affected nodes with the new nodes (fragment)
+ FCKTools.ReplaceNodes( oParentBlockNode, oStartNode, oEndNode, oFragment ) ;
+
+ // Return the second node so it can be used for setting cursor position, etc
+ return oBlockNode2 ;
+}
+
+// Function that replaces the specified range of nodes (inclusive) within the supplied parent
+// with the nodes stored in the supplied document fragment.
+FCKTools.ReplaceNodes = function( oParentBlockNode, oStartNode, oEndNode, oFragment )
+{
+ var oRange = FCK.EditorDocument.createRange() ;
+
+ // Delete the affected node(s)
+ if ( !FCKRegexLib.SpecialBlockElements.test( oParentBlockNode.nodeName ) && (oParentBlockNode.firstChild == oStartNode) && (oParentBlockNode.lastChild == oEndNode) )
+ {
+ // Entire parent block node is to be replaced so insert the two new block elements before it
+ // and then remove the old node
+ oRange.selectNode ( oParentBlockNode );
+ }
+ else
+ {
+ // Only part of the parent block node is to be replaced so insert the two new block elements
+ // before the first inline node of the affected content and then remove the old nodes
+ oRange.setEndAfter( oEndNode ) ;
+ oRange.setStartBefore( oStartNode ) ;
+ }
+
+ // Insert the replacement nodes
+ oRange.deleteContents() ;
+ oRange.insertNode( oFragment ) ;
+}
+*/
+// END iCM Modifications
+
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools_ie.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools_ie.js
new file mode 100644
index 00000000..401bda9b
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fcktools_ie.js
@@ -0,0 +1,98 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktools_ie.js
+ * Utility functions. (IE version).
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// Appends a CSS file to a document.
+FCKTools.AppendStyleSheet = function( documentElement, cssFileUrl )
+{
+ return documentElement.createStyleSheet( cssFileUrl ) ;
+}
+
+// Removes all attributes and values from the element.
+FCKTools.ClearElementAttributes = function( element )
+{
+ element.clearAttributes() ;
+}
+
+FCKTools.GetAllChildrenIds = function( parentElement )
+{
+ var aIds = new Array() ;
+ for ( var i = 0 ; i < parentElement.all.length ; i++ )
+ {
+ var sId = parentElement.all[i].id ;
+ if ( sId && sId.length > 0 )
+ aIds[ aIds.length ] = sId ;
+ }
+ return aIds ;
+}
+
+FCKTools.RemoveOuterTags = function( e )
+{
+ e.insertAdjacentHTML( 'beforeBegin', e.innerHTML ) ;
+ e.parentNode.removeChild( e ) ;
+}
+
+FCKTools.CreateXmlObject = function( object )
+{
+ var aObjs ;
+
+ switch ( object )
+ {
+ case 'XmlHttp' :
+ aObjs = [ 'MSXML2.XmlHttp', 'Microsoft.XmlHttp' ] ;
+ break ;
+
+ case 'DOMDocument' :
+ aObjs = [ 'MSXML2.DOMDocument', 'Microsoft.XmlDom' ] ;
+ break ;
+ }
+
+ for ( var i = 0 ; i < 2 ; i++ )
+ {
+ try { return new ActiveXObject( aObjs[i] ) ; }
+ catch (e)
+ {}
+ }
+
+ if ( FCKLang.NoActiveX )
+ {
+ alert( FCKLang.NoActiveX ) ;
+ FCKLang.NoActiveX = null ;
+ }
+}
+
+FCKTools.DisableSelection = function( element )
+{
+ element.unselectable = 'on' ;
+
+ var e, i = 0 ;
+ while ( e = element.all[ i++ ] )
+ {
+ switch ( e.tagName )
+ {
+ case 'IFRAME' :
+ case 'TEXTAREA' :
+ case 'INPUT' :
+ case 'SELECT' :
+ /* Ignore the above tags */
+ break ;
+ default :
+ e.unselectable = 'on' ;
+ }
+ }
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckundo_gecko.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckundo_gecko.js
new file mode 100644
index 00000000..a87f1d9a
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckundo_gecko.js
@@ -0,0 +1,4 @@
+var FCKUndo = new Object() ;
+
+FCKUndo.SaveUndoStep = function()
+{}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckundo_ie.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckundo_ie.js
new file mode 100644
index 00000000..55a8b8ad
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckundo_ie.js
@@ -0,0 +1,97 @@
+var FCKUndo = new Object() ;
+
+FCKUndo.SavedData = new Array() ;
+FCKUndo.CurrentIndex = -1 ;
+FCKUndo.TypesCount = FCKUndo.MaxTypes = 25 ;
+FCKUndo.Typing = false ;
+
+FCKUndo.SaveUndoStep = function()
+{
+ // 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/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckurlparams.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckurlparams.js
new file mode 100644
index 00000000..9add4ca0
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckurlparams.js
@@ -0,0 +1,32 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckurlparams.js
+ * Defines the FCKURLParams object that is used to get all parameters
+ * passed by the URL QueryString (after the "?").
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+// #### URLParams: holds all URL passed parameters (like ?Param1=Value1&Param2=Value2)
+var FCKURLParams = new Object() ;
+
+var aParams = document.location.search.substr(1).split('&') ;
+for ( var i = 0 ; i < aParams.length ; i++ )
+{
+ var aParam = aParams[i].split('=') ;
+ var sParamName = aParam[0] ;
+ var sParamValue = aParam[1] ;
+
+ FCKURLParams[ sParamName ] = sParamValue ;
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckxhtml.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckxhtml.js
new file mode 100644
index 00000000..a9324e58
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/internals/fckxhtml.js
@@ -0,0 +1,371 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fckxhtml.js
+ * Defines the FCKXHtml object, responsible for the XHTML operations.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKXHtml = new Object() ;
+
+FCKXHtml.CurrentJobNum = 0 ;
+
+FCKXHtml.GetXHTML = function( node, includeNode, format )
+{
+ // 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() ;
+
+ // Strip the "XHTML" root node.
+ sXHTML = sXHTML.substr( 7, sXHTML.length - 15 ).trim() ;
+
+ // Remove the trailing added by Gecko.
+ if ( FCKBrowserInfo.IsGecko )
+ sXHTML = sXHTML.replace( /$/, '' ) ;
+
+ // Add a space in the tags with no closing tags, like ->
+ 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] ) ;
+ }
+
+ this.XML = null ;
+
+ return sXHTML
+}
+
+FCKXHtml._AppendAttribute = function( xmlNode, attributeName, attributeValue )
+{
+ try
+ {
+ // Create the attribute.
+ var oXmlAtt = this.XML.createAttribute( attributeName ) ;
+
+ oXmlAtt.value = attributeValue ? attributeValue : '' ;
+
+ // Set the attribute in the node.
+ xmlNode.attributes.setNamedItem( oXmlAtt ) ;
+ }
+ catch (e)
+ {}
+}
+
+FCKXHtml._AppendChildNodes = function( xmlNode, htmlNode, isBlockElement )
+{
+ var iCount = 0 ;
+
+ var oNode = htmlNode.firstChild ;
+
+ while ( oNode )
+ {
+ if ( this._AppendNode( xmlNode, oNode ) )
+ iCount++ ;
+
+ oNode = oNode.nextSibling ;
+ }
+
+ if ( iCount == 0 )
+ {
+ if ( isBlockElement && FCKConfig.FillEmptyBlocks )
+ {
+ this._AppendEntity( xmlNode, 'nbsp' ) ;
+ return ;
+ }
+
+ // We can't use short representation of empty elements that are not marked
+ // as empty in th XHTML DTD.
+ if ( !FCKRegexLib.EmptyElements.test( htmlNode.nodeName ) )
+ xmlNode.appendChild( this.XML.createTextNode('') ) ;
+ }
+}
+
+FCKXHtml._AppendNode = function( xmlNode, htmlNode )
+{
+ if ( !htmlNode )
+ return ;
+
+ switch ( htmlNode.nodeType )
+ {
+ // Element Node.
+ case 1 :
+ 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 ;
+
+ if ( htmlNode.getAttribute('_fckdelete') )
+ return false ;
+
+ // Get the element name.
+ var sNodeName = htmlNode.nodeName ;
+
+ //Add namespace:
+ if ( FCKBrowserInfo.IsIE && htmlNode.scopeName && htmlNode.scopeName != 'HTML' )
+ sNodeName = htmlNode.scopeName + ':' + sNodeName ;
+
+ // Check if the node name is valid, otherwise ignore this tag.
+ // If the nodeName starts with a slash, it is a orphan closing tag.
+ // On some strange cases, the nodeName is empty, even if the node exists.
+ if ( !FCKRegexLib.ElementName.test( sNodeName ) )
+ return false ;
+
+ sNodeName = sNodeName.toLowerCase() ;
+
+ if ( FCKBrowserInfo.IsGecko && sNodeName == 'br' && htmlNode.hasAttribute('type') && htmlNode.getAttribute( 'type', 2 ) == '_moz' )
+ return false ;
+
+ // The already processed nodes must be marked to avoid then to be duplicated (bad formatted HTML).
+ // So here, the "mark" is checked... if the element is Ok, then mark it.
+ if ( htmlNode._fckxhtmljob && htmlNode._fckxhtmljob == FCKXHtml.CurrentJobNum )
+ return false ;
+
+ var oNode = this._CreateNode( sNodeName ) ;
+
+ // Add all attributes.
+ FCKXHtml._AppendAttributes( xmlNode, htmlNode, oNode, sNodeName ) ;
+
+ htmlNode._fckxhtmljob = FCKXHtml.CurrentJobNum ;
+
+ // Tag specific processing.
+ var oTagProcessor = FCKXHtml.TagProcessors[ sNodeName ] ;
+
+ if ( oTagProcessor )
+ {
+ oNode = oTagProcessor( oNode, htmlNode ) ;
+ if ( !oNode ) break ;
+ }
+ else
+ this._AppendChildNodes( oNode, htmlNode, FCKRegexLib.BlockElements.test( sNodeName ) ) ;
+
+ xmlNode.appendChild( oNode ) ;
+
+ break ;
+
+ // Text Node.
+ case 3 :
+ this._AppendTextNode( xmlNode, htmlNode.nodeValue.replaceNewLineChars(' ') ) ;
+ break ;
+
+ // Comment
+ case 8 :
+ 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 ;
+}
+
+if ( FCKConfig.ForceStrongEm )
+{
+ FCKXHtml._CreateNode = function( nodeName )
+ {
+ switch ( nodeName )
+ {
+ case 'b' :
+ nodeName = 'strong' ;
+ break ;
+ case 'i' :
+ nodeName = 'em' ;
+ break ;
+ }
+ return this.XML.createElement( nodeName ) ;
+ }
+}
+else
+{
+ FCKXHtml._CreateNode = function( 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 ) ;
+}
+
+//if ( FCKConfig.ProcessHTMLEntities )
+//{
+ FCKXHtml._AppendTextNode = function( targetNode, textValue )
+ {
+ // We can't just replace the special chars with entities and create a
+ // text node with it. We must split the text isolating the special chars
+ // and add each piece a time.
+ var asPieces = textValue.match( FCKXHtmlEntities.EntitiesRegex ) ;
+
+ if ( asPieces )
+ {
+ for ( var i = 0 ; i < asPieces.length ; i++ )
+ {
+ if ( asPieces[i].length == 1 )
+ {
+ var sEntity = FCKXHtmlEntities.Entities[ asPieces[i] ] ;
+ if ( sEntity != null )
+ {
+ this._AppendEntity( targetNode, sEntity ) ;
+ continue ;
+ }
+ }
+ targetNode.appendChild( this.XML.createTextNode( asPieces[i] ) ) ;
+ }
+ }
+ }
+//}
+//else
+//{
+// FCKXHtml._AppendTextNode = function( targetNode, textValue )
+// {
+// targetNode.appendChild( this.XML.createTextNode( textValue ) ) ;
+// }
+//}
+
+// An object that hold tag specific operations.
+FCKXHtml.TagProcessors = new Object() ;
+
+FCKXHtml.TagProcessors['img'] = function( node, htmlNode )
+{
+ // The "ALT" attribute is required in XHTML.
+ if ( ! node.attributes.getNamedItem( 'alt' ) )
+ FCKXHtml._AppendAttribute( node, 'alt', '' ) ;
+
+ var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ;
+ if ( sSavedUrl && sSavedUrl.length > 0 )
+ FCKXHtml._AppendAttribute( node, 'src', sSavedUrl ) ;
+
+ return node ;
+}
+
+FCKXHtml.TagProcessors['a'] = function( node, htmlNode )
+{
+ var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ;
+ if ( sSavedUrl && sSavedUrl.length > 0 )
+ FCKXHtml._AppendAttribute( node, 'href', sSavedUrl ) ;
+
+ FCKXHtml._AppendChildNodes( node, htmlNode, false ) ;
+
+ return node ;
+}
+
+FCKXHtml.TagProcessors['script'] = function( node, htmlNode )
+{
+ // The "TYPE" attribute is required in XHTML.
+ if ( ! node.attributes.getNamedItem( 'type' ) )
+ FCKXHtml._AppendAttribute( node, 'type', 'text/javascript' ) ;
+
+ node.appendChild( FCKXHtml.XML.createTextNode( FCKXHtml._AppendSpecialItem( htmlNode.text ) ) ) ;
+
+ return node ;
+}
+
+FCKXHtml.TagProcessors['style'] = function( node, htmlNode )
+{
+ // The "_fcktemp" attribute is used to mark the
 + '.gif){kind=small}
' ;
+
+ oCell = this._Row.insertCell(-1) ;
+ oCell.className = 'CM_Label' ;
+ oCell.noWrap = true ;
+ oCell.innerHTML = this.Label ;
+}
+
+FCKContextMenuItem.prototype.SetVisible = function( isVisible )
+{
+ this._Row.style.display = isVisible ? '' : 'none' ;
+}
+
+FCKContextMenuItem.prototype.RefreshState = function()
+{
+ switch ( this.Command.GetState() )
+ {
+ case FCK_TRISTATE_ON :
+ case FCK_TRISTATE_OFF :
+ this._Row.className = 'CM_Option' ;
+ break ;
+ default :
+ this._Row.className = 'CM_Disabled' ;
+ break ;
+ }
+}
+
+/*
+Sample output.
+-----------------------------------------
+
' ;
+
+ FCKToolbarSet.DOMElement.appendChild( e ) ;
+}
+
+FCKToolbar.prototype.AddItem = function( toolbarItem )
+{
+ this.Items[ this.Items.length ] = toolbarItem ;
+ toolbarItem.CreateInstance( this ) ;
+}
+
+FCKToolbar.prototype.AddSeparator = function()
+{
+ var oCell = this.DOMRow.insertCell(-1) ;
+ oCell.innerHTML = '
' ;
+}
+
+FCKToolbar.prototype.AddTerminator = function()
+{
+ var oCell = this.DOMRow.insertCell(-1) ;
+ oCell.className = 'TB_End' ;
+ oCell.innerHTML = '
' ;
+}
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbreak_gecko.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbreak_gecko.js
new file mode 100644
index 00000000..65e08e79
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbreak_gecko.js
@@ -0,0 +1,29 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktoolbarbreak_gecko.js
+ * FCKToolbarBreak Class: breaks the toolbars.
+ * It makes it possible to force the toolbar to brak to a new line.
+ * This is the Gecko specific implementation.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarBreak = function()
+{
+ var oBreakDiv = document.createElement( 'div' ) ;
+
+ oBreakDiv.style.clear = oBreakDiv.style.cssFloat = FCKLang.Dir == 'rtl' ? 'right' : 'left' ;
+
+ FCKToolbarSet.DOMElement.appendChild( oBreakDiv ) ;
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbreak_ie.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbreak_ie.js
new file mode 100644
index 00000000..d6c913be
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbreak_ie.js
@@ -0,0 +1,31 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktoolbarbreak_ie.js
+ * FCKToolbarBreak Class: breaks the toolbars.
+ * It makes it possible to force the toolbar to brak to a new line.
+ * This is the IE specific implementation.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarBreak = function()
+{
+ var oBreakDiv = document.createElement( 'div' ) ;
+
+ oBreakDiv.className = 'TB_Break' ;
+
+ oBreakDiv.style.clear = FCKLang.Dir == 'rtl' ? 'left' : 'right' ;
+
+ FCKToolbarSet.DOMElement.appendChild( oBreakDiv ) ;
+}
\ No newline at end of file
diff --git a/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbutton.js b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbutton.js
new file mode 100644
index 00000000..b9d05e71
--- /dev/null
+++ b/oss/vtiger/trunk/include/fckeditor/editor/_source/classes/fcktoolbarbutton.js
@@ -0,0 +1,148 @@
+/*
+ * FCKeditor - The text editor for internet
+ * Copyright (C) 2003-2005 Frederico Caldeira Knabben
+ *
+ * Licensed under the terms of the GNU Lesser General Public License:
+ * http://www.opensource.org/licenses/lgpl-license.php
+ *
+ * For further information visit:
+ * http://www.fckeditor.net/
+ *
+ * "Support Open Source software. What about a donation today?"
+ *
+ * File Name: fcktoolbarbutton.js
+ * FCKToolbarButton Class: represents a button in the toolbar.
+ *
+ * File Authors:
+ * Frederico Caldeira Knabben (fredck@fckeditor.net)
+ */
+
+var FCKToolbarButton = function( commandName, label, tooltip, style, sourceView, contextSensitive )
+{
+ this.Command = FCKCommands.GetCommand( commandName ) ;
+ this.Label = label ? label : commandName ;
+ this.Tooltip = tooltip ? tooltip : ( label ? label : commandName) ;
+ this.Style = style ? style : FCK_TOOLBARITEM_ONLYICON ;
+ this.SourceView = sourceView ? true : false ;
+ this.ContextSensitive = contextSensitive ? true : false ;
+ this.IconPath = FCKConfig.SkinPath + 'toolbar/' + commandName.toLowerCase() + '.gif' ;
+ this.State = FCK_UNKNOWN ;
+}
+
+FCKToolbarButton.prototype.CreateInstance = function( parentToolbar )
+{
+ this.DOMDiv = document.createElement( 'div' ) ;
+ this.DOMDiv.className = 'TB_Button_Off' ;
+
+ this.DOMDiv.FCKToolbarButton = this ;
+
+ var sHtml =
+ '
