/branches/livraison_aha/api/fckeditor/editor/_source/fckjscoreextensions.js |
---|
New file |
0,0 → 1,120 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckjscoreextensions.js |
* Extensions to the JavaScript Core. |
* |
* All custom extentions functions are PascalCased to differ from the standard |
* camelCased ones. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
String.prototype.Contains = function( textToCheck ) |
{ |
return ( this.indexOf( textToCheck ) > -1 ) ; |
} |
String.prototype.Equals = function() |
{ |
for ( var i = 0 ; i < arguments.length ; i++ ) |
if ( this == arguments[i] ) |
return true ; |
return false ; |
} |
String.prototype.ReplaceAll = function( searchArray, replaceArray ) |
{ |
var replaced = this ; |
for ( var i = 0 ; i < searchArray.length ; i++ ) |
{ |
replaced = replaced.replace( searchArray[i], replaceArray[i] ) ; |
} |
return replaced ; |
} |
Array.prototype.AddItem = function( item ) |
{ |
var i = this.length ; |
this[ i ] = item ; |
return i ; |
} |
Array.prototype.indexOf = function( value ) |
{ |
for ( var i = 0 ; i < this.length ; i++ ) |
{ |
if ( this[i] == value ) |
return i ; |
} |
return -1 ; |
} |
String.prototype.startsWith = function( value ) |
{ |
return ( this.substr( 0, value.length ) == value ) ; |
} |
// Extends the String object, creating a "endsWith" method on it. |
String.prototype.endsWith = function( value, ignoreCase ) |
{ |
var L1 = this.length ; |
var L2 = value.length ; |
if ( L2 > L1 ) |
return false ; |
if ( ignoreCase ) |
{ |
var oRegex = new RegExp( value + '$' , 'i' ) ; |
return oRegex.test( this ) ; |
} |
else |
return ( L2 == 0 || this.substr( L1 - L2, L2 ) == value ) ; |
} |
String.prototype.remove = function( start, length ) |
{ |
var s = '' ; |
if ( start > 0 ) |
s = this.substring( 0, start ) ; |
if ( start + length < this.length ) |
s += this.substring( start + length , this.length ) ; |
return s ; |
} |
String.prototype.trim = function() |
{ |
return this.replace( /(^\s*)|(\s*$)/g, '' ) ; |
} |
String.prototype.ltrim = function() |
{ |
return this.replace( /^\s*/g, '' ) ; |
} |
String.prototype.rtrim = function() |
{ |
return this.replace( /\s*$/g, '' ) ; |
} |
String.prototype.replaceNewLineChars = function( replacement ) |
{ |
return this.replace( /\n/g, replacement ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/fckconstants.js |
---|
New file |
0,0 → 1,44 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckconstants.js |
* Defines some constants used by the editor. These constants are also |
* globally available in the page where the editor is placed. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// Editor Instance Status. |
var FCK_STATUS_NOTLOADED = window.parent.FCK_STATUS_NOTLOADED = 0 ; |
var FCK_STATUS_ACTIVE = window.parent.FCK_STATUS_ACTIVE = 1 ; |
var FCK_STATUS_COMPLETE = window.parent.FCK_STATUS_COMPLETE = 2 ; |
// Tristate Operations. |
var FCK_TRISTATE_OFF = window.parent.FCK_TRISTATE_OFF = 0 ; |
var FCK_TRISTATE_ON = window.parent.FCK_TRISTATE_ON = 1 ; |
var FCK_TRISTATE_DISABLED = window.parent.FCK_TRISTATE_DISABLED = -1 ; |
// For unknown values. |
var FCK_UNKNOWN = window.parent.FCK_UNKNOWN = -9 ; |
// Toolbar Items Style. |
var FCK_TOOLBARITEM_ONLYICON = window.parent.FCK_TOOLBARITEM_ONLYICON = 0 ; |
var FCK_TOOLBARITEM_ONLYTEXT = window.parent.FCK_TOOLBARITEM_ONLYTEXT = 1 ; |
var FCK_TOOLBARITEM_ICONTEXT = window.parent.FCK_TOOLBARITEM_ICONTEXT = 2 ; |
// Edit Mode |
var FCK_EDITMODE_WYSIWYG = window.parent.FCK_EDITMODE_WYSIWYG = 0 ; |
var FCK_EDITMODE_SOURCE = window.parent.FCK_EDITMODE_SOURCE = 1 ; |
var FCK_IMAGES_PATH = 'images/' ; // Check usage. |
var FCK_SPACER_PATH = 'images/spacer.gif' ; |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fckspellcheckcommand_ie.js |
---|
New file |
0,0 → 1,63 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckspellcheckcommand_ie.js |
* FCKStyleCommand Class: represents the "Spell Check" command. |
* (IE specific implementation) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKSpellCheckCommand = function() |
{ |
this.Name = 'SpellCheck' ; |
this.IsEnabled = ( FCKConfig.SpellChecker == 'ieSpell' || FCKConfig.SpellChecker == 'SpellerPages' ) ; |
} |
FCKSpellCheckCommand.prototype.Execute = function() |
{ |
switch ( FCKConfig.SpellChecker ) |
{ |
case 'ieSpell' : |
this._RunIeSpell() ; |
break ; |
case 'SpellerPages' : |
FCKDialog.OpenDialog( 'FCKDialog_SpellCheck', 'Spell Check', 'dialog/fck_spellerpages.html', 440, 480 ) ; |
break ; |
} |
} |
FCKSpellCheckCommand.prototype._RunIeSpell = function() |
{ |
try |
{ |
var oIeSpell = new ActiveXObject( "ieSpell.ieSpellExtension" ) ; |
oIeSpell.CheckAllLinkedDocuments( FCK.EditorDocument ) ; |
} |
catch( e ) |
{ |
if( e.number == -2146827859 ) |
{ |
if ( confirm( FCKLang.IeSpellDownload ) ) |
window.open( FCKConfig.IeSpellDownloadUrl , 'IeSpellDownload' ) ; |
} |
else |
alert( 'Error Loading ieSpell: ' + e.message + ' (' + e.number + ')' ) ; |
} |
} |
FCKSpellCheckCommand.prototype.GetState = function() |
{ |
return this.IsEnabled ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fckfitwindow.js |
---|
New file |
0,0 → 1,164 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckfitwindow.js |
* Stretch the editor to full window size and back. |
* |
* File Authors: |
* Paul Moers (mail@saulmade.nl) |
* Thanks to Christian Fecteau (webmaster@christianfecteau.com) |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKFitWindow = function() |
{ |
this.Name = 'FitWindow' ; |
} |
FCKFitWindow.prototype.Execute = function() |
{ |
var eEditorFrame = window.frameElement ; |
var eEditorFrameStyle = eEditorFrame.style ; |
var eMainWindow = parent ; |
var eDocEl = eMainWindow.document.documentElement ; |
var eBody = eMainWindow.document.body ; |
var eBodyStyle = eBody.style ; |
// No original style properties known? Go fullscreen. |
if ( !this.IsMaximized ) |
{ |
// Registering an event handler when the window gets resized. |
if( FCKBrowserInfo.IsIE ) |
eMainWindow.attachEvent( 'onresize', FCKFitWindow_Resize ) ; |
else |
eMainWindow.addEventListener( 'resize', FCKFitWindow_Resize, true ) ; |
// Save the scrollbars position. |
this._ScrollPos = FCKTools.GetScrollPosition( eMainWindow ) ; |
// Save and reset the styles for the entire node tree. They could interfere in the result. |
var eParent = eEditorFrame ; |
while( eParent = eParent.parentNode ) |
{ |
if ( eParent.nodeType == 1 ) |
eParent._fckSavedStyles = FCKTools.SaveStyles( eParent ) ; |
} |
// Hide IE scrollbars (in strict mode). |
if ( FCKBrowserInfo.IsIE ) |
{ |
this.documentElementOverflow = eDocEl.style.overflow ; |
eDocEl.style.overflow = 'hidden' ; |
eBodyStyle.overflow = 'hidden' ; |
} |
else |
{ |
// Hide the scroolbars in Firefox. |
eBodyStyle.overflow = 'hidden' ; |
eBodyStyle.width = '0px' ; |
eBodyStyle.height = '0px' ; |
} |
// Save the IFRAME styles. |
this._EditorFrameStyles = FCKTools.SaveStyles( eEditorFrame ) ; |
// Resize. |
var oViewPaneSize = FCKTools.GetViewPaneSize( eMainWindow ) ; |
eEditorFrameStyle.position = "absolute"; |
eEditorFrameStyle.zIndex = FCKConfig.FloatingPanelsZIndex - 1; |
eEditorFrameStyle.left = "0px"; |
eEditorFrameStyle.top = "0px"; |
eEditorFrameStyle.width = oViewPaneSize.Width + "px"; |
eEditorFrameStyle.height = oViewPaneSize.Height + "px"; |
// Giving the frame some (huge) borders on his right and bottom |
// side to hide the background that would otherwise show when the |
// editor is in fullsize mode and the window is increased in size |
// not for IE, because IE immediately adapts the editor on resize, |
// without showing any of the background oddly in firefox, the |
// editor seems not to fill the whole frame, so just setting the |
// background of it to white to cover the page laying behind it anyway. |
if ( !FCKBrowserInfo.IsIE ) |
{ |
eEditorFrameStyle.borderRight = eEditorFrameStyle.borderBottom = "9999px solid white" ; |
eEditorFrameStyle.backgroundColor = "white"; |
} |
// Scroll to top left. |
eMainWindow.scrollTo(0, 0); |
this.IsMaximized = true ; |
} |
else // Resize to original size. |
{ |
// Remove the event handler of window resizing. |
if( FCKBrowserInfo.IsIE ) |
eMainWindow.detachEvent( "onresize", FCKFitWindow_Resize ) ; |
else |
eMainWindow.removeEventListener( "resize", FCKFitWindow_Resize, true ) ; |
// Restore the CSS position for the entire node tree. |
var eParent = eEditorFrame ; |
while( eParent = eParent.parentNode ) |
{ |
if ( eParent._fckSavedStyles ) |
{ |
FCKTools.RestoreStyles( eParent, eParent._fckSavedStyles ) ; |
eParent._fckSavedStyles = null ; |
} |
} |
// Restore IE scrollbars |
if ( FCKBrowserInfo.IsIE ) |
eDocEl.style.overflow = this.documentElementOverflow ; |
// Restore original size |
FCKTools.RestoreStyles( eEditorFrame, this._EditorFrameStyles ) ; |
// Restore the window scroll position. |
eMainWindow.scrollTo( this._ScrollPos.X, this._ScrollPos.Y ) ; |
this.IsMaximized = false ; |
} |
FCKToolbarItems.GetItem('FitWindow').RefreshState() ; |
// It seams that Firefox restarts the editing area when making this changes. |
// On FF 1.0.x, the area is not anymore editable. On FF 1.5+, the special |
//configuration, like DisableFFTableHandles and DisableObjectResizing get |
//lost, so we must reset it. Also, the cursor position and selection are |
//also lost, even if you comment the following line (MakeEditable). |
// if ( FCKBrowserInfo.IsGecko10 ) // Initially I thought it was a FF 1.0 only problem. |
FCK.EditingArea.MakeEditable() ; |
FCK.Focus() ; |
} |
FCKFitWindow.prototype.GetState = function() |
{ |
if ( FCKConfig.ToolbarLocation != 'In' ) |
return FCK_TRISTATE_DISABLED ; |
else |
return ( this.IsMaximized ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF ); |
} |
function FCKFitWindow_Resize() |
{ |
var oViewPaneSize = FCKTools.GetViewPaneSize( parent ) ; |
var eEditorFrameStyle = window.frameElement.style ; |
eEditorFrameStyle.width = oViewPaneSize.Width + 'px' ; |
eEditorFrameStyle.height = oViewPaneSize.Height + 'px' ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fckstylecommand.js |
---|
New file |
0,0 → 1,95 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckstylecommand.js |
* FCKStyleCommand Class: represents the "Style" command. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKStyleCommand = function() |
{ |
this.Name = 'Style' ; |
// Load the Styles defined in the XML file. |
this.StylesLoader = new FCKStylesLoader() ; |
this.StylesLoader.Load( FCKConfig.StylesXmlPath ) ; |
this.Styles = this.StylesLoader.Styles ; |
} |
FCKStyleCommand.prototype.Execute = function( styleName, styleComboItem ) |
{ |
FCKUndo.SaveUndoStep() ; |
if ( styleComboItem.Selected ) |
styleComboItem.Style.RemoveFromSelection() ; |
else |
styleComboItem.Style.ApplyToSelection() ; |
FCKUndo.SaveUndoStep() ; |
FCK.Focus() ; |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
FCKStyleCommand.prototype.GetState = function() |
{ |
if ( !FCK.EditorDocument ) |
return FCK_TRISTATE_DISABLED ; |
var oSelection = FCK.EditorDocument.selection ; |
if ( FCKSelection.GetType() == 'Control' ) |
{ |
var e = FCKSelection.GetSelectedElement() ; |
if ( e ) |
return this.StylesLoader.StyleGroups[ e.tagName ] ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; |
} |
return FCK_TRISTATE_OFF ; |
} |
FCKStyleCommand.prototype.GetActiveStyles = function() |
{ |
var aActiveStyles = new Array() ; |
if ( FCKSelection.GetType() == 'Control' ) |
this._CheckStyle( FCKSelection.GetSelectedElement(), aActiveStyles, false ) ; |
else |
this._CheckStyle( FCKSelection.GetParentElement(), aActiveStyles, true ) ; |
return aActiveStyles ; |
} |
FCKStyleCommand.prototype._CheckStyle = function( element, targetArray, checkParent ) |
{ |
if ( ! element ) |
return ; |
if ( element.nodeType == 1 ) |
{ |
var aStyleGroup = this.StylesLoader.StyleGroups[ element.tagName ] ; |
if ( aStyleGroup ) |
{ |
for ( var i = 0 ; i < aStyleGroup.length ; i++ ) |
{ |
if ( aStyleGroup[i].IsEqual( element ) ) |
targetArray[ targetArray.length ] = aStyleGroup[i] ; |
} |
} |
} |
if ( checkParent ) |
this._CheckStyle( element.parentNode, targetArray, checkParent ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fck_othercommands.js |
---|
New file |
0,0 → 1,309 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_othercommands.js |
* Definition of other commands that are not available internaly in the |
* browser (see FCKNamedCommand). |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// ### General Dialog Box Commands. |
var FCKDialogCommand = function( name, title, url, width, height, getStateFunction, getStateParam ) |
{ |
this.Name = name ; |
this.Title = title ; |
this.Url = url ; |
this.Width = width ; |
this.Height = height ; |
this.GetStateFunction = getStateFunction ; |
this.GetStateParam = getStateParam ; |
} |
FCKDialogCommand.prototype.Execute = function() |
{ |
FCKDialog.OpenDialog( 'FCKDialog_' + this.Name , this.Title, this.Url, this.Width, this.Height ) ; |
} |
FCKDialogCommand.prototype.GetState = function() |
{ |
if ( this.GetStateFunction ) |
return this.GetStateFunction( this.GetStateParam ) ; |
else |
return FCK_TRISTATE_OFF ; |
} |
// Generic Undefined command (usually used when a command is under development). |
var FCKUndefinedCommand = function() |
{ |
this.Name = 'Undefined' ; |
} |
FCKUndefinedCommand.prototype.Execute = function() |
{ |
alert( FCKLang.NotImplemented ) ; |
} |
FCKUndefinedCommand.prototype.GetState = function() |
{ |
return FCK_TRISTATE_OFF ; |
} |
// ### FontName |
var FCKFontNameCommand = function() |
{ |
this.Name = 'FontName' ; |
} |
FCKFontNameCommand.prototype.Execute = function( fontName ) |
{ |
if (fontName == null || fontName == "") |
{ |
// TODO: Remove font name attribute. |
} |
else |
FCK.ExecuteNamedCommand( 'FontName', fontName ) ; |
} |
FCKFontNameCommand.prototype.GetState = function() |
{ |
return FCK.GetNamedCommandValue( 'FontName' ) ; |
} |
// ### FontSize |
var FCKFontSizeCommand = function() |
{ |
this.Name = 'FontSize' ; |
} |
FCKFontSizeCommand.prototype.Execute = function( fontSize ) |
{ |
if ( typeof( fontSize ) == 'string' ) fontSize = parseInt(fontSize) ; |
if ( fontSize == null || fontSize == '' ) |
{ |
// TODO: Remove font size attribute (Now it works with size 3. Will it work forever?) |
FCK.ExecuteNamedCommand( 'FontSize', 3 ) ; |
} |
else |
FCK.ExecuteNamedCommand( 'FontSize', fontSize ) ; |
} |
FCKFontSizeCommand.prototype.GetState = function() |
{ |
return FCK.GetNamedCommandValue( 'FontSize' ) ; |
} |
// ### FormatBlock |
var FCKFormatBlockCommand = function() |
{ |
this.Name = 'FormatBlock' ; |
} |
FCKFormatBlockCommand.prototype.Execute = function( formatName ) |
{ |
if ( formatName == null || formatName == '' ) |
FCK.ExecuteNamedCommand( 'FormatBlock', '<P>' ) ; |
else if ( formatName == 'div' && FCKBrowserInfo.IsGecko ) |
FCK.ExecuteNamedCommand( 'FormatBlock', 'div' ) ; |
else |
FCK.ExecuteNamedCommand( 'FormatBlock', '<' + formatName + '>' ) ; |
} |
FCKFormatBlockCommand.prototype.GetState = function() |
{ |
return FCK.GetNamedCommandValue( 'FormatBlock' ) ; |
} |
// ### Preview |
var FCKPreviewCommand = function() |
{ |
this.Name = 'Preview' ; |
} |
FCKPreviewCommand.prototype.Execute = function() |
{ |
FCK.Preview() ; |
} |
FCKPreviewCommand.prototype.GetState = function() |
{ |
return FCK_TRISTATE_OFF ; |
} |
// ### Save |
var FCKSaveCommand = function() |
{ |
this.Name = 'Save' ; |
} |
FCKSaveCommand.prototype.Execute = function() |
{ |
// Get the linked field form. |
var oForm = FCK.LinkedField.form ; |
if ( typeof( oForm.onsubmit ) == 'function' ) |
{ |
var bRet = oForm.onsubmit() ; |
if ( bRet != null && bRet === false ) |
return ; |
} |
// Submit the form. |
oForm.submit() ; |
} |
FCKSaveCommand.prototype.GetState = function() |
{ |
return FCK_TRISTATE_OFF ; |
} |
// ### NewPage |
var FCKNewPageCommand = function() |
{ |
this.Name = 'NewPage' ; |
} |
FCKNewPageCommand.prototype.Execute = function() |
{ |
FCKUndo.SaveUndoStep() ; |
FCK.SetHTML( '' ) ; |
FCKUndo.Typing = true ; |
// FCK.SetHTML( FCKBrowserInfo.IsGecko ? ' ' : '' ) ; |
// FCK.SetHTML( FCKBrowserInfo.IsGecko ? GECKO_BOGUS : '' ) ; |
} |
FCKNewPageCommand.prototype.GetState = function() |
{ |
return FCK_TRISTATE_OFF ; |
} |
// ### Source button |
var FCKSourceCommand = function() |
{ |
this.Name = 'Source' ; |
} |
FCKSourceCommand.prototype.Execute = function() |
{ |
if ( FCKConfig.SourcePopup ) // Until v2.2, it was mandatory for FCKBrowserInfo.IsGecko. |
{ |
var iWidth = FCKConfig.ScreenWidth * 0.65 ; |
var iHeight = FCKConfig.ScreenHeight * 0.65 ; |
FCKDialog.OpenDialog( 'FCKDialog_Source', FCKLang.Source, 'dialog/fck_source.html', iWidth, iHeight, null, null, true ) ; |
} |
else |
FCK.SwitchEditMode() ; |
} |
FCKSourceCommand.prototype.GetState = function() |
{ |
return ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ? FCK_TRISTATE_OFF : FCK_TRISTATE_ON ) ; |
} |
// ### Undo |
var FCKUndoCommand = function() |
{ |
this.Name = 'Undo' ; |
} |
FCKUndoCommand.prototype.Execute = function() |
{ |
if ( FCKBrowserInfo.IsIE ) |
FCKUndo.Undo() ; |
else |
FCK.ExecuteNamedCommand( 'Undo' ) ; |
} |
FCKUndoCommand.prototype.GetState = function() |
{ |
if ( FCKBrowserInfo.IsIE ) |
return ( FCKUndo.CheckUndoState() ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ) ; |
else |
return FCK.GetNamedCommandState( 'Undo' ) ; |
} |
// ### Redo |
var FCKRedoCommand = function() |
{ |
this.Name = 'Redo' ; |
} |
FCKRedoCommand.prototype.Execute = function() |
{ |
if ( FCKBrowserInfo.IsIE ) |
FCKUndo.Redo() ; |
else |
FCK.ExecuteNamedCommand( 'Redo' ) ; |
} |
FCKRedoCommand.prototype.GetState = function() |
{ |
if ( FCKBrowserInfo.IsIE ) |
return ( FCKUndo.CheckRedoState() ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ) ; |
else |
return FCK.GetNamedCommandState( 'Redo' ) ; |
} |
// ### Page Break |
var FCKPageBreakCommand = function() |
{ |
this.Name = 'PageBreak' ; |
} |
FCKPageBreakCommand.prototype.Execute = function() |
{ |
// var e = FCK.EditorDocument.createElement( 'CENTER' ) ; |
// e.style.pageBreakAfter = 'always' ; |
// Tidy was removing the empty CENTER tags, so the following solution has |
// been found. It also validates correctly as XHTML 1.0 Strict. |
var e = FCK.EditorDocument.createElement( 'DIV' ) ; |
e.style.pageBreakAfter = 'always' ; |
e.innerHTML = '<span style="DISPLAY:none"> </span>' ; |
var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', e ) ; |
oFakeImage = FCK.InsertElement( oFakeImage ) ; |
} |
FCKPageBreakCommand.prototype.GetState = function() |
{ |
return 0 ; // FCK_TRISTATE_OFF |
} |
// FCKUnlinkCommand - by Johnny Egeland (johnny@coretrek.com) |
var FCKUnlinkCommand = function() |
{ |
this.Name = 'Unlink' ; |
} |
FCKUnlinkCommand.prototype.Execute = function() |
{ |
if ( FCKBrowserInfo.IsGecko ) |
{ |
var oLink = FCK.Selection.MoveToAncestorNode( 'A' ) ; |
if ( oLink ) |
FCK.Selection.SelectNode( oLink ) ; |
} |
FCK.ExecuteNamedCommand( this.Name ) ; |
if ( FCKBrowserInfo.IsGecko ) |
FCK.Selection.Collapse( true ) ; |
} |
FCKUnlinkCommand.prototype.GetState = function() |
{ |
return FCK.GetNamedCommandState( this.Name ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fcktextcolorcommand.js |
---|
New file |
0,0 → 1,171 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktextcolorcommand.js |
* FCKTextColorCommand Class: represents the text color comand. It shows the |
* color selection panel. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// FCKTextColorCommand Contructor |
// type: can be 'ForeColor' or 'BackColor'. |
var FCKTextColorCommand = function( type ) |
{ |
this.Name = type == 'ForeColor' ? 'TextColor' : 'BGColor' ; |
this.Type = type ; |
var oWindow ; |
if ( FCKBrowserInfo.IsIE ) |
oWindow = window ; |
else if ( FCK.ToolbarSet._IFrame ) |
oWindow = FCKTools.GetElementWindow( FCK.ToolbarSet._IFrame ) ; |
else |
oWindow = window.parent ; |
this._Panel = new FCKPanel( oWindow, true ) ; |
this._Panel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ; |
this._Panel.MainNode.className = 'FCK_Panel' ; |
this._CreatePanelBody( this._Panel.Document, this._Panel.MainNode ) ; |
FCKTools.DisableSelection( this._Panel.Document.body ) ; |
} |
FCKTextColorCommand.prototype.Execute = function( panelX, panelY, relElement ) |
{ |
// We must "cache" the actual panel type to be used in the SetColor method. |
FCK._ActiveColorPanelType = this.Type ; |
// Show the Color Panel at the desired position. |
this._Panel.Show( panelX, panelY, relElement ) ; |
} |
FCKTextColorCommand.prototype.SetColor = function( color ) |
{ |
if ( FCK._ActiveColorPanelType == 'ForeColor' ) |
FCK.ExecuteNamedCommand( 'ForeColor', color ) ; |
else if ( FCKBrowserInfo.IsGeckoLike ) |
{ |
if ( FCKBrowserInfo.IsGecko && !FCKConfig.GeckoUseSPAN ) |
FCK.EditorDocument.execCommand( 'useCSS', false, false ) ; |
FCK.ExecuteNamedCommand( 'hilitecolor', color ) ; |
if ( FCKBrowserInfo.IsGecko && !FCKConfig.GeckoUseSPAN ) |
FCK.EditorDocument.execCommand( 'useCSS', false, true ) ; |
} |
else |
FCK.ExecuteNamedCommand( 'BackColor', color ) ; |
// Delete the "cached" active panel type. |
delete FCK._ActiveColorPanelType ; |
} |
FCKTextColorCommand.prototype.GetState = function() |
{ |
return FCK_TRISTATE_OFF ; |
} |
function FCKTextColorCommand_OnMouseOver() { this.className='ColorSelected' ; } |
function FCKTextColorCommand_OnMouseOut() { this.className='ColorDeselected' ; } |
function FCKTextColorCommand_OnClick() |
{ |
this.className = 'ColorDeselected' ; |
this.Command.SetColor( '#' + this.Color ) ; |
this.Command._Panel.Hide() ; |
} |
function FCKTextColorCommand_AutoOnClick() |
{ |
this.className = 'ColorDeselected' ; |
this.Command.SetColor( '' ) ; |
this.Command._Panel.Hide() ; |
} |
function FCKTextColorCommand_MoreOnClick() |
{ |
this.className = 'ColorDeselected' ; |
this.Command._Panel.Hide() ; |
FCKDialog.OpenDialog( 'FCKDialog_Color', FCKLang.DlgColorTitle, 'dialog/fck_colorselector.html', 400, 330, this.Command.SetColor ) ; |
} |
FCKTextColorCommand.prototype._CreatePanelBody = function( targetDocument, targetDiv ) |
{ |
function CreateSelectionDiv() |
{ |
var oDiv = targetDocument.createElement( "DIV" ) ; |
oDiv.className = 'ColorDeselected' ; |
oDiv.onmouseover = FCKTextColorCommand_OnMouseOver ; |
oDiv.onmouseout = FCKTextColorCommand_OnMouseOut ; |
return oDiv ; |
} |
// Create the Table that will hold all colors. |
var oTable = targetDiv.appendChild( targetDocument.createElement( "TABLE" ) ) ; |
oTable.className = 'ForceBaseFont' ; // Firefox 1.5 Bug. |
oTable.style.tableLayout = 'fixed' ; |
oTable.cellPadding = 0 ; |
oTable.cellSpacing = 0 ; |
oTable.border = 0 ; |
oTable.width = 150 ; |
var oCell = oTable.insertRow(-1).insertCell(-1) ; |
oCell.colSpan = 8 ; |
// Create the Button for the "Automatic" color selection. |
var oDiv = oCell.appendChild( CreateSelectionDiv() ) ; |
oDiv.innerHTML = |
'<table cellspacing="0" cellpadding="0" width="100%" border="0">\ |
<tr>\ |
<td><div class="ColorBoxBorder"><div class="ColorBox" style="background-color: #000000"></div></div></td>\ |
<td nowrap width="100%" align="center">' + FCKLang.ColorAutomatic + '</td>\ |
</tr>\ |
</table>' ; |
oDiv.Command = this ; |
oDiv.onclick = FCKTextColorCommand_AutoOnClick ; |
// Create an array of colors based on the configuration file. |
var aColors = FCKConfig.FontColors.toString().split(',') ; |
// Create the colors table based on the array. |
var iCounter = 0 ; |
while ( iCounter < aColors.length ) |
{ |
var oRow = oTable.insertRow(-1) ; |
for ( var i = 0 ; i < 8 && iCounter < aColors.length ; i++, iCounter++ ) |
{ |
oDiv = oRow.insertCell(-1).appendChild( CreateSelectionDiv() ) ; |
oDiv.Color = aColors[iCounter] ; |
oDiv.innerHTML = '<div class="ColorBoxBorder"><div class="ColorBox" style="background-color: #' + aColors[iCounter] + '"></div></div>' ; |
oDiv.Command = this ; |
oDiv.onclick = FCKTextColorCommand_OnClick ; |
} |
} |
// Create the Row and the Cell for the "More Colors..." button. |
oCell = oTable.insertRow(-1).insertCell(-1) ; |
oCell.colSpan = 8 ; |
oDiv = oCell.appendChild( CreateSelectionDiv() ) ; |
oDiv.innerHTML = '<table width="100%" cellpadding="0" cellspacing="0" border="0"><tr><td nowrap align="center">' + FCKLang.ColorMoreColors + '</td></tr></table>' ; |
oDiv.Command = this ; |
oDiv.onclick = FCKTextColorCommand_MoreOnClick ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fcknamedcommand.js |
---|
New file |
0,0 → 1,33 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcknamedcommand.js |
* FCKNamedCommand Class: represents an internal browser command. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKNamedCommand = function( commandName ) |
{ |
this.Name = commandName ; |
} |
FCKNamedCommand.prototype.Execute = function() |
{ |
FCK.ExecuteNamedCommand( this.Name ) ; |
} |
FCKNamedCommand.prototype.GetState = function() |
{ |
return FCK.GetNamedCommandState( this.Name ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fckpasteplaintextcommand.js |
---|
New file |
0,0 → 1,34 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckpasteplaintextcommand.js |
* FCKPastePlainTextCommand Class: represents the |
* "Paste as Plain Text" command. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKPastePlainTextCommand = function() |
{ |
this.Name = 'PasteText' ; |
} |
FCKPastePlainTextCommand.prototype.Execute = function() |
{ |
FCK.PasteAsPlainText() ; |
} |
FCKPastePlainTextCommand.prototype.GetState = function() |
{ |
return FCK.GetNamedCommandState( 'Paste' ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fckspellcheckcommand_gecko.js |
---|
New file |
0,0 → 1,35 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckspellcheckcommand_gecko.js |
* FCKStyleCommand Class: represents the "Spell Check" command. |
* (Gecko specific implementation) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKSpellCheckCommand = function() |
{ |
this.Name = 'SpellCheck' ; |
this.IsEnabled = ( FCKConfig.SpellChecker == 'SpellerPages' ) ; |
} |
FCKSpellCheckCommand.prototype.Execute = function() |
{ |
FCKDialog.OpenDialog( 'FCKDialog_SpellCheck', 'Spell Check', 'dialog/fck_spellerpages.html', 440, 480 ) ; |
} |
FCKSpellCheckCommand.prototype.GetState = function() |
{ |
return this.IsEnabled ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fcktablecommand.js |
---|
New file |
0,0 → 1,67 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktablecommand.js |
* FCKPastePlainTextCommand Class: represents the |
* "Paste as Plain Text" command. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKTableCommand = function( command ) |
{ |
this.Name = command ; |
} |
FCKTableCommand.prototype.Execute = function() |
{ |
FCKUndo.SaveUndoStep() ; |
switch ( this.Name ) |
{ |
case 'TableInsertRow' : |
FCKTableHandler.InsertRow() ; |
break ; |
case 'TableDeleteRows' : |
FCKTableHandler.DeleteRows() ; |
break ; |
case 'TableInsertColumn' : |
FCKTableHandler.InsertColumn() ; |
break ; |
case 'TableDeleteColumns' : |
FCKTableHandler.DeleteColumns() ; |
break ; |
case 'TableInsertCell' : |
FCKTableHandler.InsertCell() ; |
break ; |
case 'TableDeleteCells' : |
FCKTableHandler.DeleteCells() ; |
break ; |
case 'TableMergeCells' : |
FCKTableHandler.MergeCells() ; |
break ; |
case 'TableSplitCell' : |
FCKTableHandler.SplitCell() ; |
break ; |
case 'TableDelete' : |
FCKTableHandler.DeleteTable() ; |
break ; |
default : |
alert( FCKLang.UnknownCommand.replace( /%1/g, this.Name ) ) ; |
} |
} |
FCKTableCommand.prototype.GetState = function() |
{ |
return FCK_TRISTATE_OFF ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/commandclasses/fckpastewordcommand.js |
---|
New file |
0,0 → 1,36 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckpastewordcommand.js |
* FCKPasteWordCommand Class: represents the "Paste from Word" command. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKPasteWordCommand = function() |
{ |
this.Name = 'PasteWord' ; |
} |
FCKPasteWordCommand.prototype.Execute = function() |
{ |
FCK.PasteFromWord() ; |
} |
FCKPasteWordCommand.prototype.GetState = function() |
{ |
if ( FCKConfig.ForcePasteAsPlainText ) |
return FCK_TRISTATE_DISABLED ; |
else |
return FCK.GetNamedCommandState( 'Paste' ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckicon.js |
---|
New file |
0,0 → 1,94 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckicon.js |
* FCKIcon Class: renders an icon from a single image, a strip or even a |
* spacer. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKIcon = function( iconPathOrStripInfoArray ) |
{ |
var sTypeOf = iconPathOrStripInfoArray ? typeof( iconPathOrStripInfoArray ) : 'undefined' ; |
switch ( sTypeOf ) |
{ |
case 'number' : |
this.Path = FCKConfig.SkinPath + 'fck_strip.gif' ; |
this.Size = 16 ; |
this.Position = iconPathOrStripInfoArray ; |
break ; |
case 'undefined' : |
this.Path = FCK_SPACER_PATH ; |
break ; |
case 'string' : |
this.Path = iconPathOrStripInfoArray ; |
break ; |
default : |
// It is an array in the format [ StripFilePath, IconSize, IconPosition ] |
this.Path = iconPathOrStripInfoArray[0] ; |
this.Size = iconPathOrStripInfoArray[1] ; |
this.Position = iconPathOrStripInfoArray[2] ; |
} |
} |
FCKIcon.prototype.CreateIconElement = function( document ) |
{ |
var eIcon ; |
if ( this.Position ) // It is using an icons strip image. |
{ |
var sPos = '-' + ( ( this.Position - 1 ) * this.Size ) + 'px' ; |
if ( FCKBrowserInfo.IsIE ) |
{ |
// <div class="TB_Button_Image"><img src="strip.gif" style="top:-16px"></div> |
eIcon = document.createElement( 'DIV' ) ; |
var eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ; |
eIconImage.src = this.Path ; |
eIconImage.style.top = sPos ; |
} |
else |
{ |
// <img class="TB_Button_Image" src="spacer.gif" style="background-position: 0px -16px;background-image: url(strip.gif);"> |
eIcon = document.createElement( 'IMG' ) ; |
eIcon.src = FCK_SPACER_PATH ; |
eIcon.style.backgroundPosition = '0px ' + sPos ; |
eIcon.style.backgroundImage = 'url(' + this.Path + ')' ; |
} |
} |
else // It is using a single icon image. |
{ |
// This is not working well with IE. See notes bellow. |
// <img class="TB_Button_Image" src="smiley.gif"> |
// eIcon = document.createElement( 'IMG' ) ; |
// eIcon.src = this.Path ? this.Path : FCK_SPACER_PATH ; |
// IE makes the button 1px higher if using the <img> directly, so we |
// are changing to the <div> system to clip the image correctly. |
eIcon = document.createElement( 'DIV' ) ; |
var eIconImage = eIcon.appendChild( document.createElement( 'IMG' ) ) ; |
eIconImage.src = this.Path ? this.Path : FCK_SPACER_PATH ; |
} |
eIcon.className = 'TB_Button_Image' ; |
return eIcon ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckstyledef_ie.js |
---|
New file |
0,0 → 1,139 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckstyledef_ie.js |
* FCKStyleDef Class: represents a single stylke definition. (IE specific) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKStyleDef.prototype.ApplyToSelection = function() |
{ |
var oSelection = FCK.ToolbarSet.CurrentInstance.EditorDocument.selection ; |
if ( oSelection.type == 'Text' ) |
{ |
var oRange = oSelection.createRange() ; |
// Create the main element. |
var e = document.createElement( this.Element ) ; |
e.innerHTML = oRange.htmlText ; |
// Set the attributes. |
this._AddAttributes( e ) ; |
// Remove the duplicated elements. |
this._RemoveDuplicates( e ) ; |
// Replace the selection with the resulting HTML. |
oRange.pasteHTML( e.outerHTML ) ; |
} |
else if ( oSelection.type == 'Control' ) |
{ |
var oControl = FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ; |
if ( oControl.tagName == this.Element ) |
this._AddAttributes( oControl ) ; |
} |
} |
FCKStyleDef.prototype._AddAttributes = function( targetElement ) |
{ |
for ( var a in this.Attributes ) |
{ |
switch ( a.toLowerCase() ) |
{ |
case 'style' : |
targetElement.style.cssText = this.Attributes[a] ; |
break ; |
case 'class' : |
targetElement.setAttribute( 'className', this.Attributes[a], 0 ) ; |
break ; |
case 'src' : |
targetElement.setAttribute( '_fcksavedurl', this.Attributes[a], 0 ) ; |
default : |
targetElement.setAttribute( a, this.Attributes[a], 0 ) ; |
} |
} |
} |
FCKStyleDef.prototype._RemoveDuplicates = function( parent ) |
{ |
for ( var i = 0 ; i < parent.children.length ; i++ ) |
{ |
var oChild = parent.children[i] ; |
this._RemoveDuplicates( oChild ) ; |
if ( this.IsEqual( oChild ) ) |
FCKTools.RemoveOuterTags( oChild ) ; |
} |
} |
FCKStyleDef.prototype.IsEqual = function( e ) |
{ |
if ( e.tagName != this.Element ) |
return false ; |
for ( var a in this.Attributes ) |
{ |
switch ( a.toLowerCase() ) |
{ |
case 'style' : |
if ( e.style.cssText.toLowerCase() != this.Attributes[a].toLowerCase() ) |
return false ; |
break ; |
case 'class' : |
if ( e.getAttribute( 'className', 0 ) != this.Attributes[a] ) |
return false ; |
break ; |
default : |
if ( e.getAttribute( a, 0 ) != this.Attributes[a] ) |
return false ; |
} |
} |
return true ; |
} |
FCKStyleDef.prototype._RemoveMe = function( elementToCheck ) |
{ |
if ( ! elementToCheck ) |
return ; |
var oParent = elementToCheck.parentElement ; |
if ( this.IsEqual( elementToCheck ) ) |
{ |
if ( this.IsObjectElement ) |
{ |
for ( var a in this.Attributes ) |
{ |
switch ( a.toLowerCase() ) |
{ |
case 'class' : |
elementToCheck.removeAttribute( 'className', 0 ) ; |
break ; |
default : |
elementToCheck.removeAttribute( a, 0 ) ; |
} |
} |
return ; |
} |
else |
FCKTools.RemoveOuterTags( elementToCheck ) ; |
} |
this._RemoveMe( oParent ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarbuttonui.js |
---|
New file |
0,0 → 1,218 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarbuttonui.js |
* FCKToolbarButtonUI Class: interface representation of a toolbar button. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarButtonUI = function( name, label, tooltip, iconPathOrStripInfoArray, style, state ) |
{ |
this.Name = name ; |
this.Label = label || name ; |
this.Tooltip = tooltip || this.Label ; |
this.Style = style || FCK_TOOLBARITEM_ONLYICON ; |
this.State = state || FCK_TRISTATE_OFF ; |
this.Icon = new FCKIcon( iconPathOrStripInfoArray ) ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKToolbarButtonUI_Cleanup ) ; |
} |
FCKToolbarButtonUI.prototype._CreatePaddingElement = function( document ) |
{ |
var oImg = document.createElement( 'IMG' ) ; |
oImg.className = 'TB_Button_Padding' ; |
oImg.src = FCK_SPACER_PATH ; |
return oImg ; |
} |
FCKToolbarButtonUI.prototype.Create = function( parentElement ) |
{ |
var oMainElement = this.MainElement ; |
if ( oMainElement ) |
{ |
FCKToolbarButtonUI_Cleanup.call(this) ; |
if ( oMainElement.parentNode ) |
oMainElement.parentNode.removeChild( oMainElement ) ; |
oMainElement = this.MainElement = null ; |
} |
var oDoc = FCKTools.GetElementDocument( parentElement ) ; |
// Create the Main Element. |
oMainElement = this.MainElement = oDoc.createElement( 'DIV' ) ; |
oMainElement._FCKButton = this ; // IE Memory Leak (Circular reference). |
oMainElement.title = this.Tooltip ; |
// The following will prevent the button from catching the focus. |
if ( FCKBrowserInfo.IsGecko ) |
oMainElement.onmousedown = FCKTools.CancelEvent ; |
this.ChangeState( this.State, true ) ; |
if ( this.Style == FCK_TOOLBARITEM_ONLYICON && !this.ShowArrow ) |
{ |
// <td><div class="TB_Button_On" title="Smiley">{Image}</div></td> |
oMainElement.appendChild( this.Icon.CreateIconElement( oDoc ) ) ; |
} |
else |
{ |
// <td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td>{Image}</td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td> |
// <td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td><img class="TB_Button_Padding"></td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td> |
var oTable = oMainElement.appendChild( oDoc.createElement( 'TABLE' ) ) ; |
oTable.cellPadding = 0 ; |
oTable.cellSpacing = 0 ; |
var oRow = oTable.insertRow(-1) ; |
// The Image cell (icon or padding). |
var oCell = oRow.insertCell(-1) ; |
if ( this.Style == FCK_TOOLBARITEM_ONLYICON || this.Style == FCK_TOOLBARITEM_ICONTEXT ) |
oCell.appendChild( this.Icon.CreateIconElement( oDoc ) ) ; |
else |
oCell.appendChild( this._CreatePaddingElement( oDoc ) ) ; |
if ( this.Style == FCK_TOOLBARITEM_ONLYTEXT || this.Style == FCK_TOOLBARITEM_ICONTEXT ) |
{ |
// The Text cell. |
oCell = oRow.insertCell(-1) ; |
oCell.className = 'TB_Button_Text' ; |
oCell.noWrap = true ; |
oCell.appendChild( oDoc.createTextNode( this.Label ) ) ; |
} |
if ( this.ShowArrow ) |
{ |
if ( this.Style != FCK_TOOLBARITEM_ONLYICON ) |
{ |
// A padding cell. |
oRow.insertCell(-1).appendChild( this._CreatePaddingElement( oDoc ) ) ; |
} |
oCell = oRow.insertCell(-1) ; |
var eImg = oCell.appendChild( oDoc.createElement( 'IMG' ) ) ; |
eImg.src = FCKConfig.SkinPath + 'images/toolbar.buttonarrow.gif' ; |
eImg.width = 5 ; |
eImg.height = 3 ; |
} |
// The last padding cell. |
oCell = oRow.insertCell(-1) ; |
oCell.appendChild( this._CreatePaddingElement( oDoc ) ) ; |
} |
parentElement.appendChild( oMainElement ) ; |
} |
FCKToolbarButtonUI.prototype.ChangeState = function( newState, force ) |
{ |
if ( !force && this.State == newState ) |
return ; |
var e = this.MainElement ; |
switch ( parseInt( newState ) ) |
{ |
case FCK_TRISTATE_OFF : |
e.className = 'TB_Button_Off' ; |
e.onmouseover = FCKToolbarButton_OnMouseOverOff ; |
e.onmouseout = FCKToolbarButton_OnMouseOutOff ; |
e.onclick = FCKToolbarButton_OnClick ; |
break ; |
case FCK_TRISTATE_ON : |
e.className = 'TB_Button_On' ; |
e.onmouseover = FCKToolbarButton_OnMouseOverOn ; |
e.onmouseout = FCKToolbarButton_OnMouseOutOn ; |
e.onclick = FCKToolbarButton_OnClick ; |
break ; |
case FCK_TRISTATE_DISABLED : |
e.className = 'TB_Button_Disabled' ; |
e.onmouseover = null ; |
e.onmouseout = null ; |
e.onclick = null ; |
bEnableEvents = false ; |
break ; |
} |
this.State = newState ; |
} |
function FCKToolbarButtonUI_Cleanup() |
{ |
if ( this.MainElement ) |
{ |
this.MainElement._FCKButton = null ; |
this.MainElement = null ; |
} |
} |
// Event Handlers. |
function FCKToolbarButton_OnMouseOverOn() |
{ |
this.className = 'TB_Button_On_Over' ; |
} |
function FCKToolbarButton_OnMouseOutOn() |
{ |
this.className = 'TB_Button_On' ; |
} |
function FCKToolbarButton_OnMouseOverOff() |
{ |
this.className = 'TB_Button_Off_Over' ; |
} |
function FCKToolbarButton_OnMouseOutOff() |
{ |
this.className = 'TB_Button_Off' ; |
} |
function FCKToolbarButton_OnClick( e ) |
{ |
if ( this._FCKButton.OnClick ) |
this._FCKButton.OnClick( this._FCKButton ) ; |
} |
/* |
Sample outputs: |
This is the base structure. The variation is the image that is marked as {Image}: |
<td><div class="TB_Button_On" title="Smiley">{Image}</div></td> |
<td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td>{Image}</td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td> |
<td><div class="TB_Button_On" title="Smiley"><table cellpadding="0" cellspacing="0"><tr><td><img class="TB_Button_Padding"></td><td nowrap>Toolbar Button</td><td><img class="TB_Button_Padding"></td></tr></table></div></td> |
These are samples of possible {Image} values: |
Strip - IE version: |
<div class="TB_Button_Image"><img src="strip.gif" style="top:-16px"></div> |
Strip : Firefox, Safari and Opera version |
<img class="TB_Button_Image" style="background-position: 0px -16px;background-image: url(strip.gif);"> |
No-Strip : Browser independent: |
<img class="TB_Button_Image" src="smiley.gif"> |
*/ |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarfontscombo.js |
---|
New file |
0,0 → 1,43 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarfontscombo.js |
* FCKToolbarPanelButton Class: Handles the Fonts combo selector. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarFontsCombo = function( tooltip, style ) |
{ |
this.CommandName = 'FontName' ; |
this.Label = this.GetLabel() ; |
this.Tooltip = tooltip ? tooltip : this.Label ; |
this.Style = style ? style : FCK_TOOLBARITEM_ICONTEXT ; |
} |
// Inherit from FCKToolbarSpecialCombo. |
FCKToolbarFontsCombo.prototype = new FCKToolbarSpecialCombo ; |
FCKToolbarFontsCombo.prototype.GetLabel = function() |
{ |
return FCKLang.Font ; |
} |
FCKToolbarFontsCombo.prototype.CreateItems = function( targetSpecialCombo ) |
{ |
var aFonts = FCKConfig.FontNames.split(';') ; |
for ( var i = 0 ; i < aFonts.length ; i++ ) |
this._Combo.AddItem( aFonts[i], '<font face="' + aFonts[i] + '" style="font-size: 12px">' + aFonts[i] + '</font>' ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckplugin.js |
---|
New file |
0,0 → 1,52 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckplugin.js |
* FCKPlugin Class: Represents a single plugin. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKPlugin = function( name, availableLangs, basePath ) |
{ |
this.Name = name ; |
this.BasePath = basePath ? basePath : FCKConfig.PluginsPath ; |
this.Path = this.BasePath + name + '/' ; |
if ( !availableLangs || availableLangs.length == 0 ) |
this.AvailableLangs = new Array() ; |
else |
this.AvailableLangs = availableLangs.split(',') ; |
} |
FCKPlugin.prototype.Load = function() |
{ |
// Load the language file, if defined. |
if ( this.AvailableLangs.length > 0 ) |
{ |
var sLang ; |
// Check if the plugin has the language file for the active language. |
if ( this.AvailableLangs.indexOf( FCKLanguageManager.ActiveLanguage.Code ) >= 0 ) |
sLang = FCKLanguageManager.ActiveLanguage.Code ; |
else |
// Load the default language file (first one) if the current one is not available. |
sLang = this.AvailableLangs[0] ; |
// Add the main plugin script. |
LoadScript( this.Path + 'lang/' + sLang + '.js' ) ; |
} |
// Add the main plugin script. |
LoadScript( this.Path + 'fckplugin.js' ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarbutton.js |
---|
New file |
0,0 → 1,70 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarbutton.js |
* FCKToolbarButton Class: represents a button in the toolbar. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarButton = function( commandName, label, tooltip, style, sourceView, contextSensitive, icon ) |
{ |
this.CommandName = commandName ; |
this.Label = label ; |
this.Tooltip = tooltip ; |
this.Style = style ; |
this.SourceView = sourceView ? true : false ; |
this.ContextSensitive = contextSensitive ? true : false ; |
if ( icon == null ) |
this.IconPath = FCKConfig.SkinPath + 'toolbar/' + commandName.toLowerCase() + '.gif' ; |
else if ( typeof( icon ) == 'number' ) |
this.IconPath = [ FCKConfig.SkinPath + 'fck_strip.gif', 16, icon ] ; |
} |
FCKToolbarButton.prototype.Create = function( targetElement ) |
{ |
this._UIButton = new FCKToolbarButtonUI( this.CommandName, this.Label, this.Tooltip, this.IconPath, this.Style ) ; |
this._UIButton.OnClick = this.Click ; |
this._UIButton._ToolbarButton = this ; |
this._UIButton.Create( targetElement ) ; |
} |
FCKToolbarButton.prototype.RefreshState = function() |
{ |
// Gets the actual state. |
var eState = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetState() ; |
// If there are no state changes than do nothing and return. |
if ( eState == this._UIButton.State ) return ; |
// Sets the actual state. |
this._UIButton.ChangeState( eState ) ; |
} |
FCKToolbarButton.prototype.Click = function() |
{ |
var oToolbarButton = this._ToolbarButton || this ; |
FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( oToolbarButton.CommandName ).Execute() ; |
} |
FCKToolbarButton.prototype.Enable = function() |
{ |
this.RefreshState() ; |
} |
FCKToolbarButton.prototype.Disable = function() |
{ |
// Sets the actual state. |
this._UIButton.ChangeState( FCK_TRISTATE_DISABLED ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckpanel.js |
---|
New file |
0,0 → 1,295 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckpanel.js |
* Component that creates floating panels. It is used by many |
* other components, like the toolbar items, context menu, etc... |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKPanel = function( parentWindow ) |
{ |
this.IsRTL = ( FCKLang.Dir == 'rtl' ) ; |
this.IsContextMenu = false ; |
this._LockCounter = 0 ; |
this._Window = parentWindow || window ; |
var oDocument ; |
if ( FCKBrowserInfo.IsIE ) |
{ |
// Create the Popup that will hold the panel. |
this._Popup = this._Window.createPopup() ; |
oDocument = this.Document = this._Popup.document ; |
} |
else |
{ |
var oIFrame = this._IFrame = this._Window.document.createElement('iframe') ; |
oIFrame.src = 'javascript:void(0)' ; |
oIFrame.allowTransparency = true ; |
oIFrame.frameBorder = '0' ; |
oIFrame.scrolling = 'no' ; |
oIFrame.style.position = 'absolute'; |
oIFrame.style.zIndex = FCKConfig.FloatingPanelsZIndex ; |
oIFrame.width = oIFrame.height = 0 ; |
if ( this._Window == window.parent && window.frameElement ) |
window.frameElement.parentNode.insertBefore( oIFrame, window.frameElement ) ; |
else |
this._Window.document.body.appendChild( oIFrame ) ; |
var oIFrameWindow = oIFrame.contentWindow ; |
oDocument = this.Document = oIFrameWindow.document ; |
// Initialize the IFRAME document body. |
oDocument.open() ; |
oDocument.write( '<html><head></head><body style="margin:0px;padding:0px;"><\/body><\/html>' ) ; |
oDocument.close() ; |
FCKTools.AddEventListenerEx( oIFrameWindow, 'focus', FCKPanel_Window_OnFocus, this ) ; |
FCKTools.AddEventListenerEx( oIFrameWindow, 'blur', FCKPanel_Window_OnBlur, this ) ; |
} |
oDocument.dir = FCKLang.Dir ; |
oDocument.oncontextmenu = FCKTools.CancelEvent ; |
// Create the main DIV that is used as the panel base. |
this.MainNode = oDocument.body.appendChild( oDocument.createElement('DIV') ) ; |
// The "float" property must be set so Firefox calculates the size correcly. |
this.MainNode.style.cssFloat = this.IsRTL ? 'right' : 'left' ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKPanel_Cleanup ) ; |
} |
FCKPanel.prototype.AppendStyleSheet = function( styleSheet ) |
{ |
FCKTools.AppendStyleSheet( this.Document, styleSheet ) ; |
} |
FCKPanel.prototype.Preload = function( x, y, relElement ) |
{ |
// The offsetWidth and offsetHeight properties are not available if the |
// element is not visible. So we must "show" the popup with no size to |
// be able to use that values in the second call (IE only). |
if ( this._Popup ) |
this._Popup.show( x, y, 0, 0, relElement ) ; |
} |
FCKPanel.prototype.Show = function( x, y, relElement, width, height ) |
{ |
if ( this._Popup ) |
{ |
// The offsetWidth and offsetHeight properties are not available if the |
// element is not visible. So we must "show" the popup with no size to |
// be able to use that values in the second call. |
this._Popup.show( x, y, 0, 0, relElement ) ; |
// The following lines must be place after the above "show", otherwise it |
// doesn't has the desired effect. |
this.MainNode.style.width = width ? width + 'px' : '' ; |
this.MainNode.style.height = height ? height + 'px' : '' ; |
var iMainWidth = this.MainNode.offsetWidth ; |
if ( this.IsRTL ) |
{ |
if ( this.IsContextMenu ) |
x = x - iMainWidth + 1 ; |
else if ( relElement ) |
x = ( x * -1 ) + relElement.offsetWidth - iMainWidth ; |
} |
// Second call: Show the Popup at the specified location, with the correct size. |
this._Popup.show( x, y, iMainWidth, this.MainNode.offsetHeight, relElement ) ; |
if ( this.OnHide ) |
{ |
if ( this._Timer ) |
CheckPopupOnHide.call( this, true ) ; |
this._Timer = FCKTools.SetInterval( CheckPopupOnHide, 100, this ) ; |
} |
} |
else |
{ |
// Do not fire OnBlur while the panel is opened. |
if ( typeof( FCKFocusManager ) != 'undefined' ) |
FCKFocusManager.Lock() ; |
if ( this.ParentPanel ) |
this.ParentPanel.Lock() ; |
this.MainNode.style.width = width ? width + 'px' : '' ; |
this.MainNode.style.height = height ? height + 'px' : '' ; |
var iMainWidth = this.MainNode.offsetWidth ; |
if ( !width ) this._IFrame.width = 1 ; |
if ( !height ) this._IFrame.height = 1 ; |
// This is weird... but with Firefox, we must get the offsetWidth before |
// setting the _IFrame size (which returns "0"), and then after that, |
// to return the correct width. Remove the first step and it will not |
// work when the editor is in RTL. |
iMainWidth = this.MainNode.offsetWidth ; |
var oPos = FCKTools.GetElementPosition( ( relElement.nodeType == 9 ? relElement.body : relElement), this._Window ) ; |
if ( this.IsRTL && !this.IsContextMenu ) |
x = ( x * -1 ) ; |
x += oPos.X ; |
y += oPos.Y ; |
if ( this.IsRTL ) |
{ |
if ( this.IsContextMenu ) |
x = x - iMainWidth + 1 ; |
else if ( relElement ) |
x = x + relElement.offsetWidth - iMainWidth ; |
} |
else |
{ |
var oViewPaneSize = FCKTools.GetViewPaneSize( this._Window ) ; |
var oScrollPosition = FCKTools.GetScrollPosition( this._Window ) ; |
var iViewPaneHeight = oViewPaneSize.Height + oScrollPosition.Y ; |
var iViewPaneWidth = oViewPaneSize.Width + oScrollPosition.X ; |
if ( ( x + iMainWidth ) > iViewPaneWidth ) |
x -= x + iMainWidth - iViewPaneWidth ; |
if ( ( y + this.MainNode.offsetHeight ) > iViewPaneHeight ) |
y -= y + this.MainNode.offsetHeight - iViewPaneHeight ; |
} |
if ( x < 0 ) |
x = 0 ; |
// Set the context menu DIV in the specified location. |
this._IFrame.style.left = x + 'px' ; |
this._IFrame.style.top = y + 'px' ; |
var iWidth = iMainWidth ; |
var iHeight = this.MainNode.offsetHeight ; |
this._IFrame.width = iWidth ; |
this._IFrame.height = iHeight ; |
// Move the focus to the IFRAME so we catch the "onblur". |
this._IFrame.contentWindow.focus() ; |
} |
this._IsOpened = true ; |
FCKTools.RunFunction( this.OnShow, this ) ; |
} |
FCKPanel.prototype.Hide = function( ignoreOnHide ) |
{ |
if ( this._Popup ) |
this._Popup.hide() ; |
else |
{ |
if ( !this._IsOpened ) |
return ; |
// Enable the editor to fire the "OnBlur". |
if ( typeof( FCKFocusManager ) != 'undefined' ) |
FCKFocusManager.Unlock() ; |
// It is better to set the sizes to 0, otherwise Firefox would have |
// rendering problems. |
this._IFrame.width = this._IFrame.height = 0 ; |
this._IsOpened = false ; |
if ( this.ParentPanel ) |
this.ParentPanel.Unlock() ; |
if ( !ignoreOnHide ) |
FCKTools.RunFunction( this.OnHide, this ) ; |
} |
} |
FCKPanel.prototype.CheckIsOpened = function() |
{ |
if ( this._Popup ) |
return this._Popup.isOpen ; |
else |
return this._IsOpened ; |
} |
FCKPanel.prototype.CreateChildPanel = function() |
{ |
var oWindow = this._Popup ? FCKTools.GetParentWindow( this.Document ) : this._Window ; |
var oChildPanel = new FCKPanel( oWindow, true ) ; |
oChildPanel.ParentPanel = this ; |
return oChildPanel ; |
} |
FCKPanel.prototype.Lock = function() |
{ |
this._LockCounter++ ; |
} |
FCKPanel.prototype.Unlock = function() |
{ |
if ( --this._LockCounter == 0 && !this.HasFocus ) |
this.Hide() ; |
} |
/* Events */ |
function FCKPanel_Window_OnFocus( e, panel ) |
{ |
panel.HasFocus = true ; |
} |
function FCKPanel_Window_OnBlur( e, panel ) |
{ |
panel.HasFocus = false ; |
if ( panel._LockCounter == 0 ) |
FCKTools.RunFunction( panel.Hide, panel ) ; |
} |
function CheckPopupOnHide( forceHide ) |
{ |
if ( forceHide || !this._Popup.isOpen ) |
{ |
window.clearInterval( this._Timer ) ; |
this._Timer = null ; |
FCKTools.RunFunction( this.OnHide, this ) ; |
} |
} |
function FCKPanel_Cleanup() |
{ |
this._Popup = null ; |
this._Window = null ; |
this.Document = null ; |
this.MainNode = null ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckmenublockpanel.js |
---|
New file |
0,0 → 1,51 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckmenublockpanel.js |
* This class is a menu block that behaves like a panel. It's a mix of the |
* FCKMenuBlock and FCKPanel classes. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKMenuBlockPanel = function() |
{ |
// Call the "base" constructor. |
FCKMenuBlock.call( this ) ; |
} |
FCKMenuBlockPanel.prototype = new FCKMenuBlock() ; |
// Override the create method. |
FCKMenuBlockPanel.prototype.Create = function() |
{ |
var oPanel = this.Panel = ( this.Parent && this.Parent.Panel ? this.Parent.Panel.CreateChildPanel() : new FCKPanel() ) ; |
oPanel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ; |
// Call the "base" implementation. |
FCKMenuBlock.prototype.Create.call( this, oPanel.MainNode ) ; |
} |
FCKMenuBlockPanel.prototype.Show = function( x, y, relElement ) |
{ |
if ( !this.Panel.CheckIsOpened() ) |
this.Panel.Show( x, y, relElement ) ; |
} |
FCKMenuBlockPanel.prototype.Hide = function() |
{ |
if ( this.Panel.CheckIsOpened() ) |
this.Panel.Hide() ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckspecialcombo.js |
---|
New file |
0,0 → 1,351 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckspecialcombo.js |
* FCKSpecialCombo Class: represents a special combo. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKSpecialCombo = function( caption, fieldWidth, panelWidth, panelMaxHeight, parentWindow ) |
{ |
// Default properties values. |
this.FieldWidth = fieldWidth || 100 ; |
this.PanelWidth = panelWidth || 150 ; |
this.PanelMaxHeight = panelMaxHeight || 150 ; |
this.Label = ' ' ; |
this.Caption = caption ; |
this.Tooltip = caption ; |
this.Style = FCK_TOOLBARITEM_ICONTEXT ; |
this.Enabled = true ; |
this.Items = new Object() ; |
this._Panel = new FCKPanel( parentWindow || window, true ) ; |
this._Panel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ; |
this._PanelBox = this._Panel.MainNode.appendChild( this._Panel.Document.createElement( 'DIV' ) ) ; |
this._PanelBox.className = 'SC_Panel' ; |
this._PanelBox.style.width = this.PanelWidth + 'px' ; |
this._PanelBox.innerHTML = '<table cellpadding="0" cellspacing="0" width="100%" style="TABLE-LAYOUT: fixed"><tr><td nowrap></td></tr></table>' ; |
this._ItemsHolderEl = this._PanelBox.getElementsByTagName('TD')[0] ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKSpecialCombo_Cleanup ) ; |
// this._Panel.StyleSheet = FCKConfig.SkinPath + 'fck_contextmenu.css' ; |
// this._Panel.Create() ; |
// this._Panel.PanelDiv.className += ' SC_Panel' ; |
// this._Panel.PanelDiv.innerHTML = '<table cellpadding="0" cellspacing="0" width="100%" style="TABLE-LAYOUT: fixed"><tr><td nowrap></td></tr></table>' ; |
// this._ItemsHolderEl = this._Panel.PanelDiv.getElementsByTagName('TD')[0] ; |
} |
function FCKSpecialCombo_ItemOnMouseOver() |
{ |
this.className += ' SC_ItemOver' ; |
} |
function FCKSpecialCombo_ItemOnMouseOut() |
{ |
this.className = this.originalClass ; |
} |
function FCKSpecialCombo_ItemOnClick() |
{ |
this.className = this.originalClass ; |
this.FCKSpecialCombo._Panel.Hide() ; |
this.FCKSpecialCombo.SetLabel( this.FCKItemLabel ) ; |
if ( typeof( this.FCKSpecialCombo.OnSelect ) == 'function' ) |
this.FCKSpecialCombo.OnSelect( this.FCKItemID, this ) ; |
} |
FCKSpecialCombo.prototype.AddItem = function( id, html, label, bgColor ) |
{ |
// <div class="SC_Item" onmouseover="this.className='SC_Item SC_ItemOver';" onmouseout="this.className='SC_Item';"><b>Bold 1</b></div> |
var oDiv = this._ItemsHolderEl.appendChild( this._Panel.Document.createElement( 'DIV' ) ) ; |
oDiv.className = oDiv.originalClass = 'SC_Item' ; |
oDiv.innerHTML = html ; |
oDiv.FCKItemID = id ; |
oDiv.FCKItemLabel = label || id ; |
oDiv.FCKSpecialCombo = this ; |
oDiv.Selected = false ; |
// In IE, the width must be set so the borders are shown correctly when the content overflows. |
if ( FCKBrowserInfo.IsIE ) |
oDiv.style.width = '100%' ; |
if ( bgColor ) |
oDiv.style.backgroundColor = bgColor ; |
oDiv.onmouseover = FCKSpecialCombo_ItemOnMouseOver ; |
oDiv.onmouseout = FCKSpecialCombo_ItemOnMouseOut ; |
oDiv.onclick = FCKSpecialCombo_ItemOnClick ; |
this.Items[ id.toString().toLowerCase() ] = oDiv ; |
return oDiv ; |
} |
FCKSpecialCombo.prototype.SelectItem = function( itemId ) |
{ |
itemId = itemId ? itemId.toString().toLowerCase() : '' ; |
var oDiv = this.Items[ itemId ] ; |
if ( oDiv ) |
{ |
oDiv.className = oDiv.originalClass = 'SC_ItemSelected' ; |
oDiv.Selected = true ; |
} |
} |
FCKSpecialCombo.prototype.SelectItemByLabel = function( itemLabel, setLabel ) |
{ |
for ( var id in this.Items ) |
{ |
var oDiv = this.Items[id] ; |
if ( oDiv.FCKItemLabel == itemLabel ) |
{ |
oDiv.className = oDiv.originalClass = 'SC_ItemSelected' ; |
oDiv.Selected = true ; |
if ( setLabel ) |
this.SetLabel( itemLabel ) ; |
} |
} |
} |
FCKSpecialCombo.prototype.DeselectAll = function( clearLabel ) |
{ |
for ( var i in this.Items ) |
{ |
this.Items[i].className = this.Items[i].originalClass = 'SC_Item' ; |
this.Items[i].Selected = false ; |
} |
if ( clearLabel ) |
this.SetLabel( '' ) ; |
} |
FCKSpecialCombo.prototype.SetLabelById = function( id ) |
{ |
id = id ? id.toString().toLowerCase() : '' ; |
var oDiv = this.Items[ id ] ; |
this.SetLabel( oDiv ? oDiv.FCKItemLabel : '' ) ; |
} |
FCKSpecialCombo.prototype.SetLabel = function( text ) |
{ |
this.Label = text.length == 0 ? ' ' : text ; |
if ( this._LabelEl ) |
this._LabelEl.innerHTML = this.Label ; |
} |
FCKSpecialCombo.prototype.SetEnabled = function( isEnabled ) |
{ |
this.Enabled = isEnabled ; |
this._OuterTable.className = isEnabled ? '' : 'SC_FieldDisabled' ; |
} |
FCKSpecialCombo.prototype.Create = function( targetElement ) |
{ |
var oDoc = FCKTools.GetElementDocument( targetElement ) ; |
var eOuterTable = this._OuterTable = targetElement.appendChild( oDoc.createElement( 'TABLE' ) ) ; |
eOuterTable.cellPadding = 0 ; |
eOuterTable.cellSpacing = 0 ; |
eOuterTable.insertRow(-1) ; |
var sClass ; |
var bShowLabel ; |
switch ( this.Style ) |
{ |
case FCK_TOOLBARITEM_ONLYICON : |
sClass = 'TB_ButtonType_Icon' ; |
bShowLabel = false; |
break ; |
case FCK_TOOLBARITEM_ONLYTEXT : |
sClass = 'TB_ButtonType_Text' ; |
bShowLabel = false; |
break ; |
case FCK_TOOLBARITEM_ICONTEXT : |
bShowLabel = true; |
break ; |
} |
if ( this.Caption && this.Caption.length > 0 && bShowLabel ) |
{ |
var oCaptionCell = eOuterTable.rows[0].insertCell(-1) ; |
oCaptionCell.innerHTML = this.Caption ; |
oCaptionCell.className = 'SC_FieldCaption' ; |
} |
// Create the main DIV element. |
var oField = FCKTools.AppendElement( eOuterTable.rows[0].insertCell(-1), 'div' ) ; |
if ( bShowLabel ) |
{ |
oField.className = 'SC_Field' ; |
oField.style.width = this.FieldWidth + 'px' ; |
oField.innerHTML = '<table width="100%" cellpadding="0" cellspacing="0" style="TABLE-LAYOUT: fixed;"><tbody><tr><td class="SC_FieldLabel"><label> </label></td><td class="SC_FieldButton"> </td></tr></tbody></table>' ; |
this._LabelEl = oField.getElementsByTagName('label')[0] ; // Memory Leak |
this._LabelEl.innerHTML = this.Label ; |
} |
else |
{ |
oField.className = 'TB_Button_Off' ; |
//oField.innerHTML = '<span className="SC_FieldCaption">' + this.Caption + '<table cellpadding="0" cellspacing="0" style="TABLE-LAYOUT: fixed;"><tbody><tr><td class="SC_FieldButton" style="border-left: none;"> </td></tr></tbody></table>' ; |
//oField.innerHTML = '<table cellpadding="0" cellspacing="0" style="TABLE-LAYOUT: fixed;"><tbody><tr><td class="SC_FieldButton" style="border-left: none;"> </td></tr></tbody></table>' ; |
// Gets the correct CSS class to use for the specified style (param). |
oField.innerHTML = '<table title="' + this.Tooltip + '" class="' + sClass + '" cellspacing="0" cellpadding="0" border="0">' + |
'<tr>' + |
//'<td class="TB_Icon"><img src="' + FCKConfig.SkinPath + 'toolbar/' + this.Command.Name.toLowerCase() + '.gif" width="21" height="21"></td>' + |
'<td><img class="TB_Button_Padding" src="' + FCK_SPACER_PATH + '" /></td>' + |
'<td class="TB_Text">' + this.Caption + '</td>' + |
'<td><img class="TB_Button_Padding" src="' + FCK_SPACER_PATH + '" /></td>' + |
'<td class="TB_ButtonArrow"><img src="' + FCKConfig.SkinPath + 'images/toolbar.buttonarrow.gif" width="5" height="3"></td>' + |
'<td><img class="TB_Button_Padding" src="' + FCK_SPACER_PATH + '" /></td>' + |
'</tr>' + |
'</table>' ; |
} |
// Events Handlers |
oField.SpecialCombo = this ; |
oField.onmouseover = FCKSpecialCombo_OnMouseOver ; |
oField.onmouseout = FCKSpecialCombo_OnMouseOut ; |
oField.onclick = FCKSpecialCombo_OnClick ; |
FCKTools.DisableSelection( this._Panel.Document.body ) ; |
} |
function FCKSpecialCombo_Cleanup() |
{ |
this._LabelEl = null ; |
this._OuterTable = null ; |
this._ItemsHolderEl = null ; |
this._PanelBox = null ; |
if ( this.Items ) |
{ |
for ( var key in this.Items ) |
this.Items[key] = null ; |
} |
} |
function FCKSpecialCombo_OnMouseOver() |
{ |
if ( this.SpecialCombo.Enabled ) |
{ |
switch ( this.SpecialCombo.Style ) |
{ |
case FCK_TOOLBARITEM_ONLYICON : |
this.className = 'TB_Button_On_Over'; |
break ; |
case FCK_TOOLBARITEM_ONLYTEXT : |
this.className = 'TB_Button_On_Over'; |
break ; |
case FCK_TOOLBARITEM_ICONTEXT : |
this.className = 'SC_Field SC_FieldOver' ; |
break ; |
} |
} |
} |
function FCKSpecialCombo_OnMouseOut() |
{ |
switch ( this.SpecialCombo.Style ) |
{ |
case FCK_TOOLBARITEM_ONLYICON : |
this.className = 'TB_Button_Off'; |
break ; |
case FCK_TOOLBARITEM_ONLYTEXT : |
this.className = 'TB_Button_Off'; |
break ; |
case FCK_TOOLBARITEM_ICONTEXT : |
this.className='SC_Field' ; |
break ; |
} |
} |
function FCKSpecialCombo_OnClick( e ) |
{ |
// For Mozilla we must stop the event propagation to avoid it hiding |
// the panel because of a click outside of it. |
// if ( e ) |
// { |
// e.stopPropagation() ; |
// FCKPanelEventHandlers.OnDocumentClick( e ) ; |
// } |
var oSpecialCombo = this.SpecialCombo ; |
if ( oSpecialCombo.Enabled ) |
{ |
var oPanel = oSpecialCombo._Panel ; |
var oPanelBox = oSpecialCombo._PanelBox ; |
var oItemsHolder = oSpecialCombo._ItemsHolderEl ; |
var iMaxHeight = oSpecialCombo.PanelMaxHeight ; |
if ( oSpecialCombo.OnBeforeClick ) |
oSpecialCombo.OnBeforeClick( oSpecialCombo ) ; |
// This is a tricky thing. We must call the "Load" function, otherwise |
// it will not be possible to retrieve "oItemsHolder.offsetHeight" (IE only). |
if ( FCKBrowserInfo.IsIE ) |
oPanel.Preload( 0, this.offsetHeight, this ) ; |
if ( oItemsHolder.offsetHeight > iMaxHeight ) |
// { |
oPanelBox.style.height = iMaxHeight + 'px' ; |
// if ( FCKBrowserInfo.IsGecko ) |
// oPanelBox.style.overflow = '-moz-scrollbars-vertical' ; |
// } |
else |
oPanelBox.style.height = '' ; |
// oPanel.PanelDiv.style.width = oSpecialCombo.PanelWidth + 'px' ; |
oPanel.Show( 0, this.offsetHeight, this ) ; |
} |
// return false ; |
} |
/* |
Sample Combo Field HTML output: |
<div class="SC_Field" style="width: 80px;"> |
<table width="100%" cellpadding="0" cellspacing="0" style="table-layout: fixed;"> |
<tbody> |
<tr> |
<td class="SC_FieldLabel"><label> </label></td> |
<td class="SC_FieldButton"> </td> |
</tr> |
</tbody> |
</table> |
</div> |
*/ |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbar.js |
---|
New file |
0,0 → 1,116 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbar.js |
* FCKToolbar Class: represents a toolbar in the toolbarset. It is a group of |
* toolbar items. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbar = function() |
{ |
this.Items = new Array() ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKToolbar_Cleanup ) ; |
} |
FCKToolbar.prototype.AddItem = function( item ) |
{ |
return this.Items[ this.Items.length ] = item ; |
} |
FCKToolbar.prototype.AddButton = function( name, label, tooltip, iconPathOrStripInfoArrayOrIndex, style, state ) |
{ |
if ( typeof( iconPathOrStripInfoArrayOrIndex ) == 'number' ) |
iconPathOrStripInfoArrayOrIndex = [ this.DefaultIconsStrip, this.DefaultIconSize, iconPathOrStripInfoArrayOrIndex ] ; |
var oButton = new FCKToolbarButtonUI( name, label, tooltip, iconPathOrStripInfoArrayOrIndex, style, state ) ; |
oButton._FCKToolbar = this ; |
oButton.OnClick = FCKToolbar_OnItemClick ; |
return this.AddItem( oButton ) ; |
} |
function FCKToolbar_OnItemClick( item ) |
{ |
var oToolbar = item._FCKToolbar ; |
if ( oToolbar.OnItemClick ) |
oToolbar.OnItemClick( oToolbar, item ) ; |
} |
FCKToolbar.prototype.AddSeparator = function() |
{ |
this.AddItem( new FCKToolbarSeparator() ) ; |
} |
FCKToolbar.prototype.Create = function( parentElement ) |
{ |
if ( this.MainElement ) |
{ |
// this._Cleanup() ; |
if ( this.MainElement.parentNode ) |
this.MainElement.parentNode.removeChild( this.MainElement ) ; |
this.MainElement = null ; |
} |
var oDoc = FCKTools.GetElementDocument( parentElement ) ; |
var e = this.MainElement = oDoc.createElement( 'table' ) ; |
e.className = 'TB_Toolbar' ; |
e.style.styleFloat = e.style.cssFloat = ( FCKLang.Dir == 'ltr' ? 'left' : 'right' ) ; |
e.dir = FCKLang.Dir ; |
e.cellPadding = 0 ; |
e.cellSpacing = 0 ; |
this.RowElement = e.insertRow(-1) ; |
// Insert the start cell. |
var eCell ; |
if ( !this.HideStart ) |
{ |
eCell = this.RowElement.insertCell(-1) ; |
eCell.appendChild( oDoc.createElement( 'div' ) ).className = 'TB_Start' ; |
} |
for ( var i = 0 ; i < this.Items.length ; i++ ) |
{ |
this.Items[i].Create( this.RowElement.insertCell(-1) ) ; |
} |
// Insert the ending cell. |
if ( !this.HideEnd ) |
{ |
eCell = this.RowElement.insertCell(-1) ; |
eCell.appendChild( oDoc.createElement( 'div' ) ).className = 'TB_End' ; |
} |
parentElement.appendChild( e ) ; |
} |
function FCKToolbar_Cleanup() |
{ |
this.MainElement = null ; |
this.RowElement = null ; |
} |
var FCKToolbarSeparator = function() |
{} |
FCKToolbarSeparator.prototype.Create = function( parentElement ) |
{ |
FCKTools.AppendElement( parentElement, 'div' ).className = 'TB_Separator' ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarstylecombo.js |
---|
New file |
0,0 → 1,99 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarstylecombo.js |
* FCKToolbarPanelButton Class: Handles the Fonts combo selector. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarStyleCombo = function( tooltip, style ) |
{ |
this.CommandName = 'Style' ; |
this.Label = this.GetLabel() ; |
this.Tooltip = tooltip ? tooltip : this.Label ; |
this.Style = style ? style : FCK_TOOLBARITEM_ICONTEXT ; |
} |
// Inherit from FCKToolbarSpecialCombo. |
FCKToolbarStyleCombo.prototype = new FCKToolbarSpecialCombo ; |
FCKToolbarStyleCombo.prototype.GetLabel = function() |
{ |
return FCKLang.Style ; |
} |
FCKToolbarStyleCombo.prototype.CreateItems = function( targetSpecialCombo ) |
{ |
var oTargetDoc = targetSpecialCombo._Panel.Document ; |
// Add the Editor Area CSS to the panel so the style classes are previewed correctly. |
FCKTools.AppendStyleSheet( oTargetDoc, FCKConfig.ToolbarComboPreviewCSS ) ; |
oTargetDoc.body.className += ' ForceBaseFont' ; |
// For some reason Gecko is blocking inside the "RefreshVisibleItems" function. |
if ( ! FCKBrowserInfo.IsGecko ) |
targetSpecialCombo.OnBeforeClick = this.RefreshVisibleItems ; |
// Add the styles to the special combo. |
var aCommandStyles = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).Styles ; |
for ( var s in aCommandStyles ) |
{ |
var oStyle = aCommandStyles[s] ; |
var oItem ; |
if ( oStyle.IsObjectElement ) |
oItem = targetSpecialCombo.AddItem( s, s ) ; |
else |
oItem = targetSpecialCombo.AddItem( s, oStyle.GetOpenerTag() + s + oStyle.GetCloserTag() ) ; |
oItem.Style = oStyle ; |
} |
} |
FCKToolbarStyleCombo.prototype.RefreshActiveItems = function( targetSpecialCombo ) |
{ |
// Clear the actual selection. |
targetSpecialCombo.DeselectAll() ; |
// Get the active styles. |
var aStyles = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetActiveStyles() ; |
if ( aStyles.length > 0 ) |
{ |
// Select the active styles in the combo. |
for ( var i = 0 ; i < aStyles.length ; i++ ) |
targetSpecialCombo.SelectItem( aStyles[i].Name ) ; |
// Set the combo label to the first style in the collection. |
targetSpecialCombo.SetLabelById( aStyles[0].Name ) ; |
} |
else |
targetSpecialCombo.SetLabel('') ; |
} |
FCKToolbarStyleCombo.prototype.RefreshVisibleItems = function( targetSpecialCombo ) |
{ |
if ( FCKSelection.GetType() == 'Control' ) |
var sTagName = FCKSelection.GetSelectedElement().tagName ; |
for ( var i in targetSpecialCombo.Items ) |
{ |
var oItem = targetSpecialCombo.Items[i] ; |
if ( ( sTagName && oItem.Style.Element == sTagName ) || ( ! sTagName && ! oItem.Style.IsObjectElement ) ) |
oItem.style.display = '' ; |
else |
oItem.style.display = 'none' ; // For some reason Gecko is blocking here. |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarfontsizecombo.js |
---|
New file |
0,0 → 1,48 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarfontsizecombo.js |
* FCKToolbarPanelButton Class: Handles the Fonts combo selector. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarFontSizeCombo = function( tooltip, style ) |
{ |
this.CommandName = 'FontSize' ; |
this.Label = this.GetLabel() ; |
this.Tooltip = tooltip ? tooltip : this.Label ; |
this.Style = style ? style : FCK_TOOLBARITEM_ICONTEXT ; |
} |
// Inherit from FCKToolbarSpecialCombo. |
FCKToolbarFontSizeCombo.prototype = new FCKToolbarSpecialCombo ; |
FCKToolbarFontSizeCombo.prototype.GetLabel = function() |
{ |
return FCKLang.FontSize ; |
} |
FCKToolbarFontSizeCombo.prototype.CreateItems = function( targetSpecialCombo ) |
{ |
targetSpecialCombo.FieldWidth = 70 ; |
var aSizes = FCKConfig.FontSizes.split(';') ; |
for ( var i = 0 ; i < aSizes.length ; i++ ) |
{ |
var aSizeParts = aSizes[i].split('/') ; |
this._Combo.AddItem( aSizeParts[0], '<font size="' + aSizeParts[0] + '">' + aSizeParts[1] + '</font>', aSizeParts[1] ) ; |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckevents.js |
---|
New file |
0,0 → 1,51 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckevents.js |
* FCKEvents Class: used to handle events is a advanced way. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKEvents ; |
FCKEvents = function( eventsOwner ) |
{ |
this.Owner = eventsOwner ; |
this.RegisteredEvents = new Object() ; |
} |
FCKEvents.prototype.AttachEvent = function( eventName, functionPointer ) |
{ |
var aTargets ; |
if ( !( aTargets = this.RegisteredEvents[ eventName ] ) ) |
this.RegisteredEvents[ eventName ] = [ functionPointer ] ; |
else |
aTargets.push( functionPointer ) ; |
} |
FCKEvents.prototype.FireEvent = function( eventName, params ) |
{ |
var bReturnValue = true ; |
var oCalls = this.RegisteredEvents[ eventName ] ; |
if ( oCalls ) |
{ |
for ( var i = 0 ; i < oCalls.length ; i++ ) |
bReturnValue = ( oCalls[ i ]( this.Owner, params ) && bReturnValue ) ; |
} |
return bReturnValue ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckiecleanup.js |
---|
New file |
0,0 → 1,51 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckiecleanup.js |
* FCKIECleanup Class: a generic class used as a tool to remove IE leaks. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKIECleanup = function( attachWindow ) |
{ |
this.Items = new Array() ; |
attachWindow._FCKCleanupObj = this ; |
attachWindow.attachEvent( 'onunload', FCKIECleanup_Cleanup ) ; |
} |
FCKIECleanup.prototype.AddItem = function( dirtyItem, cleanupFunction ) |
{ |
this.Items.push( [ dirtyItem, cleanupFunction ] ) ; |
} |
function FCKIECleanup_Cleanup() |
{ |
var aItems = this._FCKCleanupObj.Items ; |
var iLenght = aItems.length ; |
for ( var i = 0 ; i < iLenght ; i++ ) |
{ |
var oItem = aItems[i] ; |
oItem[1].call( oItem[0] ) ; |
aItems[i] = null ; |
} |
this._FCKCleanupObj = null ; |
if ( CollectGarbage ) |
CollectGarbage() ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckxml_gecko.js |
---|
New file |
0,0 → 1,66 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckxml_gecko.js |
* FCKXml Class: class to load and manipulate XML files. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKXml = function() |
{} |
FCKXml.prototype.LoadUrl = function( urlToCall ) |
{ |
var oFCKXml = this ; |
var oXmlHttp = FCKTools.CreateXmlObject( 'XmlHttp' ) ; |
oXmlHttp.open( "GET", urlToCall, false ) ; |
oXmlHttp.send( null ) ; |
if ( oXmlHttp.status == 200 || oXmlHttp.status == 304 ) |
this.DOMDocument = oXmlHttp.responseXML ; |
else if ( oXmlHttp.status == 0 && oXmlHttp.readyState == 4 ) |
this.DOMDocument = oXmlHttp.responseXML ; |
else |
alert( 'Error loading "' + urlToCall + '"' ) ; |
} |
FCKXml.prototype.SelectNodes = function( xpath, contextNode ) |
{ |
var aNodeArray = new Array(); |
var xPathResult = this.DOMDocument.evaluate( xpath, contextNode ? contextNode : this.DOMDocument, |
this.DOMDocument.createNSResolver(this.DOMDocument.documentElement), XPathResult.ORDERED_NODE_ITERATOR_TYPE, null) ; |
if ( xPathResult ) |
{ |
var oNode = xPathResult.iterateNext() ; |
while( oNode ) |
{ |
aNodeArray[aNodeArray.length] = oNode ; |
oNode = xPathResult.iterateNext(); |
} |
} |
return aNodeArray ; |
} |
FCKXml.prototype.SelectSingleNode = function( xpath, contextNode ) |
{ |
var xPathResult = this.DOMDocument.evaluate( xpath, contextNode ? contextNode : this.DOMDocument, |
this.DOMDocument.createNSResolver(this.DOMDocument.documentElement), 9, null); |
if ( xPathResult && xPathResult.singleNodeValue ) |
return xPathResult.singleNodeValue ; |
else |
return null ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckcontextmenu.js |
---|
New file |
0,0 → 1,123 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckcontextmenu.js |
* FCKContextMenu Class: renders an control a context menu. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKContextMenu = function( parentWindow, mouseClickWindow, langDir ) |
{ |
var oPanel = this._Panel = new FCKPanel( parentWindow, true ) ; |
oPanel.AppendStyleSheet( FCKConfig.SkinPath + 'fck_editor.css' ) ; |
oPanel.IsContextMenu = true ; |
var oMenuBlock = this._MenuBlock = new FCKMenuBlock() ; |
oMenuBlock.Panel = oPanel ; |
oMenuBlock.OnClick = FCKTools.CreateEventListener( FCKContextMenu_MenuBlock_OnClick, this ) ; |
this._Redraw = true ; |
this.SetMouseClickWindow( mouseClickWindow || parentWindow ) ; |
} |
FCKContextMenu.prototype.SetMouseClickWindow = function( mouseClickWindow ) |
{ |
if ( !FCKBrowserInfo.IsIE ) |
{ |
this._Document = mouseClickWindow.document ; |
this._Document.addEventListener( 'contextmenu', FCKContextMenu_Document_OnContextMenu, false ) ; |
} |
} |
FCKContextMenu.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) |
{ |
var oItem = this._MenuBlock.AddItem( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled) ; |
this._Redraw = true ; |
return oItem ; |
} |
FCKContextMenu.prototype.AddSeparator = function() |
{ |
this._MenuBlock.AddSeparator() ; |
this._Redraw = true ; |
} |
FCKContextMenu.prototype.RemoveAllItems = function() |
{ |
this._MenuBlock.RemoveAllItems() ; |
this._Redraw = true ; |
} |
FCKContextMenu.prototype.AttachToElement = function( element ) |
{ |
if ( FCKBrowserInfo.IsIE ) |
FCKTools.AddEventListenerEx( element, 'contextmenu', FCKContextMenu_AttachedElement_OnContextMenu, this ) ; |
else |
element._FCKContextMenu = this ; |
// element.onmouseup = FCKContextMenu_AttachedElement_OnMouseUp ; |
} |
function FCKContextMenu_Document_OnContextMenu( e ) |
{ |
var el = e.target ; |
while ( el ) |
{ |
if ( el._FCKContextMenu ) |
{ |
FCKTools.CancelEvent( e ) ; |
FCKContextMenu_AttachedElement_OnContextMenu( e, el._FCKContextMenu, el ) ; |
} |
el = el.parentNode ; |
} |
} |
function FCKContextMenu_AttachedElement_OnContextMenu( ev, fckContextMenu, el ) |
{ |
// var iButton = e ? e.which - 1 : event.button ; |
// if ( iButton != 2 ) |
// return ; |
var eTarget = el || this ; |
if ( fckContextMenu.OnBeforeOpen ) |
fckContextMenu.OnBeforeOpen.call( fckContextMenu, eTarget ) ; |
if ( fckContextMenu._MenuBlock.Count() == 0 ) |
return false ; |
if ( fckContextMenu._Redraw ) |
{ |
fckContextMenu._MenuBlock.Create( fckContextMenu._Panel.MainNode ) ; |
fckContextMenu._Redraw = false ; |
} |
fckContextMenu._Panel.Show( |
ev.pageX || ev.screenX, |
ev.pageY || ev.screenY, |
ev.currentTarget || null |
) ; |
return false ; |
} |
function FCKContextMenu_MenuBlock_OnClick( menuItem, contextMenu ) |
{ |
contextMenu._Panel.Hide() ; |
FCKTools.RunFunction( contextMenu.OnItemClick, contextMenu, menuItem ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckstylesloader.js |
---|
New file |
0,0 → 1,84 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckstylesloader.js |
* FCKStylesLoader Class: this class define objects that are responsible |
* for loading the styles defined in the XML file. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKStylesLoader = function() |
{ |
this.Styles = new Object() ; |
this.StyleGroups = new Object() ; |
this.Loaded = false ; |
this.HasObjectElements = false ; |
} |
FCKStylesLoader.prototype.Load = function( stylesXmlUrl ) |
{ |
// Load the XML file into a FCKXml object. |
var oXml = new FCKXml() ; |
oXml.LoadUrl( stylesXmlUrl ) ; |
// Get the "Style" nodes defined in the XML file. |
var aStyleNodes = oXml.SelectNodes( 'Styles/Style' ) ; |
// Add each style to our "Styles" collection. |
for ( var i = 0 ; i < aStyleNodes.length ; i++ ) |
{ |
var sElement = aStyleNodes[i].attributes.getNamedItem('element').value.toUpperCase() ; |
// Create the style definition object. |
var oStyleDef = new FCKStyleDef( aStyleNodes[i].attributes.getNamedItem('name').value, sElement ) ; |
if ( oStyleDef.IsObjectElement ) |
this.HasObjectElements = true ; |
// Get the attributes defined for the style (if any). |
var aAttNodes = oXml.SelectNodes( 'Attribute', aStyleNodes[i] ) ; |
// Add the attributes to the style definition object. |
for ( var j = 0 ; j < aAttNodes.length ; j++ ) |
{ |
var sAttName = aAttNodes[j].attributes.getNamedItem('name').value ; |
var sAttValue = aAttNodes[j].attributes.getNamedItem('value').value ; |
// IE changes the "style" attribute value when applied to an element |
// so we must get the final resulting value (for comparision issues). |
if ( sAttName.toLowerCase() == 'style' ) |
{ |
var oTempE = document.createElement( 'SPAN' ) ; |
oTempE.style.cssText = sAttValue ; |
sAttValue = oTempE.style.cssText ; |
} |
oStyleDef.AddAttribute( sAttName, sAttValue ) ; |
} |
// Add the style to the "Styles" collection using it's name as the key. |
this.Styles[ oStyleDef.Name ] = oStyleDef ; |
// Add the style to the "StyleGroups" collection. |
var aGroup = this.StyleGroups[sElement] ; |
if ( aGroup == null ) |
{ |
this.StyleGroups[sElement] = new Array() ; |
aGroup = this.StyleGroups[sElement] ; |
} |
aGroup[aGroup.length] = oStyleDef ; |
} |
this.Loaded = true ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckeditingarea.js |
---|
New file |
0,0 → 1,190 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckeditingarea.js |
* FCKEditingArea Class: renders an editable area. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
/** |
* @constructor |
* @param {String} targetElement The element that will hold the editing area. Any child element present in the target will be deleted. |
*/ |
var FCKEditingArea = function( targetElement ) |
{ |
this.TargetElement = targetElement ; |
this.Mode = FCK_EDITMODE_WYSIWYG ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKEditingArea_Cleanup ) ; |
} |
/** |
* @param {String} html The complete HTML for the page, including DOCTYPE and the <html> tag. |
*/ |
FCKEditingArea.prototype.Start = function( html, secondCall ) |
{ |
var eTargetElement = this.TargetElement ; |
var oTargetDocument = FCKTools.GetElementDocument( eTargetElement ) ; |
// Remove all child nodes from the target. |
while( eTargetElement.childNodes.length > 0 ) |
eTargetElement.removeChild( eTargetElement.childNodes[0] ) ; |
if ( this.Mode == FCK_EDITMODE_WYSIWYG ) |
{ |
if ( FCKBrowserInfo.IsGecko ) |
html = html.replace( /(<body[^>]*>)\s*(<\/body>)/i, '$1' + GECKO_BOGUS + '$2' ) ; |
// Create the editing area IFRAME. |
var oIFrame = this.IFrame = oTargetDocument.createElement( 'iframe' ) ; |
oIFrame.src = 'javascript:void(0)' ; |
oIFrame.frameBorder = 0 ; |
oIFrame.width = oIFrame.height = '100%' ; |
// Append the new IFRAME to the target. |
eTargetElement.appendChild( oIFrame ) ; |
// IE has a bug with the <base> tag... it must have a </base> closer, |
// otherwise the all sucessive tags will be set as children nodes of the <base>. |
if ( FCKBrowserInfo.IsIE ) |
html = html.replace( /(<base[^>]*?)\s*\/?>(?!\s*<\/base>)/gi, '$1></base>' ) ; |
// Get the window and document objects used to interact with the newly created IFRAME. |
this.Window = oIFrame.contentWindow ; |
// IE: Avoid JavaScript errors thrown by the editing are source (like tags events). |
// TODO: This error handler is not being fired. |
// this.Window.onerror = function() { alert( 'Error!' ) ; return true ; } |
var oDoc = this.Document = this.Window.document ; |
oDoc.open() ; |
oDoc.write( html ) ; |
oDoc.close() ; |
// Firefox 1.0.x is buggy... ohh yes... so let's do it two times and it |
// will magicaly work. |
if ( FCKBrowserInfo.IsGecko10 && !secondCall ) |
{ |
this.Start( html, true ) ; |
return ; |
} |
this.Window._FCKEditingArea = this ; |
// FF 1.0.x is buggy... we must wait a lot to enable editing because |
// sometimes the content simply disappears, for example when pasting |
// "bla1!<img src='some_url'>!bla2" in the source and then switching |
// back to design. |
if ( FCKBrowserInfo.IsGecko10 ) |
this.Window.setTimeout( FCKEditingArea_CompleteStart, 500 ) ; |
else |
FCKEditingArea_CompleteStart.call( this.Window ) ; |
} |
else |
{ |
var eTextarea = this.Textarea = oTargetDocument.createElement( 'textarea' ) ; |
eTextarea.className = 'SourceField' ; |
eTextarea.dir = 'ltr' ; |
eTextarea.style.width = eTextarea.style.height = '100%' ; |
eTextarea.style.border = 'none' ; |
eTargetElement.appendChild( eTextarea ) ; |
eTextarea.value = html ; |
// Fire the "OnLoad" event. |
FCKTools.RunFunction( this.OnLoad ) ; |
} |
} |
// "this" here is FCKEditingArea.Window |
function FCKEditingArea_CompleteStart() |
{ |
// Of Firefox, the DOM takes a little to become available. So we must wait for it in a loop. |
if ( !this.document.body ) |
{ |
this.setTimeout( FCKEditingArea_CompleteStart, 50 ) ; |
return ; |
} |
var oEditorArea = this._FCKEditingArea ; |
oEditorArea.MakeEditable() ; |
// Fire the "OnLoad" event. |
FCKTools.RunFunction( oEditorArea.OnLoad ) ; |
} |
FCKEditingArea.prototype.MakeEditable = function() |
{ |
var oDoc = this.Document ; |
if ( FCKBrowserInfo.IsIE ) |
oDoc.body.contentEditable = true ; |
else |
{ |
try |
{ |
oDoc.designMode = 'on' ; |
// Tell Gecko to use or not the <SPAN> tag for the bold, italic and underline. |
oDoc.execCommand( 'useCSS', false, !FCKConfig.GeckoUseSPAN ) ; |
// Analysing Firefox 1.5 source code, it seams that there is support for a |
// "insertBrOnReturn" command. Applying it gives no error, but it doesn't |
// gives the same behavior that you have with IE. It works only if you are |
// already inside a paragraph and it doesn't render correctly in the first enter. |
// oDoc.execCommand( 'insertBrOnReturn', false, false ) ; |
// Tell Gecko (Firefox 1.5+) to enable or not live resizing of objects (by Alfonso Martinez) |
oDoc.execCommand( 'enableObjectResizing', false, !FCKConfig.DisableObjectResizing ) ; |
// Disable the standard table editing features of Firefox. |
oDoc.execCommand( 'enableInlineTableEditing', false, !FCKConfig.DisableFFTableHandles ) ; |
} |
catch (e) {} |
} |
} |
FCKEditingArea.prototype.Focus = function() |
{ |
try |
{ |
if ( this.Mode == FCK_EDITMODE_WYSIWYG ) |
{ |
if ( FCKBrowserInfo.IsSafari ) |
this.IFrame.focus() ; |
else |
this.Window.focus() ; |
} |
else |
this.Textarea.focus() ; |
} |
catch(e) {} |
} |
function FCKEditingArea_Cleanup() |
{ |
this.TargetElement = null ; |
this.IFrame = null ; |
this.Document = null ; |
this.Textarea = null ; |
if ( this.Window ) |
{ |
this.Window._FCKEditingArea = null ; |
this.Window = null ; |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckxml_ie.js |
---|
New file |
0,0 → 1,78 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckxml_ie.js |
* FCKXml Class: class to load and manipulate XML files. |
* (IE specific implementation) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKXml = function() |
{ |
this.Error = false ; |
} |
FCKXml.prototype.LoadUrl = function( urlToCall ) |
{ |
this.Error = false ; |
var oXmlHttp = FCKTools.CreateXmlObject( 'XmlHttp' ) ; |
if ( !oXmlHttp ) |
{ |
this.Error = true ; |
return ; |
} |
oXmlHttp.open( "GET", urlToCall, false ) ; |
oXmlHttp.send( null ) ; |
if ( oXmlHttp.status == 200 || oXmlHttp.status == 304 ) |
this.DOMDocument = oXmlHttp.responseXML ; |
else if ( oXmlHttp.status == 0 && oXmlHttp.readyState == 4 ) |
{ |
this.DOMDocument = FCKTools.CreateXmlObject( 'DOMDocument' ) ; |
this.DOMDocument.async = false ; |
this.DOMDocument.resolveExternals = false ; |
this.DOMDocument.loadXML( oXmlHttp.responseText ) ; |
} |
else |
{ |
this.Error = true ; |
alert( 'Error loading "' + urlToCall + '"' ) ; |
} |
} |
FCKXml.prototype.SelectNodes = function( xpath, contextNode ) |
{ |
if ( this.Error ) |
return new Array() ; |
if ( contextNode ) |
return contextNode.selectNodes( xpath ) ; |
else |
return this.DOMDocument.selectNodes( xpath ) ; |
} |
FCKXml.prototype.SelectSingleNode = function( xpath, contextNode ) |
{ |
if ( this.Error ) |
return ; |
if ( contextNode ) |
return contextNode.selectSingleNode( xpath ) ; |
else |
return this.DOMDocument.selectSingleNode( xpath ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarpanelbutton.js |
---|
New file |
0,0 → 1,87 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarpanelbutton.js |
* FCKToolbarPanelButton Class: represents a special button in the toolbar |
* that shows a panel when pressed. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarPanelButton = function( commandName, label, tooltip, style, icon ) |
{ |
this.CommandName = commandName ; |
var oIcon ; |
if ( icon == null ) |
oIcon = FCKConfig.SkinPath + 'toolbar/' + commandName.toLowerCase() + '.gif' ; |
else if ( typeof( icon ) == 'number' ) |
oIcon = [ FCKConfig.SkinPath + 'fck_strip.gif', 16, icon ] ; |
var oUIButton = this._UIButton = new FCKToolbarButtonUI( commandName, label, tooltip, oIcon, style ) ; |
oUIButton._FCKToolbarPanelButton = this ; |
oUIButton.ShowArrow = true ; |
oUIButton.OnClick = FCKToolbarPanelButton_OnButtonClick ; |
} |
FCKToolbarPanelButton.prototype.TypeName = 'FCKToolbarPanelButton' ; |
FCKToolbarPanelButton.prototype.Create = function( parentElement ) |
{ |
parentElement.className += 'Menu' ; |
this._UIButton.Create( parentElement ) ; |
var oPanel = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName )._Panel ; |
oPanel._FCKToolbarPanelButton = this ; |
var eLineDiv = oPanel.Document.body.appendChild( oPanel.Document.createElement( 'div' ) ) ; |
eLineDiv.style.position = 'absolute' ; |
eLineDiv.style.top = '0px' ; |
var eLine = this.LineImg = eLineDiv.appendChild( oPanel.Document.createElement( 'IMG' ) ) ; |
eLine.className = 'TB_ConnectionLine' ; |
// eLine.style.backgroundColor = 'Red' ; |
eLine.src = FCK_SPACER_PATH ; |
oPanel.OnHide = FCKToolbarPanelButton_OnPanelHide ; |
} |
/* |
Events |
*/ |
function FCKToolbarPanelButton_OnButtonClick( toolbarButton ) |
{ |
var oButton = this._FCKToolbarPanelButton ; |
var e = oButton._UIButton.MainElement ; |
oButton._UIButton.ChangeState( FCK_TRISTATE_ON ) ; |
oButton.LineImg.style.width = ( e.offsetWidth - 2 ) + 'px' ; |
FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( oButton.CommandName ).Execute( 0, e.offsetHeight - 1, e ) ; // -1 to be over the border |
} |
function FCKToolbarPanelButton_OnPanelHide() |
{ |
var oMenuButton = this._FCKToolbarPanelButton ; |
oMenuButton._UIButton.ChangeState( FCK_TRISTATE_OFF ) ; |
} |
// The Panel Button works like a normal button so the refresh state functions |
// defined for the normal button can be reused here. |
FCKToolbarPanelButton.prototype.RefreshState = FCKToolbarButton.prototype.RefreshState ; |
FCKToolbarPanelButton.prototype.Enable = FCKToolbarButton.prototype.Enable ; |
FCKToolbarPanelButton.prototype.Disable = FCKToolbarButton.prototype.Disable ; |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarbreak_gecko.js |
---|
New file |
0,0 → 1,32 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarbreak_gecko.js |
* FCKToolbarBreak Class: breaks the toolbars. |
* It makes it possible to force the toolbar to break to a new line. |
* This is the Gecko specific implementation. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarBreak = function() |
{} |
FCKToolbarBreak.prototype.Create = function( targetElement ) |
{ |
var oBreakDiv = targetElement.ownerDocument.createElement( 'div' ) ; |
oBreakDiv.style.clear = oBreakDiv.style.cssFloat = FCKLang.Dir == 'rtl' ? 'right' : 'left' ; |
targetElement.appendChild( oBreakDiv ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckmenublock.js |
---|
New file |
0,0 → 1,140 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckmenublock.js |
* Renders a list of menu items. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKMenuBlock = function() |
{ |
this._Items = new Array() ; |
} |
FCKMenuBlock.prototype.Count = function() |
{ |
return this._Items.length ; |
} |
FCKMenuBlock.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) |
{ |
var oItem = new FCKMenuItem( this, name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) ; |
oItem.OnClick = FCKTools.CreateEventListener( FCKMenuBlock_Item_OnClick, this ) ; |
oItem.OnActivate = FCKTools.CreateEventListener( FCKMenuBlock_Item_OnActivate, this ) ; |
this._Items.push( oItem ) ; |
return oItem ; |
} |
FCKMenuBlock.prototype.AddSeparator = function() |
{ |
this._Items.push( new FCKMenuSeparator() ) ; |
} |
FCKMenuBlock.prototype.RemoveAllItems = function() |
{ |
this._Items = new Array() ; |
var eItemsTable = this._ItemsTable ; |
if ( eItemsTable ) |
{ |
while ( eItemsTable.rows.length > 0 ) |
eItemsTable.deleteRow( 0 ) ; |
} |
} |
FCKMenuBlock.prototype.Create = function( parentElement ) |
{ |
if ( !this._ItemsTable ) |
{ |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKMenuBlock_Cleanup ) ; |
this._Window = FCKTools.GetElementWindow( parentElement ) ; |
var oDoc = FCKTools.GetElementDocument( parentElement ) ; |
var eTable = parentElement.appendChild( oDoc.createElement( 'table' ) ) ; |
eTable.cellPadding = 0 ; |
eTable.cellSpacing = 0 ; |
FCKTools.DisableSelection( eTable ) ; |
var oMainElement = eTable.insertRow(-1).insertCell(-1) ; |
oMainElement.className = 'MN_Menu' ; |
var eItemsTable = this._ItemsTable = oMainElement.appendChild( oDoc.createElement( 'table' ) ) ; |
eItemsTable.cellPadding = 0 ; |
eItemsTable.cellSpacing = 0 ; |
} |
for ( var i = 0 ; i < this._Items.length ; i++ ) |
this._Items[i].Create( this._ItemsTable ) ; |
} |
/* Events */ |
function FCKMenuBlock_Item_OnClick( clickedItem, menuBlock ) |
{ |
FCKTools.RunFunction( menuBlock.OnClick, menuBlock, [ clickedItem ] ) ; |
} |
function FCKMenuBlock_Item_OnActivate( menuBlock ) |
{ |
var oActiveItem = menuBlock._ActiveItem ; |
if ( oActiveItem && oActiveItem != this ) |
{ |
// Set the focus to this menu block window (to fire OnBlur on opened panels). |
if ( !FCKBrowserInfo.IsIE && oActiveItem.HasSubMenu && !this.HasSubMenu ) |
menuBlock._Window.focus() ; |
oActiveItem.Deactivate() ; |
} |
menuBlock._ActiveItem = this ; |
} |
function FCKMenuBlock_Cleanup() |
{ |
this._Window = null ; |
this._ItemsTable = null ; |
} |
// ################# // |
var FCKMenuSeparator = function() |
{} |
FCKMenuSeparator.prototype.Create = function( parentTable ) |
{ |
var oDoc = FCKTools.GetElementDocument( parentTable ) ; |
var r = parentTable.insertRow(-1) ; |
var eCell = r.insertCell(-1) ; |
eCell.className = 'MN_Separator MN_Icon' ; |
eCell = r.insertCell(-1) ; |
eCell.className = 'MN_Separator' ; |
eCell.appendChild( oDoc.createElement( 'DIV' ) ).className = 'MN_Separator_Line' ; |
eCell = r.insertCell(-1) ; |
eCell.className = 'MN_Separator' ; |
eCell.appendChild( oDoc.createElement( 'DIV' ) ).className = 'MN_Separator_Line' ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckstyledef.js |
---|
New file |
0,0 → 1,55 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckstyledef.js |
* FCKStyleDef Class: represents a single style definition. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKStyleDef = function( name, element ) |
{ |
this.Name = name ; |
this.Element = element.toUpperCase() ; |
this.IsObjectElement = FCKRegexLib.ObjectElements.test( this.Element ) ; |
this.Attributes = new Object() ; |
} |
FCKStyleDef.prototype.AddAttribute = function( name, value ) |
{ |
this.Attributes[ name ] = value ; |
} |
FCKStyleDef.prototype.GetOpenerTag = function() |
{ |
var s = '<' + this.Element ; |
for ( var a in this.Attributes ) |
s += ' ' + a + '="' + this.Attributes[a] + '"' ; |
return s + '>' ; |
} |
FCKStyleDef.prototype.GetCloserTag = function() |
{ |
return '</' + this.Element + '>' ; |
} |
FCKStyleDef.prototype.RemoveFromSelection = function() |
{ |
if ( FCKSelection.GetType() == 'Control' ) |
this._RemoveMe( FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ) ; |
else |
this._RemoveMe( FCK.ToolbarSet.CurrentInstance.Selection.GetParentElement() ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarfontformatcombo.js |
---|
New file |
0,0 → 1,102 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarfontformatcombo.js |
* FCKToolbarPanelButton Class: Handles the Fonts combo selector. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarFontFormatCombo = function( tooltip, style ) |
{ |
this.CommandName = 'FontFormat' ; |
this.Label = this.GetLabel() ; |
this.Tooltip = tooltip ? tooltip : this.Label ; |
this.Style = style ? style : FCK_TOOLBARITEM_ICONTEXT ; |
this.NormalLabel = 'Normal' ; |
this.PanelWidth = 190 ; |
} |
// Inherit from FCKToolbarSpecialCombo. |
FCKToolbarFontFormatCombo.prototype = new FCKToolbarSpecialCombo ; |
FCKToolbarFontFormatCombo.prototype.GetLabel = function() |
{ |
return FCKLang.FontFormat ; |
} |
FCKToolbarFontFormatCombo.prototype.CreateItems = function( targetSpecialCombo ) |
{ |
// Add the Editor Area CSS to the panel to create a realistic preview. |
FCKTools.AppendStyleSheet( targetSpecialCombo._Panel.Document, FCKConfig.ToolbarComboPreviewCSS ) ; |
// Get the format names from the language file. |
var aNames = FCKLang['FontFormats'].split(';') ; |
var oNames = { |
p : aNames[0], |
pre : aNames[1], |
address : aNames[2], |
h1 : aNames[3], |
h2 : aNames[4], |
h3 : aNames[5], |
h4 : aNames[6], |
h5 : aNames[7], |
h6 : aNames[8], |
div : aNames[9] |
} ; |
// Get the available formats from the configuration file. |
var aTags = FCKConfig.FontFormats.split(';') ; |
for ( var i = 0 ; i < aTags.length ; i++ ) |
{ |
// Support for DIV in Firefox has been reintroduced on version 2.2. |
// if ( aTags[i] == 'div' && FCKBrowserInfo.IsGecko ) |
// continue ; |
var sTag = aTags[i] ; |
var sLabel = oNames[sTag] ; |
if ( sTag == 'p' ) |
this.NormalLabel = sLabel ; |
this._Combo.AddItem( sTag, '<div class="BaseFont"><' + sTag + '>' + sLabel + '</' + sTag + '></div>', sLabel ) ; |
} |
} |
if ( FCKBrowserInfo.IsIE ) |
{ |
FCKToolbarFontFormatCombo.prototype.RefreshActiveItems = function( combo, value ) |
{ |
// FCKDebug.Output( 'FCKToolbarFontFormatCombo Value: ' + value ) ; |
// IE returns normal for DIV and P, so to avoid confusion, we will not show it if normal. |
if ( value == this.NormalLabel ) |
{ |
if ( combo.Label != ' ' ) |
combo.DeselectAll(true) ; |
} |
else |
{ |
if ( this._LastValue == value ) |
return ; |
combo.SelectItemByLabel( value, true ) ; |
} |
this._LastValue = value ; |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckmenuitem.js |
---|
New file |
0,0 → 1,157 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckmenuitem.js |
* Defines and renders a menu items in a menu block. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKMenuItem = function( parentMenuBlock, name, label, iconPathOrStripInfoArray, isDisabled ) |
{ |
this.Name = name ; |
this.Label = label || name ; |
this.IsDisabled = isDisabled ; |
this.Icon = new FCKIcon( iconPathOrStripInfoArray ) ; |
this.SubMenu = new FCKMenuBlockPanel() ; |
this.SubMenu.Parent = parentMenuBlock ; |
this.SubMenu.OnClick = FCKTools.CreateEventListener( FCKMenuItem_SubMenu_OnClick, this ) ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKMenuItem_Cleanup ) ; |
} |
FCKMenuItem.prototype.AddItem = function( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) |
{ |
this.HasSubMenu = true ; |
return this.SubMenu.AddItem( name, label, iconPathOrStripInfoArrayOrIndex, isDisabled ) ; |
} |
FCKMenuItem.prototype.AddSeparator = function() |
{ |
this.SubMenu.AddSeparator() ; |
} |
FCKMenuItem.prototype.Create = function( parentTable ) |
{ |
var bHasSubMenu = this.HasSubMenu ; |
var oDoc = FCKTools.GetElementDocument( parentTable ) ; |
// Add a row in the table to hold the menu item. |
var r = this.MainElement = parentTable.insertRow(-1) ; |
r.className = this.IsDisabled ? 'MN_Item_Disabled' : 'MN_Item' ; |
// Set the row behavior. |
if ( !this.IsDisabled ) |
{ |
FCKTools.AddEventListenerEx( r, 'mouseover', FCKMenuItem_OnMouseOver, [ this ] ) ; |
FCKTools.AddEventListenerEx( r, 'click', FCKMenuItem_OnClick, [ this ] ) ; |
if ( !bHasSubMenu ) |
FCKTools.AddEventListenerEx( r, 'mouseout', FCKMenuItem_OnMouseOut, [ this ] ) ; |
} |
// Create the icon cell. |
var eCell = r.insertCell(-1) ; |
eCell.className = 'MN_Icon' ; |
eCell.appendChild( this.Icon.CreateIconElement( oDoc ) ) ; |
// Create the label cell. |
eCell = r.insertCell(-1) ; |
eCell.className = 'MN_Label' ; |
eCell.noWrap = true ; |
eCell.appendChild( oDoc.createTextNode( this.Label ) ) ; |
// Create the arrow cell and setup the sub menu panel (if needed). |
eCell = r.insertCell(-1) ; |
if ( bHasSubMenu ) |
{ |
eCell.className = 'MN_Arrow' ; |
// The arrow is a fixed size image. |
var eArrowImg = eCell.appendChild( oDoc.createElement( 'IMG' ) ) ; |
eArrowImg.src = FCK_IMAGES_PATH + 'arrow_' + FCKLang.Dir + '.gif' ; |
eArrowImg.width = 4 ; |
eArrowImg.height = 7 ; |
this.SubMenu.Create() ; |
this.SubMenu.Panel.OnHide = FCKTools.CreateEventListener( FCKMenuItem_SubMenu_OnHide, this ) ; |
} |
} |
FCKMenuItem.prototype.Activate = function() |
{ |
this.MainElement.className = 'MN_Item_Over' ; |
if ( this.HasSubMenu ) |
{ |
// Show the child menu block. The ( +2, -2 ) correction is done because |
// of the padding in the skin. It is not a good solution because one |
// could change the skin and so the final result would not be accurate. |
// For now it is ok because we are controlling the skin. |
this.SubMenu.Show( this.MainElement.offsetWidth + 2, -2, this.MainElement ) ; |
} |
FCKTools.RunFunction( this.OnActivate, this ) ; |
} |
FCKMenuItem.prototype.Deactivate = function() |
{ |
this.MainElement.className = 'MN_Item' ; |
if ( this.HasSubMenu ) |
this.SubMenu.Hide() ; |
} |
/* Events */ |
function FCKMenuItem_SubMenu_OnClick( clickedItem, listeningItem ) |
{ |
FCKTools.RunFunction( listeningItem.OnClick, listeningItem, [ clickedItem ] ) ; |
} |
function FCKMenuItem_SubMenu_OnHide( menuItem ) |
{ |
menuItem.Deactivate() ; |
} |
function FCKMenuItem_OnClick( ev, menuItem ) |
{ |
if ( menuItem.HasSubMenu ) |
menuItem.Activate() ; |
else |
{ |
menuItem.Deactivate() ; |
FCKTools.RunFunction( menuItem.OnClick, menuItem, [ menuItem ] ) ; |
} |
} |
function FCKMenuItem_OnMouseOver( ev, menuItem ) |
{ |
menuItem.Activate() ; |
} |
function FCKMenuItem_OnMouseOut( ev, menuItem ) |
{ |
menuItem.Deactivate() ; |
} |
function FCKMenuItem_Cleanup() |
{ |
this.MainElement = null ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarspecialcombo.js |
---|
New file |
0,0 → 1,129 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarspecialcombo.js |
* FCKToolbarSpecialCombo Class: This is a "abstract" base class to be used |
* by the special combo toolbar elements like font name, font size, paragraph format, etc... |
* |
* The following properties and methods must be implemented when inheriting from |
* this class: |
* - Property: CommandName [ The command name to be executed ] |
* - Method: GetLabel() [ Returns the label ] |
* - CreateItems( targetSpecialCombo ) [ Add all items in the special combo ] |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarSpecialCombo = function() |
{ |
this.SourceView = false ; |
this.ContextSensitive = true ; |
} |
function FCKToolbarSpecialCombo_OnSelect( itemId, item ) |
{ |
FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).Execute( itemId, item ) ; |
} |
FCKToolbarSpecialCombo.prototype.Create = function( targetElement ) |
{ |
this._Combo = new FCKSpecialCombo( this.GetLabel(), this.FieldWidth, this.PanelWidth, this.PanelMaxHeight, FCKBrowserInfo.IsIE ? window : FCKTools.GetElementWindow( targetElement ).parent ) ; |
/* |
this._Combo.FieldWidth = this.FieldWidth != null ? this.FieldWidth : 100 ; |
this._Combo.PanelWidth = this.PanelWidth != null ? this.PanelWidth : 150 ; |
this._Combo.PanelMaxHeight = this.PanelMaxHeight != null ? this.PanelMaxHeight : 150 ; |
*/ |
//this._Combo.Command.Name = this.Command.Name; |
// this._Combo.Label = this.Label ; |
this._Combo.Tooltip = this.Tooltip ; |
this._Combo.Style = this.Style ; |
this.CreateItems( this._Combo ) ; |
this._Combo.Create( targetElement ) ; |
this._Combo.CommandName = this.CommandName ; |
this._Combo.OnSelect = FCKToolbarSpecialCombo_OnSelect ; |
} |
function FCKToolbarSpecialCombo_RefreshActiveItems( combo, value ) |
{ |
combo.DeselectAll() ; |
combo.SelectItem( value ) ; |
combo.SetLabelById( value ) ; |
} |
FCKToolbarSpecialCombo.prototype.RefreshState = function() |
{ |
// Gets the actual state. |
var eState ; |
// if ( FCK.EditMode == FCK_EDITMODE_SOURCE && ! this.SourceView ) |
// eState = FCK_TRISTATE_DISABLED ; |
// else |
// { |
var sValue = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetState() ; |
// FCKDebug.Output( 'RefreshState of Special Combo "' + this.TypeOf + '" - State: ' + sValue ) ; |
if ( sValue != FCK_TRISTATE_DISABLED ) |
{ |
eState = FCK_TRISTATE_ON ; |
if ( this.RefreshActiveItems ) |
this.RefreshActiveItems( this._Combo, sValue ) ; |
else |
{ |
if ( this._LastValue != sValue ) |
{ |
this._LastValue = sValue ; |
FCKToolbarSpecialCombo_RefreshActiveItems( this._Combo, sValue ) ; |
} |
} |
} |
else |
eState = FCK_TRISTATE_DISABLED ; |
// } |
// If there are no state changes then do nothing and return. |
if ( eState == this.State ) return ; |
if ( eState == FCK_TRISTATE_DISABLED ) |
{ |
this._Combo.DeselectAll() ; |
this._Combo.SetLabel( '' ) ; |
} |
// Sets the actual state. |
this.State = eState ; |
// Updates the graphical state. |
this._Combo.SetEnabled( eState != FCK_TRISTATE_DISABLED ) ; |
} |
FCKToolbarSpecialCombo.prototype.Enable = function() |
{ |
this.RefreshState() ; |
} |
FCKToolbarSpecialCombo.prototype.Disable = function() |
{ |
this.State = FCK_TRISTATE_DISABLED ; |
this._Combo.DeselectAll() ; |
this._Combo.SetLabel( '' ) ; |
this._Combo.SetEnabled( false ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fcktoolbarbreak_ie.js |
---|
New file |
0,0 → 1,34 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarbreak_ie.js |
* FCKToolbarBreak Class: breaks the toolbars. |
* It makes it possible to force the toolbar to brak to a new line. |
* This is the IE specific implementation. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarBreak = function() |
{} |
FCKToolbarBreak.prototype.Create = function( targetElement ) |
{ |
var oBreakDiv = FCKTools.GetElementDocument( targetElement ).createElement( 'div' ) ; |
oBreakDiv.className = 'TB_Break' ; |
oBreakDiv.style.clear = FCKLang.Dir == 'rtl' ? 'left' : 'right' ; |
targetElement.appendChild( oBreakDiv ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/classes/fckstyledef_gecko.js |
---|
New file |
0,0 → 1,116 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckstyledef_gecko.js |
* FCKStyleDef Class: represents a single stylke definition. (Gecko specific) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKStyleDef.prototype.ApplyToSelection = function() |
{ |
if ( FCKSelection.GetType() == 'Text' && !this.IsObjectElement ) |
{ |
var oSelection = FCK.ToolbarSet.CurrentInstance.EditorWindow.getSelection() ; |
// Create the main element. |
var e = FCK.ToolbarSet.CurrentInstance.EditorDocument.createElement( this.Element ) ; |
for ( var i = 0 ; i < oSelection.rangeCount ; i++ ) |
{ |
e.appendChild( oSelection.getRangeAt(i).extractContents() ) ; |
} |
// Set the attributes. |
this._AddAttributes( e ) ; |
// Remove the duplicated elements. |
this._RemoveDuplicates( e ) ; |
var oRange = oSelection.getRangeAt(0) ; |
oRange.insertNode( e ) ; |
} |
else |
{ |
var oControl = FCK.ToolbarSet.CurrentInstance.Selection.GetSelectedElement() ; |
if ( oControl.tagName == this.Element ) |
this._AddAttributes( oControl ) ; |
} |
} |
FCKStyleDef.prototype._AddAttributes = function( targetElement ) |
{ |
for ( var a in this.Attributes ) |
{ |
switch ( a.toLowerCase() ) |
{ |
case 'src' : |
targetElement.setAttribute( '_fcksavedurl', this.Attributes[a], 0 ) ; |
default : |
targetElement.setAttribute( a, this.Attributes[a], 0 ) ; |
} |
} |
} |
FCKStyleDef.prototype._RemoveDuplicates = function( parent ) |
{ |
for ( var i = 0 ; i < parent.childNodes.length ; i++ ) |
{ |
var oChild = parent.childNodes[i] ; |
if ( oChild.nodeType != 1 ) |
continue ; |
this._RemoveDuplicates( oChild ) ; |
if ( this.IsEqual( oChild ) ) |
FCKTools.RemoveOuterTags( oChild ) ; |
} |
} |
FCKStyleDef.prototype.IsEqual = function( e ) |
{ |
if ( e.tagName != this.Element ) |
return false ; |
for ( var a in this.Attributes ) |
{ |
if ( e.getAttribute( a ) != this.Attributes[a] ) |
return false ; |
} |
return true ; |
} |
FCKStyleDef.prototype._RemoveMe = function( elementToCheck ) |
{ |
if ( ! elementToCheck ) |
return ; |
var oParent = elementToCheck.parentNode ; |
if ( elementToCheck.nodeType == 1 && this.IsEqual( elementToCheck ) ) |
{ |
if ( this.IsObjectElement ) |
{ |
for ( var a in this.Attributes ) |
elementToCheck.removeAttribute( a, 0 ) ; |
return ; |
} |
else |
FCKTools.RemoveOuterTags( elementToCheck ) ; |
} |
this._RemoveMe( oParent ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/fckeditorapi.js |
---|
New file |
0,0 → 1,104 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckeditorapi.js |
* Create the FCKeditorAPI object that is available as a global object in |
* the page where the editor is placed in. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKeditorAPI ; |
function InitializeAPI() |
{ |
if ( !( FCKeditorAPI = window.parent.FCKeditorAPI ) ) |
{ |
// Make the FCKeditorAPI object available in the parent window. Use |
// eval so it is independent from this window and so it will still be |
// available if the editor instance is removed ("Can't execute code |
// from a freed script" error). |
var sScript = '\ |
var FCKeditorAPI = {\ |
Version : \'2.3.2\',\ |
VersionBuild : \'1082\',\ |
__Instances : new Object(),\ |
GetInstance : function( instanceName )\ |
{\ |
return this.__Instances[ instanceName ] ;\ |
},\ |
_FunctionQueue : {\ |
Functions : new Array(),\ |
IsRunning : false,\ |
Add : function( functionToAdd )\ |
{\ |
this.Functions.push( functionToAdd ) ;\ |
if ( !this.IsRunning )\ |
this.StartNext() ;\ |
},\ |
StartNext : function()\ |
{\ |
var aQueue = this.Functions ;\ |
if ( aQueue.length > 0 )\ |
{\ |
this.IsRunning = true ;\ |
aQueue[0].call() ;\ |
}\ |
else\ |
this.IsRunning = false ;\ |
},\ |
Remove : function( func )\ |
{\ |
var aQueue = this.Functions ;\ |
var i = 0, fFunc ;\ |
while( fFunc = aQueue[ i ] )\ |
{\ |
if ( fFunc == func )\ |
aQueue.splice( i,1 ) ;\ |
i++ ;\ |
}\ |
this.StartNext() ;\ |
}\ |
}\ |
}' ; |
// In IE, the "eval" function is not always available (it works with |
// the JavaScript samples, but not with the ASP ones, for example). |
// So, let's use the execScript instead. |
if ( window.parent.execScript ) |
window.parent.execScript( sScript, 'JavaScript' ) ; |
else |
{ |
if ( FCKBrowserInfo.IsGecko10 ) |
{ |
// FF 1.0.4 gives an error with the above request. The |
// following seams to work well. It could become to official |
// implementation for all browsers, but we need to check it. |
eval.call( window.parent, sScript ) ; |
} |
else |
window.parent.eval( sScript ) ; |
} |
FCKeditorAPI = window.parent.FCKeditorAPI ; |
} |
// Add the current instance to the FCKeditorAPI's instances collection. |
FCKeditorAPI.__Instances[ FCK.Name ] = FCK ; |
} |
function FCKeditorAPI_Cleanup() |
{ |
FCKeditorAPI.__Instances[ FCK.Name ] = null ; |
} |
FCKTools.AddEventListener( window, 'unload', FCKeditorAPI_Cleanup ) ; |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktablehandler_gecko.js |
---|
New file |
0,0 → 1,53 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktablehandler_gecko.js |
* Manage table operations (IE specific). |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKTableHandler.GetSelectedCells = function() |
{ |
var aCells = new Array() ; |
var oSelection = FCK.EditorWindow.getSelection() ; |
// If the selection is a text. |
if ( oSelection.rangeCount == 1 && oSelection.anchorNode.nodeType == 3 ) |
{ |
var oParent = FCKTools.GetElementAscensor( oSelection.anchorNode, 'TD,TH' ) ; |
if ( oParent ) |
{ |
aCells[0] = oParent ; |
return aCells ; |
} |
} |
for ( var i = 0 ; i < oSelection.rangeCount ; i++ ) |
{ |
var oRange = oSelection.getRangeAt(i) ; |
var oCell ; |
if ( oRange.startContainer.tagName.Equals( 'TD', 'TH' ) ) |
oCell = oRange.startContainer ; |
else |
oCell = oRange.startContainer.childNodes[ oRange.startOffset ] ; |
if ( oCell.tagName.Equals( 'TD', 'TH' ) ) |
aCells[aCells.length] = oCell ; |
} |
return aCells ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckbrowserinfo.js |
---|
New file |
0,0 → 1,37 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckbrowserinfo.js |
* Contains browser detection information. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var s = navigator.userAgent.toLowerCase() ; |
var FCKBrowserInfo = |
{ |
IsIE : s.Contains('msie'), |
IsIE7 : s.Contains('msie 7'), |
IsGecko : s.Contains('gecko/'), |
IsSafari : s.Contains('safari'), |
IsOpera : s.Contains('opera') |
} |
FCKBrowserInfo.IsGeckoLike = FCKBrowserInfo.IsGecko || FCKBrowserInfo.IsSafari || FCKBrowserInfo.IsOpera ; |
if ( FCKBrowserInfo.IsGecko ) |
{ |
var sGeckoVersion = s.match( /gecko\/(\d+)/ )[1] ; |
FCKBrowserInfo.IsGecko10 = sGeckoVersion < 20051111 ; // Actually "10" refers to versions before Firefox 1.5, where Gecko 20051111 has been released. |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_2.js |
---|
New file |
0,0 → 1,162 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_2.js |
* This is the second part of the "FCK" object creation. This is the main |
* object that represents an editor instance. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// This collection is used by the browser specific implementations to tell |
// wich named commands must be handled separately. |
FCK.RedirectNamedCommands = new Object() ; |
FCK.ExecuteNamedCommand = function( commandName, commandParameter, noRedirect ) |
{ |
FCKUndo.SaveUndoStep() ; |
if ( !noRedirect && FCK.RedirectNamedCommands[ commandName ] != null ) |
FCK.ExecuteRedirectedNamedCommand( commandName, commandParameter ) ; |
else |
{ |
FCK.Focus() ; |
FCK.EditorDocument.execCommand( commandName, false, commandParameter ) ; |
FCK.Events.FireEvent( 'OnSelectionChange' ) ; |
} |
FCKUndo.SaveUndoStep() ; |
} |
FCK.GetNamedCommandState = function( commandName ) |
{ |
try |
{ |
if ( !FCK.EditorDocument.queryCommandEnabled( commandName ) ) |
return FCK_TRISTATE_DISABLED ; |
else |
return FCK.EditorDocument.queryCommandState( commandName ) ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF ; |
} |
catch ( e ) |
{ |
return FCK_TRISTATE_OFF ; |
} |
} |
FCK.GetNamedCommandValue = function( commandName ) |
{ |
var sValue = '' ; |
var eState = FCK.GetNamedCommandState( commandName ) ; |
if ( eState == FCK_TRISTATE_DISABLED ) |
return null ; |
try |
{ |
sValue = this.EditorDocument.queryCommandValue( commandName ) ; |
} |
catch(e) {} |
return sValue ? sValue : '' ; |
} |
FCK.PasteFromWord = function() |
{ |
FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word' ) ; |
} |
FCK.Preview = function() |
{ |
var iWidth = FCKConfig.ScreenWidth * 0.8 ; |
var iHeight = FCKConfig.ScreenHeight * 0.7 ; |
var iLeft = ( FCKConfig.ScreenWidth - iWidth ) / 2 ; |
var oWindow = window.open( '', null, 'toolbar=yes,location=no,status=yes,menubar=yes,scrollbars=yes,resizable=yes,width=' + iWidth + ',height=' + iHeight + ',left=' + iLeft ) ; |
var sHTML ; |
if ( FCKConfig.FullPage ) |
{ |
if ( FCK.TempBaseTag.length > 0 ) |
sHTML = FCK.TempBaseTag + FCK.GetXHTML() ; |
else |
sHTML = FCK.GetXHTML() ; |
} |
else |
{ |
sHTML = |
FCKConfig.DocType + |
'<html dir="' + FCKConfig.ContentLangDirection + '">' + |
'<head>' + |
FCK.TempBaseTag + |
'<title>' + FCKLang.Preview + '</title>' + |
FCK._GetEditorAreaStyleTags() + |
'</head><body>' + |
FCK.GetXHTML() + |
'</body></html>' ; |
} |
oWindow.document.write( sHTML ); |
oWindow.document.close(); |
} |
FCK.SwitchEditMode = function( noUndo ) |
{ |
var bIsWysiwyg = ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) ; |
var sHtml ; |
// Update the HTML in the view output to show. |
if ( bIsWysiwyg ) |
{ |
if ( !noUndo && FCKBrowserInfo.IsIE ) |
FCKUndo.SaveUndoStep() ; |
sHtml = FCK.GetXHTML( FCKConfig.FormatSource ) ; |
} |
else |
sHtml = this.EditingArea.Textarea.value ; |
FCK.EditMode = bIsWysiwyg ? FCK_EDITMODE_SOURCE : FCK_EDITMODE_WYSIWYG ; |
FCK.SetHTML( sHtml ) ; |
// Set the Focus. |
FCK.Focus() ; |
// Update the toolbar (Running it directly causes IE to fail). |
FCKTools.RunFunction( FCK.ToolbarSet.RefreshModeState, FCK.ToolbarSet ) ; |
} |
FCK.CreateElement = function( tag ) |
{ |
var e = FCK.EditorDocument.createElement( tag ) ; |
return FCK.InsertElementAndGetIt( e ) ; |
} |
FCK.InsertElementAndGetIt = function( e ) |
{ |
e.setAttribute( 'FCKTempLabel', 'true' ) ; |
this.InsertElement( e ) ; |
var aEls = FCK.EditorDocument.getElementsByTagName( e.tagName ) ; |
for ( var i = 0 ; i < aEls.length ; i++ ) |
{ |
if ( aEls[i].getAttribute( 'FCKTempLabel' ) ) |
{ |
aEls[i].removeAttribute( 'FCKTempLabel' ) ; |
return aEls[i] ; |
} |
} |
return null ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckregexlib.js |
---|
New file |
0,0 → 1,87 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckregexlib.js |
* These are some Regular Expresions used by the editor. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKRegexLib = { |
// This is the Regular expression used by the SetHTML method for the "'" entity. |
AposEntity : /'/gi , |
// Used by the Styles combo to identify styles that can't be applied to text. |
ObjectElements : /^(?:IMG|TABLE|TR|TD|TH|INPUT|SELECT|TEXTAREA|HR|OBJECT|A|UL|OL|LI)$/i , |
BlockElements : /^(?:P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TD|TH)$/i , |
// Elements marked as empty "Empty" in the XHTML DTD. |
EmptyElements : /^(?:BASE|META|LINK|HR|BR|PARAM|IMG|AREA|INPUT)$/i , |
// List all named commands (commands that can be interpreted by the browser "execCommand" method. |
NamedCommands : /^(?:Cut|Copy|Paste|Print|SelectAll|RemoveFormat|Unlink|Undo|Redo|Bold|Italic|Underline|StrikeThrough|Subscript|Superscript|JustifyLeft|JustifyCenter|JustifyRight|JustifyFull|Outdent|Indent|InsertOrderedList|InsertUnorderedList|InsertHorizontalRule)$/i , |
BodyContents : /([\s\S]*\<body[^\>]*\>)([\s\S]*)(\<\/body\>[\s\S]*)/i , |
// Temporary text used to solve some browser specific limitations. |
ToReplace : /___fcktoreplace:([\w]+)/ig , |
// Get the META http-equiv attribute from the tag. |
MetaHttpEquiv : /http-equiv\s*=\s*["']?([^"' ]+)/i , |
HasBaseTag : /<base /i , |
HtmlOpener : /<html\s?[^>]*>/i , |
HeadOpener : /<head\s?[^>]*>/i , |
HeadCloser : /<\/head\s*>/i , |
TableBorderClass : /\s*FCK__ShowTableBorders\s*/ , |
// Validate element names. |
ElementName : /(^[A-Za-z_:][\w.\-:]*\w$)|(^[A-Za-z_]$)/ , |
// Used in conjuction with the FCKConfig.ForceSimpleAmpersand configuration option. |
ForceSimpleAmpersand : /___FCKAmp___/g , |
// Get the closing parts of the tags with no closing tags, like <br/>... gets the "/>" part. |
SpaceNoClose : /\/>/g , |
EmptyParagraph : /^<(p|div)>\s*<\/\1>$/i , |
TagBody : /></ , |
StrongOpener : /<STRONG([ \>])/gi , |
StrongCloser : /<\/STRONG>/gi , |
EmOpener : /<EM([ \>])/gi , |
EmCloser : /<\/EM>/gi , |
AbbrOpener : /<ABBR([ \>])/gi , |
AbbrCloser : /<\/ABBR>/gi , |
GeckoEntitiesMarker : /#\?-\:/g , |
// We look for the "src" and href attribute with the " or ' or whithout one of |
// them. We have to do all in one, otherwhise we will have problems with URLs |
// like "thumbnail.php?src=someimage.jpg" (SF-BUG 1554141). |
ProtectUrlsImg : /(?:(<img(?=\s).*?\ssrc=)("|')(.*?)\2)|(?:(<img\s.*?src=)([^"'][^ >]+))/gi , |
ProtectUrlsA : /(?:(<a(?=\s).*?\shref=)("|')(.*?)\2)|(?:(<a\s.*?href=)([^"'][^ >]+))/gi , |
Html4DocType : /HTML 4\.0 Transitional/i , |
DocTypeTag : /<!DOCTYPE[^>]*>/i , |
// These regex are used to save the original event attributes in the HTML. |
TagsWithEvent : /<[^\>]+ on\w+[\s\r\n]*=[\s\r\n]*?('|")[\s\S]+?\>/g , |
EventAttributes : /\s(on\w+)[\s\r\n]*=[\s\r\n]*?('|")([\s\S]*?)\2/g, |
ProtectedEvents : /\s\w+_fckprotectedatt="([^"]+)"/g |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckselection_ie.js |
---|
New file |
0,0 → 1,151 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckselection_ie.js |
* Active selection functions. (IE specific implementation) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// Get the selection type. |
FCKSelection.GetType = function() |
{ |
return FCK.EditorDocument.selection.type ; |
} |
// Retrieves the selected element (if any), just in the case that a single |
// element (object like and image or a table) is selected. |
FCKSelection.GetSelectedElement = function() |
{ |
if ( this.GetType() == 'Control' ) |
{ |
var oRange = FCK.EditorDocument.selection.createRange() ; |
if ( oRange && oRange.item ) |
return FCK.EditorDocument.selection.createRange().item(0) ; |
} |
} |
FCKSelection.GetParentElement = function() |
{ |
switch ( this.GetType() ) |
{ |
case 'Control' : |
return FCKSelection.GetSelectedElement().parentElement ; |
case 'None' : |
return ; |
default : |
return FCK.EditorDocument.selection.createRange().parentElement() ; |
} |
} |
FCKSelection.SelectNode = function( node ) |
{ |
FCK.Focus() ; |
FCK.EditorDocument.selection.empty() ; |
try |
{ |
// Try to select the node as a control. |
var oRange = FCK.EditorDocument.body.createControlRange() ; |
oRange.addElement( node ) ; |
} |
catch(e) |
{ |
// If failed, select it as a text range. |
var oRange = FCK.EditorDocument.selection.createRange() ; |
oRange.moveToElementText( node ) ; |
} |
oRange.select() ; |
} |
FCKSelection.Collapse = function( toStart ) |
{ |
FCK.Focus() ; |
if ( this.GetType() == 'Text' ) |
{ |
var oRange = FCK.EditorDocument.selection.createRange() ; |
oRange.collapse( toStart == null || toStart === true ) ; |
oRange.select() ; |
} |
} |
// The "nodeTagName" parameter must be Upper Case. |
FCKSelection.HasAncestorNode = function( nodeTagName ) |
{ |
var oContainer ; |
if ( FCK.EditorDocument.selection.type == "Control" ) |
{ |
oContainer = this.GetSelectedElement() ; |
} |
else |
{ |
var oRange = FCK.EditorDocument.selection.createRange() ; |
oContainer = oRange.parentElement() ; |
} |
while ( oContainer ) |
{ |
if ( oContainer.tagName == nodeTagName ) return true ; |
oContainer = oContainer.parentNode ; |
} |
return false ; |
} |
// The "nodeTagName" parameter must be UPPER CASE. |
FCKSelection.MoveToAncestorNode = function( nodeTagName ) |
{ |
var oNode ; |
if ( FCK.EditorDocument.selection.type == "Control" ) |
{ |
var oRange = FCK.EditorDocument.selection.createRange() ; |
for ( i = 0 ; i < oRange.length ; i++ ) |
{ |
if (oRange(i).parentNode) |
{ |
oNode = oRange(i).parentNode ; |
break ; |
} |
} |
} |
else |
{ |
var oRange = FCK.EditorDocument.selection.createRange() ; |
oNode = oRange.parentElement() ; |
} |
while ( oNode && oNode.nodeName != nodeTagName ) |
oNode = oNode.parentNode ; |
return oNode ; |
} |
FCKSelection.Delete = function() |
{ |
// Gets the actual selection. |
var oSel = FCK.EditorDocument.selection ; |
// Deletes the actual selection contents. |
if ( oSel.type.toLowerCase() != "none" ) |
{ |
oSel.clear() ; |
} |
return oSel ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckurlparams.js |
---|
New file |
0,0 → 1,32 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckurlparams.js |
* Defines the FCKURLParams object that is used to get all parameters |
* passed by the URL QueryString (after the "?"). |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// #### URLParams: holds all URL passed parameters (like ?Param1=Value1&Param2=Value2) |
var FCKURLParams = new Object() ; |
var aParams = document.location.search.substr(1).split('&') ; |
for ( var i = 0 ; i < aParams.length ; i++ ) |
{ |
var aParam = aParams[i].split('=') ; |
var sParamName = aParam[0] ; |
var sParamValue = aParam[1] ; |
FCKURLParams[ sParamName ] = sParamValue ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_2_gecko.js |
---|
New file |
0,0 → 1,196 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_2_gecko.js |
* This is the second part of the "FCK" object creation. This is the main |
* object that represents an editor instance. |
* (Gecko specific implementations) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// GetNamedCommandState overload for Gecko. |
FCK._BaseGetNamedCommandState = FCK.GetNamedCommandState ; |
FCK.GetNamedCommandState = function( commandName ) |
{ |
switch ( commandName ) |
{ |
case 'Unlink' : |
return FCKSelection.HasAncestorNode('A') ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; |
default : |
return FCK._BaseGetNamedCommandState( commandName ) ; |
} |
} |
// Named commands to be handled by this browsers specific implementation. |
FCK.RedirectNamedCommands = |
{ |
Print : true, |
Paste : true, |
Cut : true, |
Copy : true |
} |
// ExecuteNamedCommand overload for Gecko. |
FCK.ExecuteRedirectedNamedCommand = function( commandName, commandParameter ) |
{ |
switch ( commandName ) |
{ |
case 'Print' : |
FCK.EditorWindow.print() ; |
break ; |
case 'Paste' : |
try { if ( FCK.Paste() ) FCK.ExecuteNamedCommand( 'Paste', null, true ) ; } |
catch (e) { alert(FCKLang.PasteErrorPaste) ; } |
break ; |
case 'Cut' : |
try { FCK.ExecuteNamedCommand( 'Cut', null, true ) ; } |
catch (e) { alert(FCKLang.PasteErrorCut) ; } |
break ; |
case 'Copy' : |
try { FCK.ExecuteNamedCommand( 'Copy', null, true ) ; } |
catch (e) { alert(FCKLang.PasteErrorCopy) ; } |
break ; |
default : |
FCK.ExecuteNamedCommand( commandName, commandParameter ) ; |
} |
} |
FCK.AttachToOnSelectionChange = function( functionPointer ) |
{ |
this.Events.AttachEvent( 'OnSelectionChange', functionPointer ) ; |
} |
FCK.Paste = function() |
{ |
if ( FCKConfig.ForcePasteAsPlainText ) |
{ |
FCK.PasteAsPlainText() ; |
return false ; |
} |
/* For now, the AutoDetectPasteFromWord feature is IE only. |
else if ( FCKConfig.AutoDetectPasteFromWord ) |
{ |
var sHTML = FCK.GetClipboardHTML() ; |
var re = /<\w[^>]* class="?MsoNormal"?/gi ; |
if ( re.test( sHTML ) ) |
{ |
if ( confirm( FCKLang["PasteWordConfirm"] ) ) |
{ |
FCK.PasteFromWord() ; |
return false ; |
} |
} |
} |
*/ |
else |
return true ; |
} |
//** |
// FCK.InsertHtml: Inserts HTML at the current cursor location. Deletes the |
// selected content if any. |
FCK.InsertHtml = function( html ) |
{ |
html = FCKConfig.ProtectedSource.Protect( html ) ; |
html = FCK.ProtectUrls( html ) ; |
// Delete the actual selection. |
var oSel = FCKSelection.Delete() ; |
// Get the first available range. |
var oRange = oSel.getRangeAt(0) ; |
// Create a fragment with the input HTML. |
var oFragment = oRange.createContextualFragment( html ) ; |
// Get the last available node. |
var oLastNode = oFragment.lastChild ; |
// Insert the fragment in the range. |
oRange.insertNode(oFragment) ; |
// Set the cursor after the inserted fragment. |
FCKSelection.SelectNode( oLastNode ) ; |
FCKSelection.Collapse( false ) ; |
this.Focus() ; |
} |
FCK.InsertElement = function( element ) |
{ |
// Deletes the actual selection. |
var oSel = FCKSelection.Delete() ; |
// Gets the first available range. |
var oRange = oSel.getRangeAt(0) ; |
// Inserts the element in the range. |
oRange.insertNode( element ) ; |
// Set the cursor after the inserted fragment. |
FCKSelection.SelectNode( element ) ; |
FCKSelection.Collapse( false ) ; |
this.Focus() ; |
} |
FCK.PasteAsPlainText = function() |
{ |
// TODO: Implement the "Paste as Plain Text" code. |
FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteAsText, 'dialog/fck_paste.html', 400, 330, 'PlainText' ) ; |
/* |
var sText = FCKTools.HTMLEncode( clipboardData.getData("Text") ) ; |
sText = sText.replace( /\n/g, '<BR>' ) ; |
this.InsertHtml( sText ) ; |
*/ |
} |
/* |
FCK.PasteFromWord = function() |
{ |
// TODO: Implement the "Paste as Plain Text" code. |
FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word' ) ; |
// FCK.CleanAndPaste( FCK.GetClipboardHTML() ) ; |
} |
*/ |
FCK.GetClipboardHTML = function() |
{ |
return '' ; |
} |
FCK.CreateLink = function( url ) |
{ |
FCK.ExecuteNamedCommand( 'Unlink' ) ; |
if ( url.length > 0 ) |
{ |
// Generate a temporary name for the link. |
var sTempUrl = 'javascript:void(0);/*' + ( new Date().getTime() ) + '*/' ; |
// Use the internal "CreateLink" command to create the link. |
FCK.ExecuteNamedCommand( 'CreateLink', sTempUrl ) ; |
// Retrieve the just created link using XPath. |
var oLink = document.evaluate("//a[@href='" + sTempUrl + "']", this.EditorDocument.body, null, 9, null).singleNodeValue ; |
if ( oLink ) |
{ |
oLink.href = url ; |
return oLink ; |
} |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_contextmenu.js |
---|
New file |
0,0 → 1,290 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_contextmenu.js |
* Defines the FCK.ContextMenu object that is responsible for all |
* Context Menu operations in the editing area. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCK.ContextMenu = new Object() ; |
FCK.ContextMenu.Listeners = new Array() ; |
FCK.ContextMenu.RegisterListener = function( listener ) |
{ |
if ( listener ) |
this.Listeners.push( listener ) ; |
} |
function FCK_ContextMenu_Init() |
{ |
var oInnerContextMenu = FCK.ContextMenu._InnerContextMenu = new FCKContextMenu( FCKBrowserInfo.IsIE ? window : window.parent, FCK.EditorWindow, FCKLang.Dir ) ; |
oInnerContextMenu.OnBeforeOpen = FCK_ContextMenu_OnBeforeOpen ; |
oInnerContextMenu.OnItemClick = FCK_ContextMenu_OnItemClick ; |
// Get the registering function. |
var oMenu = FCK.ContextMenu ; |
// Register all configured context menu listeners. |
for ( var i = 0 ; i < FCKConfig.ContextMenu.length ; i++ ) |
oMenu.RegisterListener( FCK_ContextMenu_GetListener( FCKConfig.ContextMenu[i] ) ) ; |
} |
function FCK_ContextMenu_GetListener( listenerName ) |
{ |
switch ( listenerName ) |
{ |
case 'Generic' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
menu.AddItem( 'Cut' , FCKLang.Cut , 7, FCKCommands.GetCommand( 'Cut' ).GetState() == FCK_TRISTATE_DISABLED ) ; |
menu.AddItem( 'Copy' , FCKLang.Copy , 8, FCKCommands.GetCommand( 'Copy' ).GetState() == FCK_TRISTATE_DISABLED ) ; |
menu.AddItem( 'Paste' , FCKLang.Paste , 9, FCKCommands.GetCommand( 'Paste' ).GetState() == FCK_TRISTATE_DISABLED ) ; |
}} ; |
case 'Table' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
var bIsTable = ( tagName == 'TABLE' ) ; |
var bIsCell = ( !bIsTable && FCKSelection.HasAncestorNode( 'TABLE' ) ) ; |
if ( bIsCell ) |
{ |
menu.AddSeparator() ; |
var oItem = menu.AddItem( 'Cell' , FCKLang.CellCM ) ; |
oItem.AddItem( 'TableInsertCell' , FCKLang.InsertCell, 58 ) ; |
oItem.AddItem( 'TableDeleteCells' , FCKLang.DeleteCells, 59 ) ; |
oItem.AddItem( 'TableMergeCells' , FCKLang.MergeCells, 60 ) ; |
oItem.AddItem( 'TableSplitCell' , FCKLang.SplitCell, 61 ) ; |
oItem.AddSeparator() ; |
oItem.AddItem( 'TableCellProp' , FCKLang.CellProperties, 57 ) ; |
menu.AddSeparator() ; |
oItem = menu.AddItem( 'Row' , FCKLang.RowCM ) ; |
oItem.AddItem( 'TableInsertRow' , FCKLang.InsertRow, 62 ) ; |
oItem.AddItem( 'TableDeleteRows' , FCKLang.DeleteRows, 63 ) ; |
menu.AddSeparator() ; |
oItem = menu.AddItem( 'Column' , FCKLang.ColumnCM ) ; |
oItem.AddItem( 'TableInsertColumn' , FCKLang.InsertColumn, 64 ) ; |
oItem.AddItem( 'TableDeleteColumns' , FCKLang.DeleteColumns, 65 ) ; |
} |
if ( bIsTable || bIsCell ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'TableDelete' , FCKLang.TableDelete ) ; |
menu.AddItem( 'TableProp' , FCKLang.TableProperties, 39 ) ; |
} |
}} ; |
case 'Link' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
var bInsideLink = ( tagName == 'A' || FCKSelection.HasAncestorNode( 'A' ) ) ; |
if ( bInsideLink || FCK.GetNamedCommandState( 'Unlink' ) != FCK_TRISTATE_DISABLED ) |
{ |
menu.AddSeparator() ; |
if ( bInsideLink ) |
menu.AddItem( 'Link', FCKLang.EditLink , 34 ) ; |
menu.AddItem( 'Unlink' , FCKLang.RemoveLink , 35 ) ; |
} |
}} ; |
case 'Image' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'IMG' && !tag.getAttribute( '_fckfakelement' ) ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Image', FCKLang.ImageProperties, 37 ) ; |
} |
}} ; |
case 'Anchor' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'IMG' && tag.getAttribute( '_fckanchor' ) ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Anchor', FCKLang.AnchorProp, 36 ) ; |
} |
}} ; |
case 'Flash' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'IMG' && tag.getAttribute( '_fckflash' ) ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Flash', FCKLang.FlashProperties, 38 ) ; |
} |
}} ; |
case 'Form' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( FCKSelection.HasAncestorNode('FORM') ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Form', FCKLang.FormProp, 48 ) ; |
} |
}} ; |
case 'Checkbox' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'INPUT' && tag.type == 'checkbox' ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Checkbox', FCKLang.CheckboxProp, 49 ) ; |
} |
}} ; |
case 'Radio' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'INPUT' && tag.type == 'radio' ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Radio', FCKLang.RadioButtonProp, 50 ) ; |
} |
}} ; |
case 'TextField' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'INPUT' && ( tag.type == 'text' || tag.type == 'password' ) ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'TextField', FCKLang.TextFieldProp, 51 ) ; |
} |
}} ; |
case 'HiddenField' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'INPUT' && tag.type == 'hidden' ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'HiddenField', FCKLang.HiddenFieldProp, 56 ) ; |
} |
}} ; |
case 'ImageButton' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'INPUT' && tag.type == 'image' ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'ImageButton', FCKLang.ImageButtonProp, 55 ) ; |
} |
}} ; |
case 'Button' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'INPUT' && ( tag.type == 'button' || tag.type == 'submit' || tag.type == 'reset' ) ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Button', FCKLang.ButtonProp, 54 ) ; |
} |
}} ; |
case 'Select' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'SELECT' ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Select', FCKLang.SelectionFieldProp, 53 ) ; |
} |
}} ; |
case 'Textarea' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( tagName == 'TEXTAREA' ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'Textarea', FCKLang.TextareaProp, 52 ) ; |
} |
}} ; |
case 'BulletedList' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( FCKSelection.HasAncestorNode('UL') ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'BulletedList', FCKLang.BulletedListProp, 27 ) ; |
} |
}} ; |
case 'NumberedList' : |
return { |
AddItems : function( menu, tag, tagName ) |
{ |
if ( FCKSelection.HasAncestorNode('OL') ) |
{ |
menu.AddSeparator() ; |
menu.AddItem( 'NumberedList', FCKLang.NumberedListProp, 26 ) ; |
} |
}} ; |
} |
} |
function FCK_ContextMenu_OnBeforeOpen() |
{ |
// Update the UI. |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
// Get the actual selected tag (if any). |
var oTag, sTagName ; |
if ( oTag = FCKSelection.GetSelectedElement() ) |
sTagName = oTag.tagName ; |
// Cleanup the current menu items. |
var oMenu = FCK.ContextMenu._InnerContextMenu ; |
oMenu.RemoveAllItems() ; |
// Loop through the listeners. |
var aListeners = FCK.ContextMenu.Listeners ; |
for ( var i = 0 ; i < aListeners.length ; i++ ) |
aListeners[i].AddItems( oMenu, oTag, sTagName ) ; |
} |
function FCK_ContextMenu_OnItemClick( item ) |
{ |
FCK.Focus() ; |
FCKCommands.GetCommand( item.Name ).Execute() ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_1_ie.js |
---|
New file |
0,0 → 1,294 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_1_ie.js |
* This is the first part of the "FCK" object creation. This is the main |
* object that represents an editor instance. |
* (IE specific implementations) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCK.Description = "FCKeditor for Internet Explorer 5.5+" ; |
FCK._GetBehaviorsStyle = function() |
{ |
if ( !FCK._BehaviorsStyle ) |
{ |
var sBasePath = FCKConfig.FullBasePath ; |
var sTableBehavior = '' ; |
var sStyle ; |
// The behaviors should be pointed using the FullBasePath to avoid security |
// errors when using a differente BaseHref. |
sStyle = |
'<style type="text/css" _fcktemp="true">' + |
'INPUT { behavior: url(' + sBasePath + 'css/behaviors/hiddenfield.htc) ; }' ; |
if ( FCKConfig.ShowBorders ) |
sTableBehavior = 'url(' + sBasePath + 'css/behaviors/showtableborders.htc)' ; |
// Disable resize handlers. |
sStyle += 'INPUT,TEXTAREA,SELECT,.FCK__Anchor,.FCK__PageBreak' ; |
if ( FCKConfig.DisableObjectResizing ) |
{ |
sStyle += ',IMG' ; |
sTableBehavior += ' url(' + sBasePath + 'css/behaviors/disablehandles.htc)' ; |
} |
sStyle += ' { behavior: url(' + sBasePath + 'css/behaviors/disablehandles.htc) ; }' ; |
if ( sTableBehavior.length > 0 ) |
sStyle += 'TABLE { behavior: ' + sTableBehavior + ' ; }' ; |
sStyle += '</style>' ; |
FCK._BehaviorsStyle = sStyle ; |
} |
return FCK._BehaviorsStyle ; |
} |
function Doc_OnMouseUp() |
{ |
if ( FCK.EditorWindow.event.srcElement.tagName == 'HTML' ) |
{ |
FCK.Focus() ; |
FCK.EditorWindow.event.cancelBubble = true ; |
FCK.EditorWindow.event.returnValue = false ; |
} |
} |
function Doc_OnPaste() |
{ |
if ( FCK.Status == FCK_STATUS_COMPLETE ) |
FCK.Events.FireEvent( "OnPaste" ) ; |
return false ; |
} |
/* |
function Doc_OnContextMenu() |
{ |
var e = FCK.EditorWindow.event ; |
FCK.ShowContextMenu( e.screenX, e.screenY ) ; |
return false ; |
} |
*/ |
function Doc_OnKeyDown() |
{ |
var e = FCK.EditorWindow.event ; |
switch ( e.keyCode ) |
{ |
case 13 : // ENTER |
if ( FCKConfig.UseBROnCarriageReturn && !(e.ctrlKey || e.altKey || e.shiftKey) ) |
{ |
Doc_OnKeyDownUndo() ; |
// We must ignore it if we are inside a List. |
if ( FCK.EditorDocument.queryCommandState( 'InsertOrderedList' ) || FCK.EditorDocument.queryCommandState( 'InsertUnorderedList' ) ) |
return true ; |
// Insert the <BR> (The must be also inserted to make it work) |
FCK.InsertHtml( '<br> ' ) ; |
// Remove the |
var oRange = FCK.EditorDocument.selection.createRange() ; |
oRange.moveStart( 'character', -1 ) ; |
oRange.select() ; |
FCK.EditorDocument.selection.clear() ; |
return false ; |
} |
break ; |
case 8 : // BACKSPACE |
// We must delete a control selection by code and cancels the |
// keystroke, otherwise IE will execute the browser's "back" button. |
if ( FCKSelection.GetType() == 'Control' ) |
{ |
FCKSelection.Delete() ; |
return false ; |
} |
break ; |
case 9 : // TAB |
if ( FCKConfig.TabSpaces > 0 && !(e.ctrlKey || e.altKey || e.shiftKey) ) |
{ |
Doc_OnKeyDownUndo() ; |
FCK.InsertHtml( window.FCKTabHTML ) ; |
return false ; |
} |
break ; |
case 90 : // Z |
if ( e.ctrlKey && !(e.altKey || e.shiftKey) ) |
{ |
FCKUndo.Undo() ; |
return false ; |
} |
break ; |
case 89 : // Y |
if ( e.ctrlKey && !(e.altKey || e.shiftKey) ) |
{ |
FCKUndo.Redo() ; |
return false ; |
} |
break ; |
} |
if ( !( e.keyCode >=16 && e.keyCode <= 18 ) ) |
Doc_OnKeyDownUndo() ; |
return true ; |
} |
function Doc_OnKeyDownUndo() |
{ |
if ( !FCKUndo.Typing ) |
{ |
FCKUndo.SaveUndoStep() ; |
FCKUndo.Typing = true ; |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
FCKUndo.TypesCount++ ; |
if ( FCKUndo.TypesCount > FCKUndo.MaxTypes ) |
{ |
FCKUndo.TypesCount = 0 ; |
FCKUndo.SaveUndoStep() ; |
} |
} |
function Doc_OnDblClick() |
{ |
FCK.OnDoubleClick( FCK.EditorWindow.event.srcElement ) ; |
FCK.EditorWindow.event.cancelBubble = true ; |
} |
function Doc_OnSelectionChange() |
{ |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
FCK.InitializeBehaviors = function( dontReturn ) |
{ |
// Set the focus to the editable area when clicking in the document area. |
// TODO: The cursor must be positioned at the end. |
this.EditorDocument.attachEvent( 'onmouseup', Doc_OnMouseUp ) ; |
// Intercept pasting operations |
this.EditorDocument.body.attachEvent( 'onpaste', Doc_OnPaste ) ; |
// Reset the context menu. |
FCK.ContextMenu._InnerContextMenu.AttachToElement( FCK.EditorDocument.body ) ; |
// Build the "TAB" key replacement (if necessary). |
if ( FCKConfig.TabSpaces > 0 ) |
{ |
window.FCKTabHTML = '' ; |
for ( i = 0 ; i < FCKConfig.TabSpaces ; i++ ) |
window.FCKTabHTML += " " ; |
} |
this.EditorDocument.attachEvent("onkeydown", Doc_OnKeyDown ) ; |
this.EditorDocument.attachEvent("ondblclick", Doc_OnDblClick ) ; |
// Catch cursor movements |
this.EditorDocument.attachEvent("onselectionchange", Doc_OnSelectionChange ) ; |
//Enable editing |
// this.EditorDocument.body.contentEditable = true ; |
} |
FCK.InsertHtml = function( html ) |
{ |
html = FCKConfig.ProtectedSource.Protect( html ) ; |
html = FCK.ProtectUrls( html ) ; |
FCK.Focus() ; |
FCKUndo.SaveUndoStep() ; |
// Gets the actual selection. |
var oSel = FCK.EditorDocument.selection ; |
// Deletes the actual selection contents. |
if ( oSel.type.toLowerCase() == 'control' ) |
oSel.clear() ; |
// Insert the HTML. |
oSel.createRange().pasteHTML( html ) ; |
FCKDocumentProcessor.Process( FCK.EditorDocument ) ; |
} |
FCK.SetInnerHtml = function( html ) // IE Only |
{ |
var oDoc = FCK.EditorDocument ; |
// Using the following trick, any comment in the begining of the HTML will |
// be preserved. |
oDoc.body.innerHTML = '<div id="__fakeFCKRemove__"> </div>' + html ; |
oDoc.getElementById('__fakeFCKRemove__').removeNode( true ) ; |
} |
var FCK_PreloadImages_Count = 0 ; |
var FCK_PreloadImages_Images = new Array() ; |
function FCK_PreloadImages() |
{ |
// Get the images to preload. |
var aImages = FCKConfig.PreloadImages || [] ; |
if ( typeof( aImages ) == 'string' ) |
aImages = aImages.split( ';' ) ; |
// Add the skin icons strip. |
aImages.push( FCKConfig.SkinPath + 'fck_strip.gif' ) ; |
FCK_PreloadImages_Count = aImages.length ; |
var aImageElements = new Array() ; |
for ( var i = 0 ; i < aImages.length ; i++ ) |
{ |
var eImg = document.createElement( 'img' ) ; |
eImg.onload = eImg.onerror = FCK_PreloadImages_OnImage ; |
eImg.src = aImages[i] ; |
FCK_PreloadImages_Images[i] = eImg ; |
} |
} |
function FCK_PreloadImages_OnImage() |
{ |
if ( (--FCK_PreloadImages_Count) == 0 ) |
FCKTools.RunFunction( LoadToolbarSetup ) ; |
} |
// Disable the context menu in the editor (outside the editing area). |
function Document_OnContextMenu() |
{ |
return ( event.srcElement._FCKShowContextMenu == true ) ; |
} |
document.oncontextmenu = Document_OnContextMenu ; |
function FCK_Cleanup() |
{ |
this.EditorWindow = null ; |
this.EditorDocument = null ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckdialog_ie.js |
---|
New file |
0,0 → 1,40 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckdialog_ie.js |
* Dialog windows operations. (IE specific implementations) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKDialog.Show = function( dialogInfo, dialogName, pageUrl, dialogWidth, dialogHeight, parentWindow ) |
{ |
if ( !parentWindow ) |
parentWindow = window ; |
FCKFocusManager.Lock() ; |
var oReturn ; |
try |
{ |
oReturn = parentWindow.showModalDialog( pageUrl, dialogInfo, "dialogWidth:" + dialogWidth + "px;dialogHeight:" + dialogHeight + "px;help:no;scroll:no;status:no") ; |
} |
catch( e ) |
{} |
if ( !oReturn ) |
alert( FCKLang.DialogBlocked ) ; |
FCKFocusManager.Unlock() ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckundo_gecko.js |
---|
New file |
0,0 → 1,23 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckundo_gecko.js |
* Fake implementation to ignore calls on Gecko. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKUndo = new Object() ; |
FCKUndo.SaveUndoStep = function() |
{} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_2_ie.js |
---|
New file |
0,0 → 1,164 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_2_ie.js |
* This is the second part of the "FCK" object creation. This is the main |
* object that represents an editor instance. |
* (IE specific implementations) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
/* |
if ( FCKConfig.UseBROnCarriageReturn ) |
{ |
// Named commands to be handled by this browsers specific implementation. |
FCK.RedirectNamedCommands = |
{ |
InsertOrderedList : true, |
InsertUnorderedList : true |
} |
FCK.ExecuteRedirectedNamedCommand = function( commandName, commandParameter ) |
{ |
if ( commandName == 'InsertOrderedList' || commandName == 'InsertUnorderedList' ) |
{ |
if ( !(FCK.EditorDocument.queryCommandState( 'InsertOrderedList' ) || FCK.EditorDocument.queryCommandState( 'InsertUnorderedList' )) ) |
{ |
} |
} |
FCK.ExecuteNamedCommand( commandName, commandParameter ) ; |
} |
} |
*/ |
FCK.Paste = function() |
{ |
if ( FCKConfig.ForcePasteAsPlainText ) |
{ |
FCK.PasteAsPlainText() ; |
return ; |
} |
var sHTML = FCK.GetClipboardHTML() ; |
if ( FCKConfig.AutoDetectPasteFromWord ) |
{ |
var re = /<\w[^>]*(( class="?MsoNormal"?)|(="mso-))/gi ; |
if ( re.test( sHTML ) ) |
{ |
if ( confirm( FCKLang["PasteWordConfirm"] ) ) |
{ |
FCK.PasteFromWord() ; |
return ; |
} |
} |
} |
FCK.InsertHtml( sHTML ) ; |
} |
FCK.PasteAsPlainText = function() |
{ |
// Get the data available in the clipboard and encodes it in HTML. |
var sText = FCKTools.HTMLEncode( clipboardData.getData("Text") ) ; |
// Replace the carriage returns with <BR> |
sText = sText.replace( /\n/g, '<BR>' ) ; |
// Insert the resulting data in the editor. |
this.InsertHtml( sText ) ; |
} |
/* |
FCK.PasteFromWord = function() |
{ |
FCK.CleanAndPaste( FCK.GetClipboardHTML() ) ; |
} |
*/ |
FCK.InsertElement = function( element ) |
{ |
FCK.InsertHtml( element.outerHTML ) ; |
} |
FCK.GetClipboardHTML = function() |
{ |
var oDiv = document.getElementById( '___FCKHiddenDiv' ) ; |
if ( !oDiv ) |
{ |
var oDiv = document.createElement( 'DIV' ) ; |
oDiv.id = '___FCKHiddenDiv' ; |
oDiv.style.visibility = 'hidden' ; |
oDiv.style.overflow = 'hidden' ; |
oDiv.style.position = 'absolute' ; |
oDiv.style.width = 1 ; |
oDiv.style.height = 1 ; |
document.body.appendChild( oDiv ) ; |
} |
oDiv.innerHTML = '' ; |
var oTextRange = document.body.createTextRange() ; |
oTextRange.moveToElementText( oDiv ) ; |
oTextRange.execCommand( 'Paste' ) ; |
var sData = oDiv.innerHTML ; |
oDiv.innerHTML = '' ; |
return sData ; |
} |
FCK.AttachToOnSelectionChange = function( functionPointer ) |
{ |
this.Events.AttachEvent( 'OnSelectionChange', functionPointer ) ; |
} |
/* |
FCK.AttachToOnSelectionChange = function( functionPointer ) |
{ |
FCK.EditorDocument.attachEvent( 'onselectionchange', functionPointer ) ; |
} |
*/ |
FCK.CreateLink = function( url ) |
{ |
// Remove any existing link in the selection. |
FCK.ExecuteNamedCommand( 'Unlink' ) ; |
if ( url.length > 0 ) |
{ |
// Generate a temporary name for the link. |
var sTempUrl = 'javascript:void(0);/*' + ( new Date().getTime() ) + '*/' ; |
// Use the internal "CreateLink" command to create the link. |
FCK.ExecuteNamedCommand( 'CreateLink', sTempUrl ) ; |
// Look for the just create link. |
var oLinks = this.EditorDocument.links ; |
for ( i = 0 ; i < oLinks.length ; i++ ) |
{ |
var oLink = oLinks[i] ; |
if ( oLink.href == sTempUrl ) |
{ |
var sInnerHtml = oLink.innerHTML ; // Save the innerHTML (IE changes it if it is like an URL). |
oLink.href = url ; |
oLink.innerHTML = sInnerHtml ; // Restore the innerHTML. |
return oLink ; |
} |
} |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckdocumentprocessor.js |
---|
New file |
0,0 → 1,175 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckdocumentprocessor.js |
* Advanced document processors. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKDocumentProcessor = new Object() ; |
FCKDocumentProcessor._Items = new Array() ; |
FCKDocumentProcessor.AppendNew = function() |
{ |
var oNewItem = new Object() ; |
this._Items.AddItem( oNewItem ) ; |
return oNewItem ; |
} |
FCKDocumentProcessor.Process = function( document ) |
{ |
var oProcessor, i = 0 ; |
while( ( oProcessor = this._Items[i++] ) ) |
oProcessor.ProcessDocument( document ) ; |
} |
var FCKDocumentProcessor_CreateFakeImage = function( fakeClass, realElement ) |
{ |
var oImg = FCK.EditorDocument.createElement( 'IMG' ) ; |
oImg.className = fakeClass ; |
oImg.src = FCKConfig.FullBasePath + 'images/spacer.gif' ; |
oImg.setAttribute( '_fckfakelement', 'true', 0 ) ; |
oImg.setAttribute( '_fckrealelement', FCKTempBin.AddElement( realElement ), 0 ) ; |
return oImg ; |
} |
// Link Anchors |
var FCKAnchorsProcessor = FCKDocumentProcessor.AppendNew() ; |
FCKAnchorsProcessor.ProcessDocument = function( document ) |
{ |
var aLinks = document.getElementsByTagName( 'A' ) ; |
var oLink ; |
var i = aLinks.length - 1 ; |
while ( i >= 0 && ( oLink = aLinks[i--] ) ) |
{ |
// If it is anchor. |
if ( oLink.name.length > 0 && ( !oLink.getAttribute('href') || oLink.getAttribute('href').length == 0 ) ) |
{ |
var oImg = FCKDocumentProcessor_CreateFakeImage( 'FCK__Anchor', oLink.cloneNode(true) ) ; |
oImg.setAttribute( '_fckanchor', 'true', 0 ) ; |
oLink.parentNode.insertBefore( oImg, oLink ) ; |
oLink.parentNode.removeChild( oLink ) ; |
} |
} |
} |
// Page Breaks |
var FCKPageBreaksProcessor = FCKDocumentProcessor.AppendNew() ; |
FCKPageBreaksProcessor.ProcessDocument = function( document ) |
{ |
var aDIVs = document.getElementsByTagName( 'DIV' ) ; |
var eDIV ; |
var i = aDIVs.length - 1 ; |
while ( i >= 0 && ( eDIV = aDIVs[i--] ) ) |
{ |
if ( eDIV.style.pageBreakAfter == 'always' && eDIV.childNodes.length == 1 && eDIV.childNodes[0].style && eDIV.childNodes[0].style.display == 'none' ) |
{ |
var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', eDIV.cloneNode(true) ) ; |
eDIV.parentNode.insertBefore( oFakeImage, eDIV ) ; |
eDIV.parentNode.removeChild( eDIV ) ; |
} |
} |
/* |
var aCenters = document.getElementsByTagName( 'CENTER' ) ; |
var oCenter ; |
var i = aCenters.length - 1 ; |
while ( i >= 0 && ( oCenter = aCenters[i--] ) ) |
{ |
if ( oCenter.style.pageBreakAfter == 'always' && oCenter.innerHTML.trim().length == 0 ) |
{ |
var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', oCenter.cloneNode(true) ) ; |
oCenter.parentNode.insertBefore( oFakeImage, oCenter ) ; |
oCenter.parentNode.removeChild( oCenter ) ; |
} |
} |
*/ |
} |
// Flash Embeds. |
var FCKFlashProcessor = FCKDocumentProcessor.AppendNew() ; |
FCKFlashProcessor.ProcessDocument = function( document ) |
{ |
/* |
Sample code: |
This is some <embed src="/UserFiles/Flash/Yellow_Runners.swf"></embed><strong>sample text</strong>. You are <a name="fred"></a> using <a href="http://www.fckeditor.net/">FCKeditor</a>. |
*/ |
var aEmbeds = document.getElementsByTagName( 'EMBED' ) ; |
var oEmbed ; |
var i = aEmbeds.length - 1 ; |
while ( i >= 0 && ( oEmbed = aEmbeds[i--] ) ) |
{ |
if ( oEmbed.src.endsWith( '.swf', true ) ) |
{ |
var oCloned = oEmbed.cloneNode( true ) ; |
// On IE, some properties are not getting clonned properly, so we |
// must fix it. Thanks to Alfonso Martinez. |
if ( FCKBrowserInfo.IsIE ) |
{ |
var oAtt ; |
if ( oAtt = oEmbed.getAttribute( 'scale' ) ) oCloned.setAttribute( 'scale', oAtt ) ; |
if ( oAtt = oEmbed.getAttribute( 'play' ) ) oCloned.setAttribute( 'play', oAtt ) ; |
if ( oAtt = oEmbed.getAttribute( 'loop' ) ) oCloned.setAttribute( 'loop', oAtt ) ; |
if ( oAtt = oEmbed.getAttribute( 'menu' ) ) oCloned.setAttribute( 'menu', oAtt ) ; |
if ( oAtt = oEmbed.getAttribute( 'wmode' ) ) oCloned.setAttribute( 'wmode', oAtt ) ; |
if ( oAtt = oEmbed.getAttribute( 'quality' ) ) oCloned.setAttribute( 'quality', oAtt ) ; |
} |
var oImg = FCKDocumentProcessor_CreateFakeImage( 'FCK__Flash', oCloned ) ; |
oImg.setAttribute( '_fckflash', 'true', 0 ) ; |
FCKFlashProcessor.RefreshView( oImg, oEmbed ) ; |
oEmbed.parentNode.insertBefore( oImg, oEmbed ) ; |
oEmbed.parentNode.removeChild( oEmbed ) ; |
// oEmbed.setAttribute( '_fcktemp', 'true', 0) ; |
// oEmbed.style.display = 'none' ; |
// oEmbed.hidden = true ; |
} |
} |
} |
FCKFlashProcessor.RefreshView = function( placholderImage, originalEmbed ) |
{ |
if ( originalEmbed.width > 0 ) |
placholderImage.style.width = FCKTools.ConvertHtmlSizeToStyle( originalEmbed.width ) ; |
if ( originalEmbed.height > 0 ) |
placholderImage.style.height = FCKTools.ConvertHtmlSizeToStyle( originalEmbed.height ) ; |
} |
FCK.GetRealElement = function( fakeElement ) |
{ |
var e = FCKTempBin.Elements[ fakeElement.getAttribute('_fckrealelement') ] ; |
if ( fakeElement.getAttribute('_fckflash') ) |
{ |
if ( fakeElement.style.width.length > 0 ) |
e.width = FCKTools.ConvertStyleSizeToHtml( fakeElement.style.width ) ; |
if ( fakeElement.style.height.length > 0 ) |
e.height = FCKTools.ConvertStyleSizeToHtml( fakeElement.style.height ) ; |
} |
return e ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcklanguagemanager.js |
---|
New file |
0,0 → 1,152 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcklanguagemanager.js |
* Defines the FCKLanguageManager object that is used for language |
* operations. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKLanguageManager = FCK.Language = new Object() ; |
FCKLanguageManager.AvailableLanguages = |
{ |
'ar' : 'Arabic', |
'bg' : 'Bulgarian', |
'bn' : 'Bengali/Bangla', |
'bs' : 'Bosnian', |
'ca' : 'Catalan', |
'cs' : 'Czech', |
'da' : 'Danish', |
'de' : 'German', |
'el' : 'Greek', |
'en' : 'English', |
'en-au' : 'English (Australia)', |
'en-ca' : 'English (Canadian)', |
'en-uk' : 'English (United Kingdom)', |
'eo' : 'Esperanto', |
'es' : 'Spanish', |
'et' : 'Estonian', |
'eu' : 'Basque', |
'fa' : 'Persian', |
'fi' : 'Finnish', |
'fo' : 'Faroese', |
'fr' : 'French', |
'gl' : 'Galician', |
'he' : 'Hebrew', |
'hi' : 'Hindi', |
'hr' : 'Croatian', |
'hu' : 'Hungarian', |
'it' : 'Italian', |
'ja' : 'Japanese', |
'km' : 'Khmer', |
'ko' : 'Korean', |
'lt' : 'Lithuanian', |
'lv' : 'Latvian', |
'mn' : 'Mongolian', |
'ms' : 'Malay', |
'nb' : 'Norwegian Bokmal', |
'nl' : 'Dutch', |
'no' : 'Norwegian', |
'pl' : 'Polish', |
'pt' : 'Portuguese (Portugal)', |
'pt-br' : 'Portuguese (Brazil)', |
'ro' : 'Romanian', |
'ru' : 'Russian', |
'sk' : 'Slovak', |
'sl' : 'Slovenian', |
'sr' : 'Serbian (Cyrillic)', |
'sr-latn' : 'Serbian (Latin)', |
'sv' : 'Swedish', |
'th' : 'Thai', |
'tr' : 'Turkish', |
'uk' : 'Ukrainian', |
'vi' : 'Vietnamese', |
'zh' : 'Chinese Traditional', |
'zh-cn' : 'Chinese Simplified' |
} |
FCKLanguageManager.GetActiveLanguage = function() |
{ |
if ( FCKConfig.AutoDetectLanguage ) |
{ |
var sUserLang ; |
// IE accepts "navigator.userLanguage" while Gecko "navigator.language". |
if ( navigator.userLanguage ) |
sUserLang = navigator.userLanguage.toLowerCase() ; |
else if ( navigator.language ) |
sUserLang = navigator.language.toLowerCase() ; |
else |
{ |
// Firefox 1.0 PR has a bug: it doens't support the "language" property. |
return FCKConfig.DefaultLanguage ; |
} |
// Some language codes are set in 5 characters, |
// like "pt-br" for Brasilian Portuguese. |
if ( sUserLang.length >= 5 ) |
{ |
sUserLang = sUserLang.substr(0,5) ; |
if ( this.AvailableLanguages[sUserLang] ) return sUserLang ; |
} |
// If the user's browser is set to, for example, "pt-br" but only the |
// "pt" language file is available then get that file. |
if ( sUserLang.length >= 2 ) |
{ |
sUserLang = sUserLang.substr(0,2) ; |
if ( this.AvailableLanguages[sUserLang] ) return sUserLang ; |
} |
} |
return this.DefaultLanguage ; |
} |
FCKLanguageManager.TranslateElements = function( targetDocument, tag, propertyToSet, encode ) |
{ |
var e = targetDocument.getElementsByTagName(tag) ; |
var sKey, s ; |
for ( var i = 0 ; i < e.length ; i++ ) |
{ |
if ( sKey = e[i].getAttribute( 'fckLang' ) ) |
{ |
if ( s = FCKLang[ sKey ] ) |
{ |
if ( encode ) |
s = FCKTools.HTMLEncode( s ) ; |
eval( 'e[i].' + propertyToSet + ' = s' ) ; |
} |
} |
} |
} |
FCKLanguageManager.TranslatePage = function( targetDocument ) |
{ |
this.TranslateElements( targetDocument, 'INPUT', 'value' ) ; |
this.TranslateElements( targetDocument, 'SPAN', 'innerHTML' ) ; |
this.TranslateElements( targetDocument, 'LABEL', 'innerHTML' ) ; |
this.TranslateElements( targetDocument, 'OPTION', 'innerHTML', true ) ; |
} |
FCKLanguageManager.Initialize = function() |
{ |
if ( this.AvailableLanguages[ FCKConfig.DefaultLanguage ] ) |
this.DefaultLanguage = FCKConfig.DefaultLanguage ; |
else |
this.DefaultLanguage = 'en' ; |
this.ActiveLanguage = new Object() ; |
this.ActiveLanguage.Code = this.GetActiveLanguage() ; |
this.ActiveLanguage.Name = this.AvailableLanguages[ this.ActiveLanguage.Code ] ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktoolbarset.js |
---|
New file |
0,0 → 1,352 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbarset.js |
* Defines the FCKToolbarSet object that is used to load and draw the |
* toolbar. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
function FCKToolbarSet_Create( overhideLocation ) |
{ |
var oToolbarSet ; |
var sLocation = overhideLocation || FCKConfig.ToolbarLocation ; |
switch ( sLocation ) |
{ |
case 'In' : |
document.getElementById( 'xToolbarRow' ).style.display = '' ; |
oToolbarSet = new FCKToolbarSet( document ) ; |
break ; |
// case 'OutTop' : |
// Not supported. |
default : |
FCK.Events.AttachEvent( 'OnBlur', FCK_OnBlur ) ; |
FCK.Events.AttachEvent( 'OnFocus', FCK_OnFocus ) ; |
var eToolbarTarget ; |
// Out:[TargetWindow]([TargetId]) |
var oOutMatch = sLocation.match( /^Out:(.+)\((\w+)\)$/ ) ; |
if ( oOutMatch ) |
{ |
eToolbarTarget = eval( 'parent.' + oOutMatch[1] ).document.getElementById( oOutMatch[2] ) ; |
} |
else |
{ |
// Out:[TargetId] |
oOutMatch = sLocation.match( /^Out:(\w+)$/ ) ; |
if ( oOutMatch ) |
eToolbarTarget = parent.document.getElementById( oOutMatch[1] ) ; |
} |
if ( !eToolbarTarget ) |
{ |
alert( 'Invalid value for "ToolbarLocation"' ) ; |
return this._Init( 'In' ) ; |
} |
// If it is a shared toolbar, it may be already available in the target element. |
if ( oToolbarSet = eToolbarTarget.__FCKToolbarSet ) |
break ; |
// Create the IFRAME that will hold the toolbar inside the target element. |
var eToolbarIFrame = FCKTools.GetElementDocument( eToolbarTarget ).createElement( 'iframe' ) ; |
eToolbarIFrame.frameBorder = 0 ; |
eToolbarIFrame.width = '100%' ; |
eToolbarIFrame.height = '10' ; |
eToolbarTarget.appendChild( eToolbarIFrame ) ; |
eToolbarIFrame.unselectable = 'on' ; |
// Write the basic HTML for the toolbar (copy from the editor main page). |
var eTargetDocument = eToolbarIFrame.contentWindow.document ; |
eTargetDocument.open() ; |
eTargetDocument.write( '<html><head><script type="text/javascript"> window.onload = window.onresize = function() { window.frameElement.height = document.body.scrollHeight ; } </script></head><body style="overflow: hidden">' + document.getElementById( 'xToolbarSpace' ).innerHTML + '</body></html>' ) ; |
eTargetDocument.close() ; |
eTargetDocument.oncontextmenu = FCKTools.CancelEvent ; |
// Load external resources (must be done here, otherwise Firefox will not |
// have the document DOM ready to be used right away. |
FCKTools.AppendStyleSheet( eTargetDocument, FCKConfig.SkinPath + 'fck_editor.css' ) ; |
oToolbarSet = eToolbarTarget.__FCKToolbarSet = new FCKToolbarSet( eTargetDocument ) ; |
oToolbarSet._IFrame = eToolbarIFrame ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( eToolbarTarget, FCKToolbarSet_Target_Cleanup ) ; |
} |
oToolbarSet.CurrentInstance = FCK ; |
FCK.AttachToOnSelectionChange( oToolbarSet.RefreshItemsState ) ; |
return oToolbarSet ; |
} |
function FCK_OnBlur( editorInstance ) |
{ |
var eToolbarSet = editorInstance.ToolbarSet ; |
if ( eToolbarSet.CurrentInstance == editorInstance ) |
eToolbarSet.Disable() ; |
} |
function FCK_OnFocus( editorInstance ) |
{ |
var oToolbarset = editorInstance.ToolbarSet ; |
var oInstance = editorInstance || FCK ; |
// Unregister the toolbar window from the current instance. |
oToolbarset.CurrentInstance.FocusManager.RemoveWindow( oToolbarset._IFrame.contentWindow ) ; |
// Set the new current instance. |
oToolbarset.CurrentInstance = oInstance ; |
// Register the toolbar window in the current instance. |
oInstance.FocusManager.AddWindow( oToolbarset._IFrame.contentWindow, true ) ; |
oToolbarset.Enable() ; |
} |
function FCKToolbarSet_Cleanup() |
{ |
this._TargetElement = null ; |
this._IFrame = null ; |
} |
function FCKToolbarSet_Target_Cleanup() |
{ |
this.__FCKToolbarSet = null ; |
} |
var FCKToolbarSet = function( targetDocument ) |
{ |
this._Document = targetDocument ; |
// Get the element that will hold the elements structure. |
this._TargetElement = targetDocument.getElementById( 'xToolbar' ) ; |
// Setup the expand and collapse handlers. |
var eExpandHandle = targetDocument.getElementById( 'xExpandHandle' ) ; |
var eCollapseHandle = targetDocument.getElementById( 'xCollapseHandle' ) ; |
eExpandHandle.title = FCKLang.ToolbarExpand ; |
eExpandHandle.onclick = FCKToolbarSet_Expand_OnClick ; |
eCollapseHandle.title = FCKLang.ToolbarCollapse ; |
eCollapseHandle.onclick = FCKToolbarSet_Collapse_OnClick ; |
// Set the toolbar state at startup. |
if ( !FCKConfig.ToolbarCanCollapse || FCKConfig.ToolbarStartExpanded ) |
this.Expand() ; |
else |
this.Collapse() ; |
// Enable/disable the collapse handler |
eCollapseHandle.style.display = FCKConfig.ToolbarCanCollapse ? '' : 'none' ; |
if ( FCKConfig.ToolbarCanCollapse ) |
eCollapseHandle.style.display = '' ; |
else |
targetDocument.getElementById( 'xTBLeftBorder' ).style.display = '' ; |
// Set the default properties. |
this.Toolbars = new Array() ; |
this.IsLoaded = false ; |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( this, FCKToolbarSet_Cleanup ) ; |
} |
function FCKToolbarSet_Expand_OnClick() |
{ |
FCK.ToolbarSet.Expand() ; |
} |
function FCKToolbarSet_Collapse_OnClick() |
{ |
FCK.ToolbarSet.Collapse() ; |
} |
FCKToolbarSet.prototype.Expand = function() |
{ |
this._ChangeVisibility( false ) ; |
} |
FCKToolbarSet.prototype.Collapse = function() |
{ |
this._ChangeVisibility( true ) ; |
} |
FCKToolbarSet.prototype._ChangeVisibility = function( collapse ) |
{ |
this._Document.getElementById( 'xCollapsed' ).style.display = collapse ? '' : 'none' ; |
this._Document.getElementById( 'xExpanded' ).style.display = collapse ? 'none' : '' ; |
if ( FCKBrowserInfo.IsGecko ) |
{ |
// I had to use "setTimeout" because Gecko was not responding in a right |
// way when calling window.onresize() directly. |
FCKTools.RunFunction( window.onresize ) ; |
} |
} |
FCKToolbarSet.prototype.Load = function( toolbarSetName ) |
{ |
this.Name = toolbarSetName ; |
this.Items = new Array() ; |
// Reset the array of toolbat items that are active only on WYSIWYG mode. |
this.ItemsWysiwygOnly = new Array() ; |
// Reset the array of toolbar items that are sensitive to the cursor position. |
this.ItemsContextSensitive = new Array() ; |
// Cleanup the target element. |
this._TargetElement.innerHTML = '' ; |
var ToolbarSet = FCKConfig.ToolbarSets[toolbarSetName] ; |
if ( !ToolbarSet ) |
{ |
alert( FCKLang.UnknownToolbarSet.replace( /%1/g, toolbarSetName ) ) ; |
return ; |
} |
this.Toolbars = new Array() ; |
for ( var x = 0 ; x < ToolbarSet.length ; x++ ) |
{ |
var oToolbarItems = ToolbarSet[x] ; |
var oToolbar ; |
if ( typeof( oToolbarItems ) == 'string' ) |
{ |
if ( oToolbarItems == '/' ) |
oToolbar = new FCKToolbarBreak() ; |
} |
else |
{ |
oToolbar = new FCKToolbar() ; |
for ( var j = 0 ; j < oToolbarItems.length ; j++ ) |
{ |
var sItem = oToolbarItems[j] ; |
if ( sItem == '-') |
oToolbar.AddSeparator() ; |
else |
{ |
var oItem = FCKToolbarItems.GetItem( sItem ) ; |
if ( oItem ) |
{ |
oToolbar.AddItem( oItem ) ; |
this.Items.push( oItem ) ; |
if ( !oItem.SourceView ) |
this.ItemsWysiwygOnly.push( oItem ) ; |
if ( oItem.ContextSensitive ) |
this.ItemsContextSensitive.push( oItem ) ; |
} |
} |
} |
// oToolbar.AddTerminator() ; |
} |
oToolbar.Create( this._TargetElement ) ; |
this.Toolbars[ this.Toolbars.length ] = oToolbar ; |
} |
FCKTools.DisableSelection( this._Document.getElementById( 'xCollapseHandle' ).parentNode ) ; |
if ( FCK.Status != FCK_STATUS_COMPLETE ) |
FCK.Events.AttachEvent( 'OnStatusChange', this.RefreshModeState ) ; |
else |
this.RefreshModeState() ; |
this.IsLoaded = true ; |
this.IsEnabled = true ; |
FCKTools.RunFunction( this.OnLoad ) ; |
} |
FCKToolbarSet.prototype.Enable = function() |
{ |
if ( this.IsEnabled ) |
return ; |
this.IsEnabled = true ; |
var aItems = this.Items ; |
for ( var i = 0 ; i < aItems.length ; i++ ) |
aItems[i].RefreshState() ; |
} |
FCKToolbarSet.prototype.Disable = function() |
{ |
if ( !this.IsEnabled ) |
return ; |
this.IsEnabled = false ; |
var aItems = this.Items ; |
for ( var i = 0 ; i < aItems.length ; i++ ) |
aItems[i].Disable() ; |
} |
FCKToolbarSet.prototype.RefreshModeState = function( editorInstance ) |
{ |
if ( FCK.Status != FCK_STATUS_COMPLETE ) |
return ; |
var oToolbarSet = editorInstance ? editorInstance.ToolbarSet : this ; |
var aItems = oToolbarSet.ItemsWysiwygOnly ; |
if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) |
{ |
// Enable all buttons that are available on WYSIWYG mode only. |
for ( var i = 0 ; i < aItems.length ; i++ ) |
aItems[i].Enable() ; |
// Refresh the buttons state. |
oToolbarSet.RefreshItemsState( editorInstance ) ; |
} |
else |
{ |
// Refresh the buttons state. |
oToolbarSet.RefreshItemsState( editorInstance ) ; |
// Disable all buttons that are available on WYSIWYG mode only. |
for ( var i = 0 ; i < aItems.length ; i++ ) |
aItems[i].Disable() ; |
} |
} |
FCKToolbarSet.prototype.RefreshItemsState = function( editorInstance ) |
{ |
var aItems = ( editorInstance ? editorInstance.ToolbarSet : this ).ItemsContextSensitive ; |
for ( var i = 0 ; i < aItems.length ; i++ ) |
aItems[i].RefreshState() ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckplugins.js |
---|
New file |
0,0 → 1,42 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckplugins.js |
* Defines the FCKPlugins object that is responsible for loading the Plugins. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKPlugins = FCK.Plugins = new Object() ; |
FCKPlugins.ItemsCount = 0 ; |
FCKPlugins.Items = new Object() ; |
FCKPlugins.Load = function() |
{ |
var oItems = FCKPlugins.Items ; |
// build the plugins collection. |
for ( var i = 0 ; i < FCKConfig.Plugins.Items.length ; i++ ) |
{ |
var oItem = FCKConfig.Plugins.Items[i] ; |
var oPlugin = oItems[ oItem[0] ] = new FCKPlugin( oItem[0], oItem[1], oItem[2] ) ; |
FCKPlugins.ItemsCount++ ; |
} |
// Load all items in the plugins collection. |
for ( var s in oItems ) |
oItems[s].Load() ; |
// This is a self destroyable function (must be called once). |
FCKPlugins.Load = null ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckselection.js |
---|
New file |
0,0 → 1,20 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckselection.js |
* Active selection functions. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKSelection = FCK.Selection = new Object() ; |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckdebug.js |
---|
New file |
0,0 → 1,77 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckdebug.js |
* Debug window control and operations. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKDebug = new Object() ; |
FCKDebug.Output = function( message, color, noParse ) |
{ |
if ( ! FCKConfig.Debug ) return ; |
if ( !noParse && message != null && isNaN( message ) ) |
message = message.replace(/</g, "<") ; |
if ( !this.DebugWindow || this.DebugWindow.closed ) |
this.DebugWindow = window.open( FCKConfig.BasePath + 'fckdebug.html', 'FCKeditorDebug', 'menubar=no,scrollbars=no,resizable=yes,location=no,toolbar=no,width=600,height=500', true ) ; |
if ( this.DebugWindow && this.DebugWindow.Output) |
{ |
try |
{ |
this.DebugWindow.Output( message, color ) ; |
} |
catch ( e ) {} // Ignore errors |
} |
} |
FCKDebug.OutputObject = function( anyObject, color ) |
{ |
if ( ! FCKConfig.Debug ) return ; |
var message ; |
if ( anyObject != null ) |
{ |
message = 'Properties of: ' + anyObject + '</b><blockquote>' ; |
for (var prop in anyObject) |
{ |
try |
{ |
var sVal = anyObject[ prop ] ? anyObject[ prop ] + '' : '[null]' ; |
message += '<b>' + prop + '</b> : ' + sVal.replace(/</g, '<') + '<br>' ; |
} |
catch (e) |
{ |
try |
{ |
message += '<b>' + prop + '</b> : [' + typeof( anyObject[ prop ] ) + ']<br>' ; |
} |
catch (e) |
{ |
message += '<b>' + prop + '</b> : [-error-]<br>' ; |
} |
} |
} |
message += '</blockquote><b>' ; |
} else |
message = 'OutputObject : Object is "null".' ; |
FCKDebug.Output( message, color, true ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckxhtml.js |
---|
New file |
0,0 → 1,390 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckxhtml.js |
* Defines the FCKXHtml object, responsible for the XHTML operations. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKXHtml = new Object() ; |
FCKXHtml.CurrentJobNum = 0 ; |
FCKXHtml.GetXHTML = function( node, includeNode, format ) |
{ |
FCKXHtmlEntities.Initialize() ; |
// Save the current IsDirty state. The XHTML processor may change the |
// original HTML, dirtying it. |
var bIsDirty = FCK.IsDirty() ; |
this._CreateNode = FCKConfig.ForceStrongEm ? FCKXHtml_CreateNode_StrongEm : FCKXHtml_CreateNode_Normal ; |
// Special blocks are blocks of content that remain untouched during the |
// process. It is used for SCRIPTs and STYLEs. |
FCKXHtml.SpecialBlocks = new Array() ; |
// Create the XML DOMDocument object. |
this.XML = FCKTools.CreateXmlObject( 'DOMDocument' ) ; |
// Add a root element that holds all child nodes. |
this.MainNode = this.XML.appendChild( this.XML.createElement( 'xhtml' ) ) ; |
FCKXHtml.CurrentJobNum++ ; |
if ( includeNode ) |
this._AppendNode( this.MainNode, node ) ; |
else |
this._AppendChildNodes( this.MainNode, node, false ) ; |
// Get the resulting XHTML as a string. |
var sXHTML = this._GetMainXmlString() ; |
this.XML = null ; |
// Strip the "XHTML" root node. |
sXHTML = sXHTML.substr( 7, sXHTML.length - 15 ).trim() ; |
// Remove the trailing <br> added by Gecko. |
if ( FCKBrowserInfo.IsGecko ) |
sXHTML = sXHTML.replace( /<br\/>$/, '' ) ; |
// Add a space in the tags with no closing tags, like <br/> -> <br /> |
sXHTML = sXHTML.replace( FCKRegexLib.SpaceNoClose, ' />'); |
if ( FCKConfig.ForceSimpleAmpersand ) |
sXHTML = sXHTML.replace( FCKRegexLib.ForceSimpleAmpersand, '&' ) ; |
if ( format ) |
sXHTML = FCKCodeFormatter.Format( sXHTML ) ; |
// Now we put back the SpecialBlocks contents. |
for ( var i = 0 ; i < FCKXHtml.SpecialBlocks.length ; i++ ) |
{ |
var oRegex = new RegExp( '___FCKsi___' + i ) ; |
sXHTML = sXHTML.replace( oRegex, FCKXHtml.SpecialBlocks[i] ) ; |
} |
// Replace entities marker with the ampersand. |
sXHTML = sXHTML.replace( FCKRegexLib.GeckoEntitiesMarker, '&' ) ; |
// Restore the IsDirty state if it was not dirty. |
if ( !bIsDirty ) |
FCK.ResetIsDirty() ; |
return sXHTML |
} |
FCKXHtml._AppendAttribute = function( xmlNode, attributeName, attributeValue ) |
{ |
if ( FCKConfig.ForceSimpleAmpersand && attributeValue.replace ) |
attributeValue = attributeValue.replace( /&/g, '___FCKAmp___' ) ; |
try |
{ |
// Create the attribute. |
var oXmlAtt = this.XML.createAttribute( attributeName ) ; |
oXmlAtt.value = attributeValue ? attributeValue : '' ; |
// Set the attribute in the node. |
xmlNode.attributes.setNamedItem( oXmlAtt ) ; |
} |
catch (e) |
{} |
} |
FCKXHtml._AppendChildNodes = function( xmlNode, htmlNode, isBlockElement ) |
{ |
var iCount = 0 ; |
var oNode = htmlNode.firstChild ; |
while ( oNode ) |
{ |
if ( this._AppendNode( xmlNode, oNode ) ) |
iCount++ ; |
oNode = oNode.nextSibling ; |
} |
if ( iCount == 0 ) |
{ |
if ( isBlockElement && FCKConfig.FillEmptyBlocks ) |
{ |
this._AppendEntity( xmlNode, 'nbsp' ) ; |
return ; |
} |
// We can't use short representation of empty elements that are not marked |
// as empty in th XHTML DTD. |
if ( !FCKRegexLib.EmptyElements.test( htmlNode.nodeName ) ) |
xmlNode.appendChild( this.XML.createTextNode('') ) ; |
} |
} |
FCKXHtml._AppendNode = function( xmlNode, htmlNode ) |
{ |
if ( !htmlNode ) |
return ; |
switch ( htmlNode.nodeType ) |
{ |
// Element Node. |
case 1 : |
// Here we found an element that is not the real element, but a |
// fake one (like the Flash placeholder image), so we must get the real one. |
if ( htmlNode.getAttribute('_fckfakelement') ) |
return FCKXHtml._AppendNode( xmlNode, FCK.GetRealElement( htmlNode ) ) ; |
// Mozilla insert custom nodes in the DOM. |
if ( FCKBrowserInfo.IsGecko && htmlNode.hasAttribute('_moz_editor_bogus_node') ) |
return false ; |
// This is for elements that are instrumental to FCKeditor and |
// must be removed from the final HTML. |
if ( htmlNode.getAttribute('_fcktemp') ) |
return false ; |
// Get the element name. |
var sNodeName = htmlNode.nodeName ; |
//Add namespace: |
if ( FCKBrowserInfo.IsIE && htmlNode.scopeName && htmlNode.scopeName != 'HTML' && htmlNode.scopeName != 'FCK' ) |
sNodeName = htmlNode.scopeName + ':' + sNodeName ; |
// Check if the node name is valid, otherwise ignore this tag. |
// If the nodeName starts with a slash, it is a orphan closing tag. |
// On some strange cases, the nodeName is empty, even if the node exists. |
if ( !FCKRegexLib.ElementName.test( sNodeName ) ) |
return false ; |
sNodeName = sNodeName.toLowerCase() ; |
if ( FCKBrowserInfo.IsGecko && sNodeName == 'br' && htmlNode.hasAttribute('type') && htmlNode.getAttribute( 'type', 2 ) == '_moz' ) |
return false ; |
// The already processed nodes must be marked to avoid then to be duplicated (bad formatted HTML). |
// So here, the "mark" is checked... if the element is Ok, then mark it. |
if ( htmlNode._fckxhtmljob && htmlNode._fckxhtmljob == FCKXHtml.CurrentJobNum ) |
return false ; |
var oNode = this._CreateNode( sNodeName ) ; |
// Add all attributes. |
FCKXHtml._AppendAttributes( xmlNode, htmlNode, oNode, sNodeName ) ; |
htmlNode._fckxhtmljob = FCKXHtml.CurrentJobNum ; |
// Tag specific processing. |
var oTagProcessor = FCKXHtml.TagProcessors[ sNodeName ] ; |
if ( oTagProcessor ) |
{ |
oNode = oTagProcessor( oNode, htmlNode, xmlNode ) ; |
if ( !oNode ) break ; |
} |
else |
this._AppendChildNodes( oNode, htmlNode, FCKRegexLib.BlockElements.test( sNodeName ) ) ; |
xmlNode.appendChild( oNode ) ; |
break ; |
// Text Node. |
case 3 : |
this._AppendTextNode( xmlNode, htmlNode.nodeValue.replaceNewLineChars(' ') ) ; |
break ; |
// Comment |
case 8 : |
// IE catches the <!DOTYPE ... > as a comment, but it has no |
// innerHTML, so we can catch it, and ignore it. |
if ( FCKBrowserInfo.IsIE && !htmlNode.innerHTML ) |
break ; |
try { xmlNode.appendChild( this.XML.createComment( htmlNode.nodeValue ) ) ; } |
catch (e) { /* Do nothing... probably this is a wrong format comment. */ } |
break ; |
// Unknown Node type. |
default : |
xmlNode.appendChild( this.XML.createComment( "Element not supported - Type: " + htmlNode.nodeType + " Name: " + htmlNode.nodeName ) ) ; |
break ; |
} |
return true ; |
} |
function FCKXHtml_CreateNode_StrongEm( nodeName ) |
{ |
switch ( nodeName ) |
{ |
case 'b' : |
nodeName = 'strong' ; |
break ; |
case 'i' : |
nodeName = 'em' ; |
break ; |
} |
return this.XML.createElement( nodeName ) ; |
} |
function FCKXHtml_CreateNode_Normal( nodeName ) |
{ |
return this.XML.createElement( nodeName ) ; |
} |
// Append an item to the SpecialBlocks array and returns the tag to be used. |
FCKXHtml._AppendSpecialItem = function( item ) |
{ |
return '___FCKsi___' + FCKXHtml.SpecialBlocks.AddItem( item ) ; |
} |
FCKXHtml._AppendEntity = function( xmlNode, entity ) |
{ |
xmlNode.appendChild( this.XML.createTextNode( '#?-:' + entity + ';' ) ) ; |
} |
FCKXHtml._AppendTextNode = function( targetNode, textValue ) |
{ |
targetNode.appendChild( this.XML.createTextNode( textValue.replace( FCKXHtmlEntities.EntitiesRegex, FCKXHtml_GetEntity ) ) ) ; |
return ; |
} |
// Retrieves a entity (internal format) for a given character. |
function FCKXHtml_GetEntity( character ) |
{ |
// We cannot simply place the entities in the text, because the XML parser |
// will translate & to &. So we use a temporary marker which is replaced |
// in the end of the processing. |
var sEntity = FCKXHtmlEntities.Entities[ character ] || ( '#' + character.charCodeAt(0) ) ; |
return '#?-:' + sEntity + ';' ; |
} |
// An object that hold tag specific operations. |
FCKXHtml.TagProcessors = new Object() ; |
FCKXHtml.TagProcessors['img'] = function( node, htmlNode ) |
{ |
// The "ALT" attribute is required in XHTML. |
if ( ! node.attributes.getNamedItem( 'alt' ) ) |
FCKXHtml._AppendAttribute( node, 'alt', '' ) ; |
var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ; |
if ( sSavedUrl != null ) |
FCKXHtml._AppendAttribute( node, 'src', sSavedUrl ) ; |
return node ; |
} |
FCKXHtml.TagProcessors['a'] = function( node, htmlNode ) |
{ |
var sSavedUrl = htmlNode.getAttribute( '_fcksavedurl' ) ; |
if ( sSavedUrl != null ) |
FCKXHtml._AppendAttribute( node, 'href', sSavedUrl ) ; |
FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; |
// Firefox may create empty tags when deleting the selection in some special cases (SF-BUG 1556878). |
if ( node.childNodes.length == 0 && !node.getAttribute( 'name' ) ) |
return false ; |
return node ; |
} |
FCKXHtml.TagProcessors['script'] = function( node, htmlNode ) |
{ |
// The "TYPE" attribute is required in XHTML. |
if ( ! node.attributes.getNamedItem( 'type' ) ) |
FCKXHtml._AppendAttribute( node, 'type', 'text/javascript' ) ; |
node.appendChild( FCKXHtml.XML.createTextNode( FCKXHtml._AppendSpecialItem( htmlNode.text ) ) ) ; |
return node ; |
} |
FCKXHtml.TagProcessors['style'] = function( node, htmlNode ) |
{ |
// The "TYPE" attribute is required in XHTML. |
if ( ! node.attributes.getNamedItem( 'type' ) ) |
FCKXHtml._AppendAttribute( node, 'type', 'text/css' ) ; |
node.appendChild( FCKXHtml.XML.createTextNode( FCKXHtml._AppendSpecialItem( htmlNode.innerHTML ) ) ) ; |
return node ; |
} |
FCKXHtml.TagProcessors['title'] = function( node, htmlNode ) |
{ |
node.appendChild( FCKXHtml.XML.createTextNode( FCK.EditorDocument.title ) ) ; |
return node ; |
} |
FCKXHtml.TagProcessors['table'] = function( node, htmlNode ) |
{ |
// There is a trick to show table borders when border=0. We add to the |
// table class the FCK__ShowTableBorders rule. So now we must remove it. |
var oClassAtt = node.attributes.getNamedItem( 'class' ) ; |
if ( oClassAtt && FCKRegexLib.TableBorderClass.test( oClassAtt.nodeValue ) ) |
{ |
var sClass = oClassAtt.nodeValue.replace( FCKRegexLib.TableBorderClass, '' ) ; |
if ( sClass.length == 0 ) |
node.attributes.removeNamedItem( 'class' ) ; |
else |
FCKXHtml._AppendAttribute( node, 'class', sClass ) ; |
} |
FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; |
return node ; |
} |
// Fix nested <ul> and <ol>. |
FCKXHtml.TagProcessors['ol'] = FCKXHtml.TagProcessors['ul'] = function( node, htmlNode, targetNode ) |
{ |
if ( htmlNode.innerHTML.trim().length == 0 ) |
return ; |
var ePSibling = targetNode.lastChild ; |
if ( ePSibling && ePSibling.nodeType == 3 ) |
ePSibling = ePSibling.previousSibling ; |
if ( ePSibling && ePSibling.nodeName.toUpperCase() == 'LI' ) |
{ |
htmlNode._fckxhtmljob = null ; |
FCKXHtml._AppendNode( ePSibling, htmlNode ) ; |
return ; |
} |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
FCKXHtml.TagProcessors['span'] = function( node, htmlNode ) |
{ |
// Firefox may create empty tags when deleting the selection in some special cases (SF-BUG 1084404). |
if ( htmlNode.innerHTML.length == 0 ) |
return false ; |
FCKXHtml._AppendChildNodes( node, htmlNode, false ) ; |
return node ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckselection_gecko.js |
---|
New file |
0,0 → 1,144 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckselection_gecko.js |
* Active selection functions. (Gecko specific implementation) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// Get the selection type (like document.select.type in IE). |
FCKSelection.GetType = function() |
{ |
// if ( ! this._Type ) |
// { |
// By default set the type to "Text". |
this._Type = 'Text' ; |
// Check if the actual selection is a Control (IMG, TABLE, HR, etc...). |
var oSel ; |
try { oSel = FCK.EditorWindow.getSelection() ; } |
catch (e) {} |
if ( oSel && oSel.rangeCount == 1 ) |
{ |
var oRange = oSel.getRangeAt(0) ; |
if ( oRange.startContainer == oRange.endContainer && (oRange.endOffset - oRange.startOffset) == 1 && oRange.startContainer.nodeType != Node.TEXT_NODE ) |
this._Type = 'Control' ; |
} |
// } |
return this._Type ; |
} |
// Retrieves the selected element (if any), just in the case that a single |
// element (object like and image or a table) is selected. |
FCKSelection.GetSelectedElement = function() |
{ |
if ( this.GetType() == 'Control' ) |
{ |
var oSel = FCK.EditorWindow.getSelection() ; |
return oSel.anchorNode.childNodes[ oSel.anchorOffset ] ; |
} |
} |
FCKSelection.GetParentElement = function() |
{ |
if ( this.GetType() == 'Control' ) |
return FCKSelection.GetSelectedElement().parentNode ; |
else |
{ |
var oSel = FCK.EditorWindow.getSelection() ; |
if ( oSel ) |
{ |
var oNode = oSel.anchorNode ; |
while ( oNode && oNode.nodeType != 1 ) |
oNode = oNode.parentNode ; |
return oNode ; |
} |
} |
} |
FCKSelection.SelectNode = function( element ) |
{ |
// FCK.Focus() ; |
var oRange = FCK.EditorDocument.createRange() ; |
oRange.selectNode( element ) ; |
var oSel = FCK.EditorWindow.getSelection() ; |
oSel.removeAllRanges() ; |
oSel.addRange( oRange ) ; |
} |
FCKSelection.Collapse = function( toStart ) |
{ |
var oSel = FCK.EditorWindow.getSelection() ; |
if ( toStart == null || toStart === true ) |
oSel.collapseToStart() ; |
else |
oSel.collapseToEnd() ; |
} |
// The "nodeTagName" parameter must be Upper Case. |
FCKSelection.HasAncestorNode = function( nodeTagName ) |
{ |
var oContainer = this.GetSelectedElement() ; |
if ( ! oContainer && FCK.EditorWindow ) |
{ |
try { oContainer = FCK.EditorWindow.getSelection().getRangeAt(0).startContainer ; } |
catch(e){} |
} |
while ( oContainer ) |
{ |
if ( oContainer.nodeType == 1 && oContainer.tagName == nodeTagName ) return true ; |
oContainer = oContainer.parentNode ; |
} |
return false ; |
} |
// The "nodeTagName" parameter must be Upper Case. |
FCKSelection.MoveToAncestorNode = function( nodeTagName ) |
{ |
var oNode ; |
var oContainer = this.GetSelectedElement() ; |
if ( ! oContainer ) |
oContainer = FCK.EditorWindow.getSelection().getRangeAt(0).startContainer ; |
while ( oContainer ) |
{ |
if ( oContainer.tagName == nodeTagName ) |
return oContainer ; |
oContainer = oContainer.parentNode ; |
} |
return null ; |
} |
FCKSelection.Delete = function() |
{ |
// Gets the actual selection. |
var oSel = FCK.EditorWindow.getSelection() ; |
// Deletes the actual selection contents. |
for ( var i = 0 ; i < oSel.rangeCount ; i++ ) |
{ |
oSel.getRangeAt(i).deleteContents() ; |
} |
return oSel ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckcodeformatter.js |
---|
New file |
0,0 → 1,96 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckcodeformatter.js |
* Format the HTML. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKCodeFormatter = new Object() ; |
FCKCodeFormatter.Init = function() |
{ |
var oRegex = this.Regex = new Object() ; |
// Regex for line breaks. |
oRegex.BlocksOpener = /\<(P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TITLE|META|LINK|BASE|SCRIPT|LINK|TD|TH|AREA|OPTION)[^\>]*\>/gi ; |
oRegex.BlocksCloser = /\<\/(P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|TITLE|META|LINK|BASE|SCRIPT|LINK|TD|TH|AREA|OPTION)[^\>]*\>/gi ; |
oRegex.NewLineTags = /\<(BR|HR)[^\>]*\>/gi ; |
oRegex.MainTags = /\<\/?(HTML|HEAD|BODY|FORM|TABLE|TBODY|THEAD|TR)[^\>]*\>/gi ; |
oRegex.LineSplitter = /\s*\n+\s*/g ; |
// Regex for indentation. |
oRegex.IncreaseIndent = /^\<(HTML|HEAD|BODY|FORM|TABLE|TBODY|THEAD|TR|UL|OL)[ \/\>]/i ; |
oRegex.DecreaseIndent = /^\<\/(HTML|HEAD|BODY|FORM|TABLE|TBODY|THEAD|TR|UL|OL)[ \>]/i ; |
oRegex.FormatIndentatorRemove = new RegExp( '^' + FCKConfig.FormatIndentator ) ; |
oRegex.ProtectedTags = /(<PRE[^>]*>)([\s\S]*?)(<\/PRE>)/gi ; |
} |
FCKCodeFormatter._ProtectData = function( outer, opener, data, closer ) |
{ |
return opener + '___FCKpd___' + FCKCodeFormatter.ProtectedData.AddItem( data ) + closer ; |
} |
FCKCodeFormatter.Format = function( html ) |
{ |
if ( !this.Regex ) |
this.Init() ; |
// Protected content that remain untouched during the |
// process go in the following array. |
FCKCodeFormatter.ProtectedData = new Array() ; |
var sFormatted = html.replace( this.Regex.ProtectedTags, FCKCodeFormatter._ProtectData ) ; |
// Line breaks. |
sFormatted = sFormatted.replace( this.Regex.BlocksOpener, '\n$&' ) ; ; |
sFormatted = sFormatted.replace( this.Regex.BlocksCloser, '$&\n' ) ; |
sFormatted = sFormatted.replace( this.Regex.NewLineTags, '$&\n' ) ; |
sFormatted = sFormatted.replace( this.Regex.MainTags, '\n$&\n' ) ; |
// Indentation. |
var sIndentation = '' ; |
var asLines = sFormatted.split( this.Regex.LineSplitter ) ; |
sFormatted = '' ; |
for ( var i = 0 ; i < asLines.length ; i++ ) |
{ |
var sLine = asLines[i] ; |
if ( sLine.length == 0 ) |
continue ; |
if ( this.Regex.DecreaseIndent.test( sLine ) ) |
sIndentation = sIndentation.replace( this.Regex.FormatIndentatorRemove, '' ) ; |
sFormatted += sIndentation + sLine + '\n' ; |
if ( this.Regex.IncreaseIndent.test( sLine ) ) |
sIndentation += FCKConfig.FormatIndentator ; |
} |
// Now we put back the protected data. |
for ( var i = 0 ; i < FCKCodeFormatter.ProtectedData.length ; i++ ) |
{ |
var oRegex = new RegExp( '___FCKpd___' + i ) ; |
sFormatted = sFormatted.replace( oRegex, FCKCodeFormatter.ProtectedData[i].replace( /\$/g, '$$$$' ) ) ; |
} |
return sFormatted.trim() ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckdialog.js |
---|
New file |
0,0 → 1,34 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckdialog.js |
* Dialog windows operations. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKDialog = new Object() ; |
// This method opens a dialog window using the standard dialog template. |
FCKDialog.OpenDialog = function( dialogName, dialogTitle, dialogPage, width, height, customValue, parentWindow, resizable ) |
{ |
// Setup the dialog info. |
var oDialogInfo = new Object() ; |
oDialogInfo.Title = dialogTitle ; |
oDialogInfo.Page = dialogPage ; |
oDialogInfo.Editor = window ; |
oDialogInfo.CustomValue = customValue ; // Optional |
var sUrl = FCKConfig.BasePath + 'fckdialog.html' ; |
this.Show( oDialogInfo, dialogName, sUrl, width, height, parentWindow, resizable ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_1.js |
---|
New file |
0,0 → 1,410 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_1.js |
* This is the first part of the "FCK" object creation. This is the main |
* object that represents an editor instance. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCK_StartupValue ; |
FCK.Events = new FCKEvents( FCK ) ; |
FCK.Toolbar = null ; |
FCK.HasFocus = false ; |
FCK.StartEditor = function() |
{ |
FCK.TempBaseTag = FCKConfig.BaseHref.length > 0 ? '<base href="' + FCKConfig.BaseHref + '" _fcktemp="true"></base>' : '' ; |
FCK.EditingArea = new FCKEditingArea( document.getElementById( 'xEditingArea' ) ) ; |
// Set the editor's startup contents |
this.SetHTML( FCKTools.GetLinkedFieldValue() ) ; |
} |
FCK.Focus = function() |
{ |
FCK.EditingArea.Focus() ; |
} |
FCK.SetStatus = function( newStatus ) |
{ |
this.Status = newStatus ; |
if ( newStatus == FCK_STATUS_ACTIVE ) |
{ |
FCKFocusManager.AddWindow( window, true ) ; |
if ( FCKBrowserInfo.IsIE ) |
FCKFocusManager.AddWindow( window.frameElement, true ) ; |
// Force the focus in the editor. |
if ( FCKConfig.StartupFocus ) |
FCK.Focus() ; |
} |
this.Events.FireEvent( 'OnStatusChange', newStatus ) ; |
} |
// GetHTML is Deprecated : returns the same value as GetXHTML. |
FCK.GetHTML = FCK.GetXHTML = function( format ) |
{ |
// We assume that if the user is in source editing, the editor value must |
// represent the exact contents of the source, as the user wanted it to be. |
if ( FCK.EditMode == FCK_EDITMODE_SOURCE ) |
return FCK.EditingArea.Textarea.value ; |
var sXHTML ; |
var oDoc = FCK.EditorDocument ; |
if ( FCKConfig.FullPage ) |
sXHTML = FCKXHtml.GetXHTML( oDoc.getElementsByTagName( 'html' )[0], true, format ) ; |
else |
{ |
if ( FCKConfig.IgnoreEmptyParagraphValue && oDoc.body.innerHTML == '<P> </P>' ) |
sXHTML = '' ; |
else |
sXHTML = FCKXHtml.GetXHTML( oDoc.body, false, format ) ; |
} |
// Restore protected attributes. |
sXHTML = FCK.ProtectEventsRestore( sXHTML ) ; |
if ( FCKBrowserInfo.IsIE ) |
sXHTML = sXHTML.replace( FCKRegexLib.ToReplace, '$1' ) ; |
if ( FCK.DocTypeDeclaration && FCK.DocTypeDeclaration.length > 0 ) |
sXHTML = FCK.DocTypeDeclaration + '\n' + sXHTML ; |
if ( FCK.XmlDeclaration && FCK.XmlDeclaration.length > 0 ) |
sXHTML = FCK.XmlDeclaration + '\n' + sXHTML ; |
return FCKConfig.ProtectedSource.Revert( sXHTML ) ; |
} |
FCK.UpdateLinkedField = function() |
{ |
FCK.LinkedField.value = FCK.GetXHTML( FCKConfig.FormatOutput ) ; |
FCK.Events.FireEvent( 'OnAfterLinkedFieldUpdate' ) ; |
} |
FCK.RegisteredDoubleClickHandlers = new Object() ; |
FCK.OnDoubleClick = function( element ) |
{ |
var oHandler = FCK.RegisteredDoubleClickHandlers[ element.tagName ] ; |
if ( oHandler ) |
oHandler( element ) ; |
} |
// Register objects that can handle double click operations. |
FCK.RegisterDoubleClickHandler = function( handlerFunction, tag ) |
{ |
FCK.RegisteredDoubleClickHandlers[ tag.toUpperCase() ] = handlerFunction ; |
} |
FCK.OnAfterSetHTML = function() |
{ |
FCKDocumentProcessor.Process( FCK.EditorDocument ) ; |
FCKUndo.SaveUndoStep() ; |
FCK.Events.FireEvent( 'OnSelectionChange' ) ; |
FCK.Events.FireEvent( 'OnAfterSetHTML' ) ; |
} |
// Saves URLs on links and images on special attributes, so they don't change when |
// moving around. |
FCK.ProtectUrls = function( html ) |
{ |
// <A> href |
html = html.replace( FCKRegexLib.ProtectUrlsA , '$1$4$2$3$5$2 _fcksavedurl=$2$3$5$2' ) ; |
// <IMG> src |
html = html.replace( FCKRegexLib.ProtectUrlsImg , '$1$4$2$3$5$2 _fcksavedurl=$2$3$5$2' ) ; |
return html ; |
} |
// Saves event attributes (like onclick) so they don't get executed while |
// editing. |
FCK.ProtectEvents = function( html ) |
{ |
return html.replace( FCKRegexLib.TagsWithEvent, _FCK_ProtectEvents_ReplaceTags ) ; |
} |
// Replace all events attributes (like onclick). |
function _FCK_ProtectEvents_ReplaceTags( tagMatch ) |
{ |
return tagMatch.replace( FCKRegexLib.EventAttributes, _FCK_ProtectEvents_ReplaceEvents ) ; |
} |
// Replace an event attribute with its respective __fckprotectedatt attribute. |
// The original event markup will be encoded and saved as the value of the new |
// attribute. |
function _FCK_ProtectEvents_ReplaceEvents( eventMatch, attName ) |
{ |
return ' ' + attName + '_fckprotectedatt="' + eventMatch.ReplaceAll( [/&/g,/'/g,/"/g,/=/g,/</g,/>/g,/\r/g,/\n/g], [''',''','"','=','<','>',' ',' '] ) + '"' ; |
} |
FCK.ProtectEventsRestore = function( html ) |
{ |
return html.replace( FCKRegexLib.ProtectedEvents, _FCK_ProtectEvents_RestoreEvents ) ; |
} |
function _FCK_ProtectEvents_RestoreEvents( match, encodedOriginal ) |
{ |
return encodedOriginal.ReplaceAll( [/'/g,/"/g,/=/g,/</g,/>/g,/ /g,/ /g,/'/g], ["'",'"','=','<','>','\r','\n','&'] ) ; |
} |
FCK.IsDirty = function() |
{ |
return ( FCK_StartupValue != FCK.EditorDocument.body.innerHTML ) ; |
} |
FCK.ResetIsDirty = function() |
{ |
if ( FCK.EditorDocument.body ) |
FCK_StartupValue = FCK.EditorDocument.body.innerHTML ; |
} |
FCK.SetHTML = function( html ) |
{ |
this.EditingArea.Mode = FCK.EditMode ; |
if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) |
{ |
html = FCKConfig.ProtectedSource.Protect( html ) ; |
html = FCK.ProtectEvents( html ) ; |
html = FCK.ProtectUrls( html ) ; |
// Firefox can't handle correctly the editing of the STRONG and EM tags. |
// We must replace them with B and I. |
if ( FCKBrowserInfo.IsGecko ) |
{ |
html = html.replace( FCKRegexLib.StrongOpener, '<b$1' ) ; |
html = html.replace( FCKRegexLib.StrongCloser, '<\/b>' ) ; |
html = html.replace( FCKRegexLib.EmOpener, '<i$1' ) ; |
html = html.replace( FCKRegexLib.EmCloser, '<\/i>' ) ; |
} |
else if ( FCKBrowserInfo.IsIE ) |
{ |
// IE doesn't support <abbr> and it breaks it. Let's protect it. |
html = html.replace( FCKRegexLib.AbbrOpener, '<FCK:abbr$1' ) ; |
html = html.replace( FCKRegexLib.AbbrCloser, '<\/FCK:abbr>' ) ; |
} |
var sHtml = '' ; |
if ( FCKConfig.FullPage ) |
{ |
// The HTML must be fixed if the <head> is not available. |
if ( !FCKRegexLib.HeadOpener.test( html ) ) |
{ |
// Check if the <html> is available. |
if ( !FCKRegexLib.HtmlOpener.test( html ) ) |
html = '<html dir="' + FCKConfig.ContentLangDirection + '">' + html + '</html>' ; |
// Add the <head>. |
html = html.replace( FCKRegexLib.HtmlOpener, '$&<head></head>' ) ; |
} |
// Save the DOCTYPE. |
FCK.DocTypeDeclaration = html.match( FCKRegexLib.DocTypeTag ) ; |
if ( FCKBrowserInfo.IsIE ) |
sHtml = FCK._GetBehaviorsStyle() ; |
else if ( FCKConfig.ShowBorders ) |
sHtml = '<link href="' + FCKConfig.FullBasePath + 'css/fck_showtableborders_gecko.css" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
sHtml += '<link href="' + FCKConfig.FullBasePath + 'css/fck_internal.css' + '" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
sHtml = html.replace( FCKRegexLib.HeadCloser, sHtml + '$&' ) ; |
// Insert the base tag (FCKConfig.BaseHref), if not exists in the source. |
if ( FCK.TempBaseTag.length > 0 && !FCKRegexLib.HasBaseTag.test( html ) ) |
sHtml = sHtml.replace( FCKRegexLib.HeadOpener, '$&' + FCK.TempBaseTag ) ; |
} |
else |
{ |
sHtml = |
FCKConfig.DocType + |
'<html dir="' + FCKConfig.ContentLangDirection + '"' ; |
// On IE, if you are use a DOCTYPE differenft of HTML 4 (like |
// XHTML), you must force the vertical scroll to show, otherwise |
// the horizontal one may appear when the page needs vertical scrolling. |
if ( FCKBrowserInfo.IsIE && !FCKRegexLib.Html4DocType.test( FCKConfig.DocType ) ) |
sHtml += ' style="overflow-y: scroll"' ; |
sHtml += |
'><head><title></title>' + |
this._GetEditorAreaStyleTags() + |
'<link href="' + FCKConfig.FullBasePath + 'css/fck_internal.css' + '" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
if ( FCKBrowserInfo.IsIE ) |
sHtml += FCK._GetBehaviorsStyle() ; |
else if ( FCKConfig.ShowBorders ) |
sHtml += '<link href="' + FCKConfig.FullBasePath + 'css/fck_showtableborders_gecko.css" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
sHtml += FCK.TempBaseTag ; |
sHtml += '</head><body>' ; |
if ( FCKBrowserInfo.IsGecko && ( html.length == 0 || FCKRegexLib.EmptyParagraph.test( html ) ) ) |
sHtml += GECKO_BOGUS ; |
else |
sHtml += html ; |
sHtml += '</body></html>' ; |
} |
this.EditingArea.OnLoad = FCK_EditingArea_OnLoad ; |
this.EditingArea.Start( sHtml ) ; |
} |
else |
{ |
this.EditingArea.OnLoad = null ; |
this.EditingArea.Start( html ) ; |
// Enables the context menu in the textarea. |
this.EditingArea.Textarea._FCKShowContextMenu = true ; |
} |
if ( FCKBrowserInfo.IsGecko ) |
window.onresize() ; |
} |
function FCK_EditingArea_OnLoad() |
{ |
// Get the editor's window and document (DOM) |
FCK.EditorWindow = FCK.EditingArea.Window ; |
FCK.EditorDocument = FCK.EditingArea.Document ; |
FCK.InitializeBehaviors() ; |
FCK.OnAfterSetHTML() ; |
// Check if it is not a startup call, otherwise complete the startup. |
if ( FCK.Status != FCK_STATUS_NOTLOADED ) |
return ; |
// Save the startup value for the "IsDirty()" check. |
FCK.ResetIsDirty() ; |
// Attach the editor to the form onsubmit event |
FCKTools.AttachToLinkedFieldFormSubmit( FCK.UpdateLinkedField ) ; |
FCK.SetStatus( FCK_STATUS_ACTIVE ) ; |
} |
FCK._GetEditorAreaStyleTags = function() |
{ |
var sTags = '' ; |
var aCSSs = FCKConfig.EditorAreaCSS ; |
for ( var i = 0 ; i < aCSSs.length ; i++ ) |
sTags += '<link href="' + aCSSs[i] + '" rel="stylesheet" type="text/css" />' ; |
return sTags ; |
} |
// # Focus Manager: Manages the focus in the editor. |
var FCKFocusManager = FCK.FocusManager = new Object() ; |
FCKFocusManager.IsLocked = false ; |
FCK.HasFocus = false ; |
FCKFocusManager.AddWindow = function( win, sendToEditingArea ) |
{ |
var oTarget ; |
if ( FCKBrowserInfo.IsIE ) |
oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ; |
else |
oTarget = win.document ; |
FCKTools.AddEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ; |
FCKTools.AddEventListener( oTarget, 'focus', sendToEditingArea ? FCKFocusManager_Win_OnFocus_Area : FCKFocusManager_Win_OnFocus ) ; |
} |
FCKFocusManager.RemoveWindow = function( win ) |
{ |
if ( FCKBrowserInfo.IsIE ) |
oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ; |
else |
oTarget = win.document ; |
FCKTools.RemoveEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ; |
FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus_Area ) ; |
FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus ) ; |
} |
FCKFocusManager.Lock = function() |
{ |
this.IsLocked = true ; |
} |
FCKFocusManager.Unlock = function() |
{ |
if ( this._HasPendingBlur ) |
FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ; |
this.IsLocked = false ; |
} |
FCKFocusManager._ResetTimer = function() |
{ |
this._HasPendingBlur = false ; |
if ( this._Timer ) |
{ |
window.clearTimeout( this._Timer ) ; |
delete this._Timer ; |
} |
} |
function FCKFocusManager_Win_OnBlur() |
{ |
if ( typeof(FCK) != 'undefined' && FCK.HasFocus ) |
{ |
FCKFocusManager._ResetTimer() ; |
FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ; |
} |
} |
function FCKFocusManager_FireOnBlur() |
{ |
if ( FCKFocusManager.IsLocked ) |
FCKFocusManager._HasPendingBlur = true ; |
else |
{ |
FCK.HasFocus = false ; |
FCK.Events.FireEvent( "OnBlur" ) ; |
} |
} |
function FCKFocusManager_Win_OnFocus_Area() |
{ |
FCKFocusManager_Win_OnFocus() ; |
FCK.Focus() ; |
} |
function FCKFocusManager_Win_OnFocus() |
{ |
FCKFocusManager._ResetTimer() ; |
if ( !FCK.HasFocus && !FCKFocusManager.IsLocked ) |
{ |
FCK.HasFocus = true ; |
FCK.Events.FireEvent( "OnFocus" ) ; |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktools.js |
---|
New file |
0,0 → 1,236 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktools.js |
* Utility functions. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKTools = new Object() ; |
FCKTools.AppendStyleSheet = function( documentElement, cssFileUrlOrArray ) |
{ |
if ( typeof( cssFileUrlOrArray ) == 'string' ) |
return this._AppendStyleSheet( documentElement, cssFileUrlOrArray ) ; |
else |
{ |
for ( var i = 0 ; i < cssFileUrlOrArray.length ; i++ ) |
this._AppendStyleSheet( documentElement, cssFileUrlOrArray[i] ) ; |
} |
} |
/** |
* Gets the value of the hidden INPUT element that is associated to the editor. |
* This element has its ID set to the editor's instance name so the user refers |
* to the instance name when getting the posted data. |
*/ |
FCKTools.GetLinkedFieldValue = function() |
{ |
return FCK.LinkedField.value ; |
} |
/** |
* Attachs a function call to the submit event of the linked field form. This |
* function us generally used to update the linked field value before |
* submitting the form. |
*/ |
FCKTools.AttachToLinkedFieldFormSubmit = function( functionPointer ) |
{ |
// Gets the linked field form |
var oForm = FCK.LinkedField.form ; |
// Return now if no form is available |
if (!oForm) return ; |
// Attaches the functionPointer call to the onsubmit event |
if ( FCKBrowserInfo.IsIE ) |
oForm.attachEvent( "onsubmit", functionPointer ) ; |
else |
oForm.addEventListener( 'submit', functionPointer, false ) ; |
//** |
// Attaches the functionPointer call to the submit method |
// This is done because IE doesn't fire onsubmit when the submit method is called |
// BEGIN -- |
// Creates a Array in the form object that will hold all Attached function call |
// (in the case there are more than one editor in the same page) |
if (! oForm.updateFCKeditor) oForm.updateFCKeditor = new Array() ; |
// Adds the function pointer to the array of functions to call when "submit" is called |
oForm.updateFCKeditor[oForm.updateFCKeditor.length] = functionPointer ; |
// Switches the original submit method with a new one that first call all functions |
// on the above array and the call the original submit |
// IE sees it oForm.submit function as an 'object'. |
if (! oForm.originalSubmit && ( typeof( oForm.submit ) == 'function' || ( !oForm.submit.tagName && !oForm.submit.length ) ) ) |
{ |
// Creates a copy of the original submit |
oForm.originalSubmit = oForm.submit ; |
// Creates our replacement for the submit |
oForm.submit = FCKTools_SubmitReplacer ; |
} |
// END -- |
} |
function FCKTools_SubmitReplacer() |
{ |
if (this.updateFCKeditor) |
{ |
// Calls all functions in the functions array |
for (var i = 0 ; i < this.updateFCKeditor.length ; i++) |
this.updateFCKeditor[i]() ; |
} |
// Calls the original "submit" |
this.originalSubmit() ; |
} |
// Get the window object where the element is placed in. |
FCKTools.GetElementWindow = function( element ) |
{ |
return this.GetDocumentWindow( this.GetElementDocument( element ) ) ; |
} |
FCKTools.GetDocumentWindow = function( doc ) |
{ |
// With Safari, there is not way to retrieve the window from the document, so we must fix it. |
if ( FCKBrowserInfo.IsSafari && !doc.parentWindow ) |
this.FixDocumentParentWindow( window.top ) ; |
return doc.parentWindow || doc.defaultView ; |
} |
/* |
This is a Safari specific function that fix the reference to the parent |
window from the document object. |
*/ |
FCKTools.FixDocumentParentWindow = function( targetWindow ) |
{ |
targetWindow.document.parentWindow = targetWindow ; |
for ( var i = 0 ; i < targetWindow.frames.length ; i++ ) |
FCKTools.FixDocumentParentWindow( targetWindow.frames[i] ) ; |
} |
FCKTools.GetParentWindow = function( document ) |
{ |
return document.contentWindow ? document.contentWindow : document.parentWindow ; |
} |
FCKTools.HTMLEncode = function( text ) |
{ |
if ( !text ) |
return '' ; |
text = text.replace( /&/g, '&' ) ; |
text = text.replace( /</g, '<' ) ; |
text = text.replace( />/g, '>' ) ; |
return text ; |
} |
/** |
* Adds an option to a SELECT element. |
*/ |
FCKTools.AddSelectOption = function( selectElement, optionText, optionValue ) |
{ |
var oOption = FCKTools.GetElementDocument( selectElement ).createElement( "OPTION" ) ; |
oOption.text = optionText ; |
oOption.value = optionValue ; |
selectElement.options.add(oOption) ; |
return oOption ; |
} |
FCKTools.RunFunction = function( func, thisObject, paramsArray, timerWindow ) |
{ |
if ( func ) |
this.SetTimeout( func, 0, thisObject, paramsArray, timerWindow ) ; |
} |
FCKTools.SetTimeout = function( func, milliseconds, thisObject, paramsArray, timerWindow ) |
{ |
return ( timerWindow || window ).setTimeout( |
function() |
{ |
if ( paramsArray ) |
func.apply( thisObject, [].concat( paramsArray ) ) ; |
else |
func.apply( thisObject ) ; |
}, |
milliseconds ) ; |
} |
FCKTools.SetInterval = function( func, milliseconds, thisObject, paramsArray, timerWindow ) |
{ |
return ( timerWindow || window ).setInterval( |
function() |
{ |
func.apply( thisObject, paramsArray || [] ) ; |
}, |
milliseconds ) ; |
} |
FCKTools.ConvertStyleSizeToHtml = function( size ) |
{ |
return size.endsWith( '%' ) ? size : parseInt( size ) ; |
} |
FCKTools.ConvertHtmlSizeToStyle = function( size ) |
{ |
return size.endsWith( '%' ) ? size : ( size + 'px' ) ; |
} |
// START iCM MODIFICATIONS |
// Amended to accept a list of one or more ascensor tag names |
// Amended to check the element itself before working back up through the parent hierarchy |
FCKTools.GetElementAscensor = function( element, ascensorTagNames ) |
{ |
// var e = element.parentNode ; |
var e = element ; |
var lstTags = "," + ascensorTagNames.toUpperCase() + "," ; |
while ( e ) |
{ |
if ( lstTags.indexOf( "," + e.nodeName.toUpperCase() + "," ) != -1 ) |
return e ; |
e = e.parentNode ; |
} |
return null ; |
} |
// END iCM MODIFICATIONS |
FCKTools.CreateEventListener = function( func, params ) |
{ |
var f = function() |
{ |
var aAllParams = [] ; |
for ( var i = 0 ; i < arguments.length ; i++ ) |
aAllParams.push( arguments[i] ) ; |
func.apply( this, aAllParams.concat( params ) ) ; |
} |
return f ; |
} |
FCKTools.GetElementDocument = function ( element ) |
{ |
return element.ownerDocument || element.document ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckxhtmlentities.js |
---|
New file |
0,0 → 1,340 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckxhtmlentities.js |
* This file define the HTML entities handled by the editor. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKXHtmlEntities = new Object() ; |
FCKXHtmlEntities.Initialize = function() |
{ |
if ( FCKXHtmlEntities.Entities ) |
return ; |
var sChars = '' ; |
if ( FCKConfig.ProcessHTMLEntities ) |
{ |
FCKXHtmlEntities.Entities = { |
// Latin-1 Entities |
' ':'nbsp', |
'¡':'iexcl', |
'¢':'cent', |
'£':'pound', |
'¤':'curren', |
'¥':'yen', |
'¦':'brvbar', |
'§':'sect', |
'¨':'uml', |
'©':'copy', |
'ª':'ordf', |
'«':'laquo', |
'¬':'not', |
'':'shy', |
'®':'reg', |
'¯':'macr', |
'°':'deg', |
'±':'plusmn', |
'²':'sup2', |
'³':'sup3', |
'´':'acute', |
'µ':'micro', |
'¶':'para', |
'·':'middot', |
'¸':'cedil', |
'¹':'sup1', |
'º':'ordm', |
'»':'raquo', |
'¼':'frac14', |
'½':'frac12', |
'¾':'frac34', |
'¿':'iquest', |
'×':'times', |
'÷':'divide', |
// Symbols |
'ƒ':'fnof', |
'•':'bull', |
'…':'hellip', |
'′':'prime', |
'″':'Prime', |
'‾':'oline', |
'⁄':'frasl', |
'℘':'weierp', |
'ℑ':'image', |
'ℜ':'real', |
'™':'trade', |
'ℵ':'alefsym', |
'←':'larr', |
'↑':'uarr', |
'→':'rarr', |
'↓':'darr', |
'↔':'harr', |
'↵':'crarr', |
'⇐':'lArr', |
'⇑':'uArr', |
'⇒':'rArr', |
'⇓':'dArr', |
'⇔':'hArr', |
'∀':'forall', |
'∂':'part', |
'∃':'exist', |
'∅':'empty', |
'∇':'nabla', |
'∈':'isin', |
'∉':'notin', |
'∋':'ni', |
'∏':'prod', |
'∑':'sum', |
'−':'minus', |
'∗':'lowast', |
'√':'radic', |
'∝':'prop', |
'∞':'infin', |
'∠':'ang', |
'∧':'and', |
'∨':'or', |
'∩':'cap', |
'∪':'cup', |
'∫':'int', |
'∴':'there4', |
'∼':'sim', |
'≅':'cong', |
'≈':'asymp', |
'≠':'ne', |
'≡':'equiv', |
'≤':'le', |
'≥':'ge', |
'⊂':'sub', |
'⊃':'sup', |
'⊄':'nsub', |
'⊆':'sube', |
'⊇':'supe', |
'⊕':'oplus', |
'⊗':'otimes', |
'⊥':'perp', |
'⋅':'sdot', |
'◊':'loz', |
'♠':'spades', |
'♣':'clubs', |
'♥':'hearts', |
'♦':'diams', |
// Other Special Characters |
'"':'quot', |
// '&':'amp', // This entity is automatically handled by the XHTML parser. |
// '<':'lt', // This entity is automatically handled by the XHTML parser. |
// '>':'gt', // This entity is automatically handled by the XHTML parser. |
'ˆ':'circ', |
'˜':'tilde', |
' ':'ensp', |
' ':'emsp', |
' ':'thinsp', |
'':'zwnj', |
'':'zwj', |
'':'lrm', |
'':'rlm', |
'–':'ndash', |
'—':'mdash', |
'‘':'lsquo', |
'’':'rsquo', |
'‚':'sbquo', |
'“':'ldquo', |
'”':'rdquo', |
'„':'bdquo', |
'†':'dagger', |
'‡':'Dagger', |
'‰':'permil', |
'‹':'lsaquo', |
'›':'rsaquo', |
'¤':'euro' |
} ; |
// Process Base Entities. |
for ( var e in FCKXHtmlEntities.Entities ) |
sChars += e ; |
// Include Latin Letters Entities. |
if ( FCKConfig.IncludeLatinEntities ) |
{ |
var oEntities = { |
'À':'Agrave', |
'Á':'Aacute', |
'Â':'Acirc', |
'Ã':'Atilde', |
'Ä':'Auml', |
'Å':'Aring', |
'Æ':'AElig', |
'Ç':'Ccedil', |
'È':'Egrave', |
'É':'Eacute', |
'Ê':'Ecirc', |
'Ë':'Euml', |
'Ì':'Igrave', |
'Í':'Iacute', |
'Î':'Icirc', |
'Ï':'Iuml', |
'Ð':'ETH', |
'Ñ':'Ntilde', |
'Ò':'Ograve', |
'Ó':'Oacute', |
'Ô':'Ocirc', |
'Õ':'Otilde', |
'Ö':'Ouml', |
'Ø':'Oslash', |
'Ù':'Ugrave', |
'Ú':'Uacute', |
'Û':'Ucirc', |
'Ü':'Uuml', |
'Ý':'Yacute', |
'Þ':'THORN', |
'ß':'szlig', |
'à':'agrave', |
'á':'aacute', |
'â':'acirc', |
'ã':'atilde', |
'ä':'auml', |
'å':'aring', |
'æ':'aelig', |
'ç':'ccedil', |
'è':'egrave', |
'é':'eacute', |
'ê':'ecirc', |
'ë':'euml', |
'ì':'igrave', |
'í':'iacute', |
'î':'icirc', |
'ï':'iuml', |
'ð':'eth', |
'ñ':'ntilde', |
'ò':'ograve', |
'ó':'oacute', |
'ô':'ocirc', |
'õ':'otilde', |
'ö':'ouml', |
'ø':'oslash', |
'ù':'ugrave', |
'ú':'uacute', |
'û':'ucirc', |
'ü':'uuml', |
'ý':'yacute', |
'þ':'thorn', |
'ÿ':'yuml', |
'Œ':'OElig', |
'œ':'oelig', |
'Š':'Scaron', |
'š':'scaron', |
'¾':'Yuml' |
} ; |
for ( var e in oEntities ) |
{ |
FCKXHtmlEntities.Entities[ e ] = oEntities[ e ] ; |
sChars += e ; |
} |
oEntities = null ; |
} |
// Include Greek Letters Entities. |
if ( FCKConfig.IncludeGreekEntities ) |
{ |
var oEntities = { |
'Α':'Alpha', |
'Β':'Beta', |
'Γ':'Gamma', |
'Δ':'Delta', |
'Ε':'Epsilon', |
'Ζ':'Zeta', |
'Η':'Eta', |
'Θ':'Theta', |
'Ι':'Iota', |
'Κ':'Kappa', |
'Λ':'Lambda', |
'Μ':'Mu', |
'Ν':'Nu', |
'Ξ':'Xi', |
'Ο':'Omicron', |
'Π':'Pi', |
'Ρ':'Rho', |
'Σ':'Sigma', |
'Τ':'Tau', |
'Υ':'Upsilon', |
'Φ':'Phi', |
'Χ':'Chi', |
'Ψ':'Psi', |
'Ω':'Omega', |
'α':'alpha', |
'β':'beta', |
'γ':'gamma', |
'δ':'delta', |
'ε':'epsilon', |
'ζ':'zeta', |
'η':'eta', |
'θ':'theta', |
'ι':'iota', |
'κ':'kappa', |
'λ':'lambda', |
'μ':'mu', |
'ν':'nu', |
'ξ':'xi', |
'ο':'omicron', |
'π':'pi', |
'ρ':'rho', |
'ς':'sigmaf', |
'σ':'sigma', |
'τ':'tau', |
'υ':'upsilon', |
'φ':'phi', |
'χ':'chi', |
'ψ':'psi', |
'ω':'omega' |
} ; |
for ( var e in oEntities ) |
{ |
FCKXHtmlEntities.Entities[ e ] = oEntities[ e ] ; |
sChars += e ; |
} |
oEntities = null ; |
} |
} |
else |
{ |
FCKXHtmlEntities.Entities = {} ; |
// Even if we are not processing the entities, we must render the |
// correctly. As we don't want HTML entities, let's use its numeric |
// representation ( ). |
sChars = ' ' ; |
} |
// Create the Regex used to find entities in the text. |
var sRegexPattern = '[' + sChars + ']' ; |
if ( FCKConfig.ProcessNumericEntities ) |
sRegexPattern = '[^ -~]|' + sRegexPattern ; |
var sAdditional = FCKConfig.AdditionalNumericEntities ; |
if ( sAdditional || sAdditional.length > 0 ) |
sRegexPattern += '|' + FCKConfig.AdditionalNumericEntities ; |
FCKXHtmlEntities.EntitiesRegex = new RegExp( sRegexPattern, 'g' ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckcommands.js |
---|
New file |
0,0 → 1,126 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckcommands.js |
* Define all commands available in the editor. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKCommands = FCK.Commands = new Object() ; |
FCKCommands.LoadedCommands = new Object() ; |
FCKCommands.RegisterCommand = function( commandName, command ) |
{ |
this.LoadedCommands[ commandName ] = command ; |
} |
FCKCommands.GetCommand = function( commandName ) |
{ |
var oCommand = FCKCommands.LoadedCommands[ commandName ] ; |
if ( oCommand ) |
return oCommand ; |
switch ( commandName ) |
{ |
case 'DocProps' : oCommand = new FCKDialogCommand( 'DocProps' , FCKLang.DocProps , 'dialog/fck_docprops.html' , 400, 390, FCKCommands.GetFullPageState ) ; break ; |
case 'Templates' : oCommand = new FCKDialogCommand( 'Templates' , FCKLang.DlgTemplatesTitle , 'dialog/fck_template.html' , 380, 450 ) ; break ; |
case 'Link' : oCommand = new FCKDialogCommand( 'Link' , FCKLang.DlgLnkWindowTitle , 'dialog/fck_link.html' , 400, 330, FCK.GetNamedCommandState, 'CreateLink' ) ; break ; |
case 'Unlink' : oCommand = new FCKUnlinkCommand() ; break ; |
case 'Anchor' : oCommand = new FCKDialogCommand( 'Anchor' , FCKLang.DlgAnchorTitle , 'dialog/fck_anchor.html' , 370, 170 ) ; break ; |
case 'BulletedList' : oCommand = new FCKDialogCommand( 'BulletedList', FCKLang.BulletedListProp , 'dialog/fck_listprop.html' , 370, 170 ) ; break ; |
case 'NumberedList' : oCommand = new FCKDialogCommand( 'NumberedList', FCKLang.NumberedListProp , 'dialog/fck_listprop.html' , 370, 170 ) ; break ; |
case 'About' : oCommand = new FCKDialogCommand( 'About' , FCKLang.About , 'dialog/fck_about.html' , 400, 330 ) ; break ; |
case 'Find' : oCommand = new FCKDialogCommand( 'Find' , FCKLang.DlgFindTitle , 'dialog/fck_find.html' , 340, 170 ) ; break ; |
case 'Replace' : oCommand = new FCKDialogCommand( 'Replace' , FCKLang.DlgReplaceTitle , 'dialog/fck_replace.html' , 340, 200 ) ; break ; |
case 'Image' : oCommand = new FCKDialogCommand( 'Image' , FCKLang.DlgImgTitle , 'dialog/fck_image.html' , 450, 400 ) ; break ; |
case 'Flash' : oCommand = new FCKDialogCommand( 'Flash' , FCKLang.DlgFlashTitle , 'dialog/fck_flash.html' , 450, 400 ) ; break ; |
case 'SpecialChar' : oCommand = new FCKDialogCommand( 'SpecialChar', FCKLang.DlgSpecialCharTitle , 'dialog/fck_specialchar.html' , 400, 320 ) ; break ; |
case 'Smiley' : oCommand = new FCKDialogCommand( 'Smiley' , FCKLang.DlgSmileyTitle , 'dialog/fck_smiley.html' , FCKConfig.SmileyWindowWidth, FCKConfig.SmileyWindowHeight ) ; break ; |
case 'Table' : oCommand = new FCKDialogCommand( 'Table' , FCKLang.DlgTableTitle , 'dialog/fck_table.html' , 450, 250 ) ; break ; |
case 'TableProp' : oCommand = new FCKDialogCommand( 'Table' , FCKLang.DlgTableTitle , 'dialog/fck_table.html?Parent', 400, 250 ) ; break ; |
case 'TableCellProp': oCommand = new FCKDialogCommand( 'TableCell' , FCKLang.DlgCellTitle , 'dialog/fck_tablecell.html' , 550, 250 ) ; break ; |
case 'UniversalKey' : oCommand = new FCKDialogCommand( 'UniversalKey', FCKLang.UniversalKeyboard , 'dialog/fck_universalkey.html', 415, 300 ) ; break ; |
case 'Style' : oCommand = new FCKStyleCommand() ; break ; |
case 'FontName' : oCommand = new FCKFontNameCommand() ; break ; |
case 'FontSize' : oCommand = new FCKFontSizeCommand() ; break ; |
case 'FontFormat' : oCommand = new FCKFormatBlockCommand() ; break ; |
case 'Source' : oCommand = new FCKSourceCommand() ; break ; |
case 'Preview' : oCommand = new FCKPreviewCommand() ; break ; |
case 'Save' : oCommand = new FCKSaveCommand() ; break ; |
case 'NewPage' : oCommand = new FCKNewPageCommand() ; break ; |
case 'PageBreak' : oCommand = new FCKPageBreakCommand() ; break ; |
case 'TextColor' : oCommand = new FCKTextColorCommand('ForeColor') ; break ; |
case 'BGColor' : oCommand = new FCKTextColorCommand('BackColor') ; break ; |
case 'PasteText' : oCommand = new FCKPastePlainTextCommand() ; break ; |
case 'PasteWord' : oCommand = new FCKPasteWordCommand() ; break ; |
case 'TableInsertRow' : oCommand = new FCKTableCommand('TableInsertRow') ; break ; |
case 'TableDeleteRows' : oCommand = new FCKTableCommand('TableDeleteRows') ; break ; |
case 'TableInsertColumn' : oCommand = new FCKTableCommand('TableInsertColumn') ; break ; |
case 'TableDeleteColumns' : oCommand = new FCKTableCommand('TableDeleteColumns') ; break ; |
case 'TableInsertCell' : oCommand = new FCKTableCommand('TableInsertCell') ; break ; |
case 'TableDeleteCells' : oCommand = new FCKTableCommand('TableDeleteCells') ; break ; |
case 'TableMergeCells' : oCommand = new FCKTableCommand('TableMergeCells') ; break ; |
case 'TableSplitCell' : oCommand = new FCKTableCommand('TableSplitCell') ; break ; |
case 'TableDelete' : oCommand = new FCKTableCommand('TableDelete') ; break ; |
case 'Form' : oCommand = new FCKDialogCommand( 'Form' , FCKLang.Form , 'dialog/fck_form.html' , 380, 230 ) ; break ; |
case 'Checkbox' : oCommand = new FCKDialogCommand( 'Checkbox' , FCKLang.Checkbox , 'dialog/fck_checkbox.html' , 380, 230 ) ; break ; |
case 'Radio' : oCommand = new FCKDialogCommand( 'Radio' , FCKLang.RadioButton , 'dialog/fck_radiobutton.html' , 380, 230 ) ; break ; |
case 'TextField' : oCommand = new FCKDialogCommand( 'TextField' , FCKLang.TextField , 'dialog/fck_textfield.html' , 380, 230 ) ; break ; |
case 'Textarea' : oCommand = new FCKDialogCommand( 'Textarea' , FCKLang.Textarea , 'dialog/fck_textarea.html' , 380, 230 ) ; break ; |
case 'HiddenField' : oCommand = new FCKDialogCommand( 'HiddenField', FCKLang.HiddenField , 'dialog/fck_hiddenfield.html' , 380, 230 ) ; break ; |
case 'Button' : oCommand = new FCKDialogCommand( 'Button' , FCKLang.Button , 'dialog/fck_button.html' , 380, 230 ) ; break ; |
case 'Select' : oCommand = new FCKDialogCommand( 'Select' , FCKLang.SelectionField, 'dialog/fck_select.html' , 400, 380 ) ; break ; |
case 'ImageButton' : oCommand = new FCKDialogCommand( 'ImageButton', FCKLang.ImageButton , 'dialog/fck_image.html?ImageButton', 450, 400 ) ; break ; |
case 'SpellCheck' : oCommand = new FCKSpellCheckCommand() ; break ; |
case 'FitWindow' : oCommand = new FCKFitWindow() ; break ; |
case 'Undo' : oCommand = new FCKUndoCommand() ; break ; |
case 'Redo' : oCommand = new FCKRedoCommand() ; break ; |
// Generic Undefined command (usually used when a command is under development). |
case 'Undefined' : oCommand = new FCKUndefinedCommand() ; break ; |
// By default we assume that it is a named command. |
default: |
if ( FCKRegexLib.NamedCommands.test( commandName ) ) |
oCommand = new FCKNamedCommand( commandName ) ; |
else |
{ |
alert( FCKLang.UnknownCommand.replace( /%1/g, commandName ) ) ; |
return null ; |
} |
} |
FCKCommands.LoadedCommands[ commandName ] = oCommand ; |
return oCommand ; |
} |
// Gets the state of the "Document Properties" button. It must be enabled only |
// when "Full Page" editing is available. |
FCKCommands.GetFullPageState = function() |
{ |
return FCKConfig.FullPage ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktablehandler_ie.js |
---|
New file |
0,0 → 1,54 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktablehandler_ie.js |
* Manage table operations (IE specific). |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKTableHandler.GetSelectedCells = function() |
{ |
var aCells = new Array() ; |
var oRange = FCK.EditorDocument.selection.createRange() ; |
// var oParent = oRange.parentElement() ; |
var oParent = FCKSelection.GetParentElement() ; |
if ( oParent && oParent.tagName.Equals( 'TD', 'TH' ) ) |
aCells[0] = oParent ; |
else |
{ |
var oParent = FCKSelection.MoveToAncestorNode( "TABLE" ) ; |
if ( oParent ) |
{ |
// Loops throw all cells checking if the cell is, or part of it, is inside the selection |
// and then add it to the selected cells collection. |
for ( var i = 0 ; i < oParent.cells.length ; i++ ) |
{ |
var oCellRange = FCK.EditorDocument.selection.createRange() ; |
oCellRange.moveToElementText( oParent.cells[i] ) ; |
if ( oRange.inRange( oCellRange ) |
|| ( oRange.compareEndPoints('StartToStart',oCellRange) >= 0 && oRange.compareEndPoints('StartToEnd',oCellRange) <= 0 ) |
|| ( oRange.compareEndPoints('EndToStart',oCellRange) >= 0 && oRange.compareEndPoints('EndToEnd',oCellRange) <= 0 ) ) |
{ |
aCells[aCells.length] = oParent.cells[i] ; |
} |
} |
} |
} |
return aCells ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktoolbaritems.js |
---|
New file |
0,0 → 1,118 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktoolbaritems.js |
* Toolbar items definitions. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKToolbarItems = new Object() ; |
FCKToolbarItems.LoadedItems = new Object() ; |
FCKToolbarItems.RegisterItem = function( itemName, item ) |
{ |
this.LoadedItems[ itemName ] = item ; |
} |
FCKToolbarItems.GetItem = function( itemName ) |
{ |
var oItem = FCKToolbarItems.LoadedItems[ itemName ] ; |
if ( oItem ) |
return oItem ; |
switch ( itemName ) |
{ |
case 'Source' : oItem = new FCKToolbarButton( 'Source' , FCKLang.Source, null, FCK_TOOLBARITEM_ICONTEXT, true, true, 1 ) ; break ; |
case 'DocProps' : oItem = new FCKToolbarButton( 'DocProps' , FCKLang.DocProps, null, null, null, null, 2 ) ; break ; |
case 'Save' : oItem = new FCKToolbarButton( 'Save' , FCKLang.Save, null, null, true, null, 3 ) ; break ; |
case 'NewPage' : oItem = new FCKToolbarButton( 'NewPage' , FCKLang.NewPage, null, null, true, null, 4 ) ; break ; |
case 'Preview' : oItem = new FCKToolbarButton( 'Preview' , FCKLang.Preview, null, null, true, null, 5 ) ; break ; |
case 'Templates' : oItem = new FCKToolbarButton( 'Templates' , FCKLang.Templates, null, null, null, null, 6 ) ; break ; |
case 'About' : oItem = new FCKToolbarButton( 'About' , FCKLang.About, null, null, true, null, 47 ) ; break ; |
case 'Cut' : oItem = new FCKToolbarButton( 'Cut' , FCKLang.Cut, null, null, false, true, 7 ) ; break ; |
case 'Copy' : oItem = new FCKToolbarButton( 'Copy' , FCKLang.Copy, null, null, false, true, 8 ) ; break ; |
case 'Paste' : oItem = new FCKToolbarButton( 'Paste' , FCKLang.Paste, null, null, false, true, 9 ) ; break ; |
case 'PasteText' : oItem = new FCKToolbarButton( 'PasteText' , FCKLang.PasteText, null, null, false, true, 10 ) ; break ; |
case 'PasteWord' : oItem = new FCKToolbarButton( 'PasteWord' , FCKLang.PasteWord, null, null, false, true, 11 ) ; break ; |
case 'Print' : oItem = new FCKToolbarButton( 'Print' , FCKLang.Print, null, null, false, true, 12 ) ; break ; |
case 'SpellCheck' : oItem = new FCKToolbarButton( 'SpellCheck', FCKLang.SpellCheck, null, null, null, null, 13 ) ; break ; |
case 'Undo' : oItem = new FCKToolbarButton( 'Undo' , FCKLang.Undo, null, null, false, true, 14 ) ; break ; |
case 'Redo' : oItem = new FCKToolbarButton( 'Redo' , FCKLang.Redo, null, null, false, true, 15 ) ; break ; |
case 'SelectAll' : oItem = new FCKToolbarButton( 'SelectAll' , FCKLang.SelectAll, null, null, null, null, 18 ) ; break ; |
case 'RemoveFormat' : oItem = new FCKToolbarButton( 'RemoveFormat', FCKLang.RemoveFormat, null, null, false, true, 19 ) ; break ; |
case 'FitWindow' : oItem = new FCKToolbarButton( 'FitWindow' , FCKLang.FitWindow, null, null, true, true, 66 ) ; break ; |
case 'Bold' : oItem = new FCKToolbarButton( 'Bold' , FCKLang.Bold, null, null, false, true, 20 ) ; break ; |
case 'Italic' : oItem = new FCKToolbarButton( 'Italic' , FCKLang.Italic, null, null, false, true, 21 ) ; break ; |
case 'Underline' : oItem = new FCKToolbarButton( 'Underline' , FCKLang.Underline, null, null, false, true, 22 ) ; break ; |
case 'StrikeThrough' : oItem = new FCKToolbarButton( 'StrikeThrough' , FCKLang.StrikeThrough, null, null, false, true, 23 ) ; break ; |
case 'Subscript' : oItem = new FCKToolbarButton( 'Subscript' , FCKLang.Subscript, null, null, false, true, 24 ) ; break ; |
case 'Superscript' : oItem = new FCKToolbarButton( 'Superscript' , FCKLang.Superscript, null, null, false, true, 25 ) ; break ; |
case 'OrderedList' : oItem = new FCKToolbarButton( 'InsertOrderedList' , FCKLang.NumberedListLbl, FCKLang.NumberedList, null, false, true, 26 ) ; break ; |
case 'UnorderedList' : oItem = new FCKToolbarButton( 'InsertUnorderedList' , FCKLang.BulletedListLbl, FCKLang.BulletedList, null, false, true, 27 ) ; break ; |
case 'Outdent' : oItem = new FCKToolbarButton( 'Outdent' , FCKLang.DecreaseIndent, null, null, false, true, 28 ) ; break ; |
case 'Indent' : oItem = new FCKToolbarButton( 'Indent' , FCKLang.IncreaseIndent, null, null, false, true, 29 ) ; break ; |
case 'Link' : oItem = new FCKToolbarButton( 'Link' , FCKLang.InsertLinkLbl, FCKLang.InsertLink, null, false, true, 34 ) ; break ; |
case 'Unlink' : oItem = new FCKToolbarButton( 'Unlink' , FCKLang.RemoveLink, null, null, false, true, 35 ) ; break ; |
case 'Anchor' : oItem = new FCKToolbarButton( 'Anchor' , FCKLang.Anchor, null, null, null, null, 36 ) ; break ; |
case 'Image' : oItem = new FCKToolbarButton( 'Image' , FCKLang.InsertImageLbl, FCKLang.InsertImage, null, false, true, 37 ) ; break ; |
case 'Flash' : oItem = new FCKToolbarButton( 'Flash' , FCKLang.InsertFlashLbl, FCKLang.InsertFlash, null, false, true, 38 ) ; break ; |
case 'Table' : oItem = new FCKToolbarButton( 'Table' , FCKLang.InsertTableLbl, FCKLang.InsertTable, null, false, true, 39 ) ; break ; |
case 'SpecialChar' : oItem = new FCKToolbarButton( 'SpecialChar' , FCKLang.InsertSpecialCharLbl, FCKLang.InsertSpecialChar, null, false, true, 42 ) ; break ; |
case 'Smiley' : oItem = new FCKToolbarButton( 'Smiley' , FCKLang.InsertSmileyLbl, FCKLang.InsertSmiley, null, false, true, 41 ) ; break ; |
case 'PageBreak' : oItem = new FCKToolbarButton( 'PageBreak' , FCKLang.PageBreakLbl, FCKLang.PageBreak, null, false, true, 43 ) ; break ; |
case 'UniversalKey' : oItem = new FCKToolbarButton( 'UniversalKey' , FCKLang.UniversalKeyboard , null, null, false, true, 44) ; break ; |
case 'Rule' : oItem = new FCKToolbarButton( 'InsertHorizontalRule', FCKLang.InsertLineLbl, FCKLang.InsertLine, null, false, true, 40 ) ; break ; |
case 'JustifyLeft' : oItem = new FCKToolbarButton( 'JustifyLeft' , FCKLang.LeftJustify, null, null, false, true, 30 ) ; break ; |
case 'JustifyCenter' : oItem = new FCKToolbarButton( 'JustifyCenter' , FCKLang.CenterJustify, null, null, false, true, 31 ) ; break ; |
case 'JustifyRight' : oItem = new FCKToolbarButton( 'JustifyRight' , FCKLang.RightJustify, null, null, false, true, 32 ) ; break ; |
case 'JustifyFull' : oItem = new FCKToolbarButton( 'JustifyFull' , FCKLang.BlockJustify, null, null, false, true, 33 ) ; break ; |
case 'Style' : oItem = new FCKToolbarStyleCombo() ; break ; |
case 'FontName' : oItem = new FCKToolbarFontsCombo() ; break ; |
case 'FontSize' : oItem = new FCKToolbarFontSizeCombo() ; break ; |
case 'FontFormat' : oItem = new FCKToolbarFontFormatCombo() ; break ; |
case 'TextColor' : oItem = new FCKToolbarPanelButton( 'TextColor', FCKLang.TextColor, null, null, 45 ) ; break ; |
case 'BGColor' : oItem = new FCKToolbarPanelButton( 'BGColor' , FCKLang.BGColor, null, null, 46 ) ; break ; |
case 'Find' : oItem = new FCKToolbarButton( 'Find' , FCKLang.Find, null, null, null, null, 16 ) ; break ; |
case 'Replace' : oItem = new FCKToolbarButton( 'Replace' , FCKLang.Replace, null, null, null, null, 17 ) ; break ; |
case 'Form' : oItem = new FCKToolbarButton( 'Form' , FCKLang.Form, null, null, null, null, 48 ) ; break ; |
case 'Checkbox' : oItem = new FCKToolbarButton( 'Checkbox' , FCKLang.Checkbox, null, null, null, null, 49 ) ; break ; |
case 'Radio' : oItem = new FCKToolbarButton( 'Radio' , FCKLang.RadioButton, null, null, null, null, 50 ) ; break ; |
case 'TextField' : oItem = new FCKToolbarButton( 'TextField' , FCKLang.TextField, null, null, null, null, 51 ) ; break ; |
case 'Textarea' : oItem = new FCKToolbarButton( 'Textarea' , FCKLang.Textarea, null, null, null, null, 52 ) ; break ; |
case 'HiddenField' : oItem = new FCKToolbarButton( 'HiddenField' , FCKLang.HiddenField, null, null, null, null, 56 ) ; break ; |
case 'Button' : oItem = new FCKToolbarButton( 'Button' , FCKLang.Button, null, null, null, null, 54 ) ; break ; |
case 'Select' : oItem = new FCKToolbarButton( 'Select' , FCKLang.SelectionField, null, null, null, null, 53 ) ; break ; |
case 'ImageButton' : oItem = new FCKToolbarButton( 'ImageButton' , FCKLang.ImageButton, null, null, null, null, 55 ) ; break ; |
default: |
alert( FCKLang.UnknownToolbarItem.replace( /%1/g, itemName ) ) ; |
return null ; |
} |
FCKToolbarItems.LoadedItems[ itemName ] = oItem ; |
return oItem ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckxhtml_gecko.js |
---|
New file |
0,0 → 1,62 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckxhtml_gecko.js |
* Defines the FCKXHtml object, responsible for the XHTML operations. |
* Gecko specific. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKXHtml._GetMainXmlString = function() |
{ |
// Create the XMLSerializer. |
var oSerializer = new XMLSerializer() ; |
// Return the serialized XML as a string. |
return oSerializer.serializeToString( this.MainNode ) ; |
} |
FCKXHtml._AppendAttributes = function( xmlNode, htmlNode, node ) |
{ |
var aAttributes = htmlNode.attributes ; |
for ( var n = 0 ; n < aAttributes.length ; n++ ) |
{ |
var oAttribute = aAttributes[n] ; |
if ( oAttribute.specified ) |
{ |
var sAttName = oAttribute.nodeName.toLowerCase() ; |
var sAttValue ; |
// Ignore any attribute starting with "_fck". |
if ( sAttName.startsWith( '_fck' ) ) |
continue ; |
// There is a bug in Mozilla that returns '_moz_xxx' attributes as specified. |
else if ( sAttName.indexOf( '_moz' ) == 0 ) |
continue ; |
// There are one cases (on Gecko) when the oAttribute.nodeValue must be used: |
// - for the "class" attribute |
else if ( sAttName == 'class' ) |
sAttValue = oAttribute.nodeValue ; |
// XHTML doens't support attribute minimization like "CHECKED". It must be trasformed to cheched="checked". |
else if ( oAttribute.nodeValue === true ) |
sAttValue = sAttName ; |
else |
sAttValue = htmlNode.getAttribute( sAttName, 2 ) ; // We must use getAttribute to get it exactly as it is defined. |
this._AppendAttribute( node, sAttName, sAttValue ) ; |
} |
} |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckconfig.js |
---|
New file |
0,0 → 1,195 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckconfig.js |
* Creates and initializes the FCKConfig object. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKConfig = FCK.Config = new Object() ; |
/* |
For the next major version (probably 3.0) we should move all this stuff to |
another dedicated object and leave FCKConfig as a holder object for settings only). |
*/ |
// Editor Base Path |
if ( document.location.protocol == 'file:' ) |
{ |
FCKConfig.BasePath = unescape( document.location.pathname.substr(1) ) ; |
FCKConfig.BasePath = FCKConfig.BasePath.replace( /\\/gi, '/' ) ; |
FCKConfig.BasePath = 'file://' + FCKConfig.BasePath.substring(0,FCKConfig.BasePath.lastIndexOf('/')+1) ; |
FCKConfig.FullBasePath = FCKConfig.BasePath ; |
} |
else |
{ |
FCKConfig.BasePath = document.location.pathname.substring(0,document.location.pathname.lastIndexOf('/')+1) ; |
FCKConfig.FullBasePath = document.location.protocol + '//' + document.location.host + FCKConfig.BasePath ; |
} |
FCKConfig.EditorPath = FCKConfig.BasePath.replace( /editor\/$/, '' ) ; |
// There is a bug in Gecko. If the editor is hidden on startup, an error is |
// thrown when trying to get the screen dimentions. |
try |
{ |
FCKConfig.ScreenWidth = screen.width ; |
FCKConfig.ScreenHeight = screen.height ; |
} |
catch (e) |
{ |
FCKConfig.ScreenWidth = 800 ; |
FCKConfig.ScreenHeight = 600 ; |
} |
// Override the actual configuration values with the values passed throw the |
// hidden field "<InstanceName>___Config". |
FCKConfig.ProcessHiddenField = function() |
{ |
this.PageConfig = new Object() ; |
// Get the hidden field. |
var oConfigField = window.parent.document.getElementById( FCK.Name + '___Config' ) ; |
// Do nothing if the config field was not defined. |
if ( ! oConfigField ) return ; |
var aCouples = oConfigField.value.split('&') ; |
for ( var i = 0 ; i < aCouples.length ; i++ ) |
{ |
if ( aCouples[i].length == 0 ) |
continue ; |
var aConfig = aCouples[i].split( '=' ) ; |
var sKey = unescape( aConfig[0] ) ; |
var sVal = unescape( aConfig[1] ) ; |
if ( sKey == 'CustomConfigurationsPath' ) // The Custom Config File path must be loaded immediately. |
FCKConfig[ sKey ] = sVal ; |
else if ( sVal.toLowerCase() == "true" ) // If it is a boolean TRUE. |
this.PageConfig[ sKey ] = true ; |
else if ( sVal.toLowerCase() == "false" ) // If it is a boolean FALSE. |
this.PageConfig[ sKey ] = false ; |
else if ( sVal.length > 0 && !isNaN( sVal ) ) // If it is a number. |
this.PageConfig[ sKey ] = parseInt( sVal ) ; |
else // In any other case it is a string. |
this.PageConfig[ sKey ] = sVal ; |
} |
} |
function FCKConfig_LoadPageConfig() |
{ |
var oPageConfig = FCKConfig.PageConfig ; |
for ( var sKey in oPageConfig ) |
FCKConfig[ sKey ] = oPageConfig[ sKey ] ; |
} |
function FCKConfig_PreProcess() |
{ |
var oConfig = FCKConfig ; |
// Force debug mode if fckdebug=true in the QueryString (main page). |
if ( oConfig.AllowQueryStringDebug ) |
{ |
try |
{ |
if ( (/fckdebug=true/i).test( window.top.location.search ) ) |
oConfig.Debug = true ; |
} |
catch (e) { /* Ignore it. Much probably we are inside a FRAME where the "top" is in another domain (security error). */ } |
} |
// Certifies that the "PluginsPath" configuration ends with a slash. |
if ( !oConfig.PluginsPath.endsWith('/') ) |
oConfig.PluginsPath += '/' ; |
// EditorAreaCSS accepts an array of paths or a single path (as string). |
// In the last case, transform it in an array. |
if ( typeof( oConfig.EditorAreaCSS ) == 'string' ) |
oConfig.EditorAreaCSS = [ oConfig.EditorAreaCSS ] ; |
var sComboPreviewCSS = oConfig.ToolbarComboPreviewCSS ; |
if ( !sComboPreviewCSS || sComboPreviewCSS.length == 0 ) |
oConfig.ToolbarComboPreviewCSS = oConfig.EditorAreaCSS ; |
else if ( typeof( sComboPreviewCSS ) == 'string' ) |
oConfig.ToolbarComboPreviewCSS = [ sComboPreviewCSS ] ; |
} |
// Define toolbar sets collection. |
FCKConfig.ToolbarSets = new Object() ; |
// Defines the plugins collection. |
FCKConfig.Plugins = new Object() ; |
FCKConfig.Plugins.Items = new Array() ; |
FCKConfig.Plugins.Add = function( name, langs, path ) |
{ |
FCKConfig.Plugins.Items.AddItem( [name, langs, path] ) ; |
} |
// FCKConfig.ProtectedSource: object that holds a collection of Regular |
// Expressions that defined parts of the raw HTML that must remain untouched |
// like custom tags, scripts, server side code, etc... |
FCKConfig.ProtectedSource = new Object() ; |
// Initialize the regex array with the default ones. |
FCKConfig.ProtectedSource.RegexEntries = [ |
// First of any other protection, we must protect all comments to avoid |
// loosing them (of course, IE related). |
/<!--[\s\S]*?-->/g , |
// Script tags will also be forced to be protected, otherwise IE will execute them. |
/<script[\s\S]*?<\/script>/gi, |
// <noscript> tags (get lost in IE and messed up in FF). |
/<noscript[\s\S]*?<\/noscript>/gi |
] ; |
FCKConfig.ProtectedSource.Add = function( regexPattern ) |
{ |
this.RegexEntries.AddItem( regexPattern ) ; |
} |
FCKConfig.ProtectedSource.Protect = function( html ) |
{ |
function _Replace( protectedSource ) |
{ |
var index = FCKTempBin.AddElement( protectedSource ) ; |
return '<!--{PS..' + index + '}-->' ; |
} |
for ( var i = 0 ; i < this.RegexEntries.length ; i++ ) |
{ |
html = html.replace( this.RegexEntries[i], _Replace ) ; |
} |
return html ; |
} |
FCKConfig.ProtectedSource.Revert = function( html, clearBin ) |
{ |
function _Replace( m, opener, index ) |
{ |
var protectedValue = clearBin ? FCKTempBin.RemoveElement( index ) : FCKTempBin.Elements[ index ] ; |
// There could be protected source inside another one. |
return FCKConfig.ProtectedSource.Revert( protectedValue, clearBin ) ; |
} |
return html.replace( /(<|<)!--\{PS..(\d+)\}--(>|>)/g, _Replace ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck_1_gecko.js |
---|
New file |
0,0 → 1,112 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck_1_gecko.js |
* This is the first part of the "FCK" object creation. This is the main |
* object that represents an editor instance. |
* (Gecko specific implementations) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCK.Description = "FCKeditor for Gecko Browsers" ; |
FCK.InitializeBehaviors = function() |
{ |
// When calling "SetHTML", the editing area IFRAME gets a fixed height. So we must recaulculate it. |
Window_OnResize() ; |
FCKFocusManager.AddWindow( this.EditorWindow ) ; |
// Handle pasting operations. |
var oOnKeyDown = function( e ) |
{ |
var bPrevent ; |
if ( e.ctrlKey && !e.shiftKey && !e.altKey ) |
{ |
switch ( e.which ) |
{ |
case 66 : // B |
case 98 : // b |
FCK.ExecuteNamedCommand( 'bold' ) ; bPrevent = true ; |
break; |
case 105 : // i |
case 73 : // I |
FCK.ExecuteNamedCommand( 'italic' ) ; bPrevent = true ; |
break; |
case 117 : // u |
case 85 : // U |
FCK.ExecuteNamedCommand( 'underline' ) ; bPrevent = true ; |
break; |
case 86 : // V |
case 118 : // v |
bPrevent = ( FCK.Status != FCK_STATUS_COMPLETE || !FCK.Events.FireEvent( "OnPaste" ) ) ; |
break ; |
} |
} |
else if ( e.shiftKey && !e.ctrlKey && !e.altKey && e.keyCode == 45 ) // SHIFT + <INS> |
bPrevent = ( FCK.Status != FCK_STATUS_COMPLETE || !FCK.Events.FireEvent( "OnPaste" ) ) ; |
if ( bPrevent ) |
{ |
e.preventDefault() ; |
e.stopPropagation() ; |
} |
} |
this.EditorDocument.addEventListener( 'keypress', oOnKeyDown, true ) ; |
this.ExecOnSelectionChange = function() |
{ |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
this.ExecOnSelectionChangeTimer = function() |
{ |
if ( FCK.LastOnChangeTimer ) |
window.clearTimeout( FCK.LastOnChangeTimer ) ; |
FCK.LastOnChangeTimer = window.setTimeout( FCK.ExecOnSelectionChange, 100 ) ; |
} |
this.EditorDocument.addEventListener( 'mouseup', this.ExecOnSelectionChange, false ) ; |
// On Gecko, firing the "OnSelectionChange" event on every key press started to be too much |
// slow. So, a timer has been implemented to solve performance issues when tipying to quickly. |
this.EditorDocument.addEventListener( 'keyup', this.ExecOnSelectionChangeTimer, false ) ; |
this._DblClickListener = function( e ) |
{ |
FCK.OnDoubleClick( e.target ) ; |
e.stopPropagation() ; |
} |
this.EditorDocument.addEventListener( 'dblclick', this._DblClickListener, true ) ; |
// Reset the context menu. |
FCK.ContextMenu._InnerContextMenu.SetMouseClickWindow( FCK.EditorWindow ) ; |
FCK.ContextMenu._InnerContextMenu.AttachToElement( FCK.EditorDocument ) ; |
} |
FCK.MakeEditable = function() |
{ |
this.EditingArea.MakeEditable() ; |
} |
// Disable the context menu in the editor (outside the editing area). |
function Document_OnContextMenu( e ) |
{ |
if ( !e.target._FCKShowContextMenu ) |
e.preventDefault() ; |
} |
document.oncontextmenu = Document_OnContextMenu ; |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckdialog_gecko.js |
---|
New file |
0,0 → 1,101 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckdialog_gecko.js |
* Dialog windows operations. (Gecko specific implementations) |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKDialog.Show = function( dialogInfo, dialogName, pageUrl, dialogWidth, dialogHeight, parentWindow, resizable ) |
{ |
var iTop = (FCKConfig.ScreenHeight - dialogHeight) / 2 ; |
var iLeft = (FCKConfig.ScreenWidth - dialogWidth) / 2 ; |
var sOption = "location=no,menubar=no,toolbar=no,dependent=yes,dialog=yes,minimizable=no,modal=yes,alwaysRaised=yes" + |
",resizable=" + ( resizable ? 'yes' : 'no' ) + |
",width=" + dialogWidth + |
",height=" + dialogHeight + |
",top=" + iTop + |
",left=" + iLeft ; |
if ( !parentWindow ) |
parentWindow = window ; |
FCKFocusManager.Lock() ; |
var oWindow = parentWindow.open( '', 'FCKeditorDialog_' + dialogName, sOption, true ) ; |
if ( !oWindow ) |
{ |
alert( FCKLang.DialogBlocked ) ; |
FCKFocusManager.Unlock() ; |
return ; |
} |
oWindow.moveTo( iLeft, iTop ) ; |
oWindow.resizeTo( dialogWidth, dialogHeight ) ; |
oWindow.focus() ; |
oWindow.location.href = pageUrl ; |
oWindow.dialogArguments = dialogInfo ; |
// On some Gecko browsers (probably over slow connections) the |
// "dialogArguments" are not set to the target window so we must |
// put it in the opener window so it can be used by the target one. |
parentWindow.FCKLastDialogInfo = dialogInfo ; |
this.Window = oWindow ; |
// Try/Catch must be used to avoit an error when using a frameset |
// on a different domain: |
// "Permission denied to get property Window.releaseEvents". |
try |
{ |
window.top.captureEvents( Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS ) ; |
window.top.parent.addEventListener( 'mousedown', this.CheckFocus, true ) ; |
window.top.parent.addEventListener( 'mouseup', this.CheckFocus, true ) ; |
window.top.parent.addEventListener( 'click', this.CheckFocus, true ) ; |
window.top.parent.addEventListener( 'focus', this.CheckFocus, true ) ; |
} |
catch (e) |
{} |
} |
FCKDialog.CheckFocus = function() |
{ |
// It is strange, but we have to check the FCKDialog existence to avoid a |
// random error: "FCKDialog is not defined". |
if ( typeof( FCKDialog ) != "object" ) |
return false ; |
if ( FCKDialog.Window && !FCKDialog.Window.closed ) |
FCKDialog.Window.focus() ; |
else |
{ |
// Try/Catch must be used to avoit an error when using a frameset |
// on a different domain: |
// "Permission denied to get property Window.releaseEvents". |
try |
{ |
window.top.releaseEvents(Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS) ; |
window.top.parent.removeEventListener( 'onmousedown', FCKDialog.CheckFocus, true ) ; |
window.top.parent.removeEventListener( 'mouseup', FCKDialog.CheckFocus, true ) ; |
window.top.parent.removeEventListener( 'click', FCKDialog.CheckFocus, true ) ; |
window.top.parent.removeEventListener( 'onfocus', FCKDialog.CheckFocus, true ) ; |
} |
catch (e) |
{} |
} |
return false ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktools_gecko.js |
---|
New file |
0,0 → 1,231 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktools_gecko.js |
* Utility functions. (Gecko version). |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// Constant for the Gecko Bogus Node. |
var GECKO_BOGUS = FCKBrowserInfo.IsGecko ? '<br _moz_editor_bogus_node="TRUE">' : '' ; |
FCKTools.CancelEvent = function( e ) |
{ |
if ( e ) |
e.preventDefault() ; |
} |
FCKTools.DisableSelection = function( element ) |
{ |
if ( FCKBrowserInfo.IsGecko ) |
element.style.MozUserSelect = 'none' ; // Gecko only. |
else |
element.style.userSelect = 'none' ; // CSS3 (not supported yet). |
} |
// Appends a CSS file to a document. |
FCKTools._AppendStyleSheet = function( documentElement, cssFileUrl ) |
{ |
var e = documentElement.createElement( 'LINK' ) ; |
e.rel = 'stylesheet' ; |
e.type = 'text/css' ; |
e.href = cssFileUrl ; |
documentElement.getElementsByTagName("HEAD")[0].appendChild( e ) ; |
return e ; |
} |
// Removes all attributes and values from the element. |
FCKTools.ClearElementAttributes = function( element ) |
{ |
// Loop throw all attributes in the element |
for ( var i = 0 ; i < element.attributes.length ; i++ ) |
{ |
// Remove the element by name. |
element.removeAttribute( element.attributes[i].name, 0 ) ; // 0 : Case Insensitive |
} |
} |
// Returns an Array of strings with all defined in the elements inside another element. |
FCKTools.GetAllChildrenIds = function( parentElement ) |
{ |
// Create the array that will hold all Ids. |
var aIds = new Array() ; |
// Define a recursive function that search for the Ids. |
var fGetIds = function( parent ) |
{ |
for ( var i = 0 ; i < parent.childNodes.length ; i++ ) |
{ |
var sId = parent.childNodes[i].id ; |
// Check if the Id is defined for the element. |
if ( sId && sId.length > 0 ) aIds[ aIds.length ] = sId ; |
// Recursive call. |
fGetIds( parent.childNodes[i] ) ; |
} |
} |
// Start the recursive calls. |
fGetIds( parentElement ) ; |
return aIds ; |
} |
FCKTools.RemoveOuterTags = function( e ) |
{ |
var oFragment = e.ownerDocument.createDocumentFragment() ; |
for ( var i = 0 ; i < e.childNodes.length ; i++ ) |
oFragment.appendChild( e.childNodes[i] ) ; |
e.parentNode.replaceChild( oFragment, e ) ; |
} |
FCKTools.CreateXmlObject = function( object ) |
{ |
switch ( object ) |
{ |
case 'XmlHttp' : |
return new XMLHttpRequest() ; |
case 'DOMDocument' : |
return document.implementation.createDocument( '', '', null ) ; |
} |
return null ; |
} |
FCKTools.GetScrollPosition = function( relativeWindow ) |
{ |
return { X : relativeWindow.pageXOffset, Y : relativeWindow.pageYOffset } ; |
} |
FCKTools.AddEventListener = function( sourceObject, eventName, listener ) |
{ |
sourceObject.addEventListener( eventName, listener, false ) ; |
} |
FCKTools.RemoveEventListener = function( sourceObject, eventName, listener ) |
{ |
sourceObject.removeEventListener( eventName, listener, false ) ; |
} |
// Listeners attached with this function cannot be detached. |
FCKTools.AddEventListenerEx = function( sourceObject, eventName, listener, paramsArray ) |
{ |
sourceObject.addEventListener( |
eventName, |
function( e ) |
{ |
listener.apply( sourceObject, [ e ].concat( paramsArray || [] ) ) ; |
}, |
false |
) ; |
} |
// Returns and object with the "Width" and "Height" properties. |
FCKTools.GetViewPaneSize = function( win ) |
{ |
return { Width : win.innerWidth, Height : win.innerHeight } ; |
} |
FCKTools.SaveStyles = function( element ) |
{ |
var oSavedStyles = new Object() ; |
if ( element.className.length > 0 ) |
{ |
oSavedStyles.Class = element.className ; |
element.className = '' ; |
} |
var sInlineStyle = element.getAttribute( 'style' ) ; |
if ( sInlineStyle && sInlineStyle.length > 0 ) |
{ |
oSavedStyles.Inline = sInlineStyle ; |
element.setAttribute( 'style', '', 0 ) ; // 0 : Case Insensitive |
} |
return oSavedStyles ; |
} |
FCKTools.RestoreStyles = function( element, savedStyles ) |
{ |
element.className = savedStyles.Class || '' ; |
if ( savedStyles.Inline ) |
element.setAttribute( 'style', savedStyles.Inline, 0 ) ; // 0 : Case Insensitive |
else |
element.removeAttribute( 'style', 0 ) ; |
} |
FCKTools.RegisterDollarFunction = function( targetWindow ) |
{ |
targetWindow.$ = function( id ) |
{ |
return this.document.getElementById( id ) ; |
} ; |
} |
FCKTools.AppendElement = function( target, elementName ) |
{ |
return target.appendChild( target.ownerDocument.createElement( elementName ) ) ; |
} |
// Get the coordinates of an element. |
// @el : The element to get the position. |
// @relativeWindow: The window to which we want the coordinates relative to. |
FCKTools.GetElementPosition = function( el, relativeWindow ) |
{ |
// Initializes the Coordinates object that will be returned by the function. |
var c = { X:0, Y:0 } ; |
var oWindow = relativeWindow || window ; |
var oOwnerWindow = FCKTools.GetElementWindow( el ) ; |
// Loop throw the offset chain. |
while ( el ) |
{ |
var sPosition = oOwnerWindow.getComputedStyle(el, '').position ; |
// Check for non "static" elements. |
// 'FCKConfig.FloatingPanelsZIndex' -- Submenus are under a positioned IFRAME. |
if ( sPosition && sPosition != 'static' && el.style.zIndex != FCKConfig.FloatingPanelsZIndex ) |
break ; |
c.X += el.offsetLeft - el.scrollLeft ; |
c.Y += el.offsetTop - el.scrollTop ; |
if ( el.offsetParent ) |
el = el.offsetParent ; |
else |
{ |
if ( oOwnerWindow != oWindow ) |
{ |
if ( el = oOwnerWindow.frameElement ) |
oOwnerWindow = FCKTools.GetElementWindow( el ) ; |
} |
else |
{ |
c.X += el.scrollLeft ; |
c.Y += el.scrollTop ; |
break ; |
} |
} |
} |
// Return the Coordinates object |
return c ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckxhtml_ie.js |
---|
New file |
0,0 → 1,184 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckxhtml_ie.js |
* Defines the FCKXHtml object, responsible for the XHTML operations. |
* IE specific. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKXHtml._GetMainXmlString = function() |
{ |
return this.MainNode.xml ; |
} |
FCKXHtml._AppendAttributes = function( xmlNode, htmlNode, node, nodeName ) |
{ |
var aAttributes = htmlNode.attributes ; |
for ( var n = 0 ; n < aAttributes.length ; n++ ) |
{ |
var oAttribute = aAttributes[n] ; |
if ( oAttribute.specified ) |
{ |
var sAttName = oAttribute.nodeName.toLowerCase() ; |
var sAttValue ; |
// Ignore any attribute starting with "_fck". |
if ( sAttName.startsWith( '_fck' ) ) |
continue ; |
// The following must be done because of a bug on IE regarding the style |
// attribute. It returns "null" for the nodeValue. |
else if ( sAttName == 'style' ) |
sAttValue = htmlNode.style.cssText ; |
// There are two cases when the oAttribute.nodeValue must be used: |
// - for the "class" attribute |
// - for events attributes (on IE only). |
else if ( sAttName == 'class' || sAttName.indexOf('on') == 0 ) |
sAttValue = oAttribute.nodeValue ; |
else if ( nodeName == 'body' && sAttName == 'contenteditable' ) |
continue ; |
// XHTML doens't support attribute minimization like "CHECKED". It must be trasformed to cheched="checked". |
else if ( oAttribute.nodeValue === true ) |
sAttValue = sAttName ; |
// We must use getAttribute to get it exactly as it is defined. |
else if ( ! (sAttValue = htmlNode.getAttribute( sAttName, 2 ) ) ) |
sAttValue = oAttribute.nodeValue ; |
this._AppendAttribute( node, sAttName, sAttValue ) ; |
} |
} |
} |
FCKXHtml.TagProcessors['meta'] = function( node, htmlNode ) |
{ |
var oHttpEquiv = node.attributes.getNamedItem( 'http-equiv' ) ; |
if ( oHttpEquiv == null || oHttpEquiv.value.length == 0 ) |
{ |
// Get the http-equiv value from the outerHTML. |
var sHttpEquiv = htmlNode.outerHTML.match( FCKRegexLib.MetaHttpEquiv ) ; |
if ( sHttpEquiv ) |
{ |
sHttpEquiv = sHttpEquiv[1] ; |
FCKXHtml._AppendAttribute( node, 'http-equiv', sHttpEquiv ) ; |
} |
} |
return node ; |
} |
// IE automaticaly changes <FONT> tags to <FONT size=+0>. |
FCKXHtml.TagProcessors['font'] = function( node, htmlNode ) |
{ |
if ( node.attributes.length == 0 ) |
node = FCKXHtml.XML.createDocumentFragment() ; |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
// IE doens't see the value attribute as an attribute for the <INPUT> tag. |
FCKXHtml.TagProcessors['input'] = function( node, htmlNode ) |
{ |
if ( htmlNode.name ) |
FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; |
if ( htmlNode.value && !node.attributes.getNamedItem( 'value' ) ) |
FCKXHtml._AppendAttribute( node, 'value', htmlNode.value ) ; |
if ( !node.attributes.getNamedItem( 'type' ) ) |
FCKXHtml._AppendAttribute( node, 'type', 'text' ) ; |
return node ; |
} |
// IE ignores the "SELECTED" attribute so we must add it manually. |
FCKXHtml.TagProcessors['option'] = function( node, htmlNode ) |
{ |
if ( htmlNode.selected && !node.attributes.getNamedItem( 'selected' ) ) |
FCKXHtml._AppendAttribute( node, 'selected', 'selected' ) ; |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
// IE ignores the "COORDS" and "SHAPE" attribute so we must add it manually. |
FCKXHtml.TagProcessors['area'] = function( node, htmlNode ) |
{ |
if ( ! node.attributes.getNamedItem( 'coords' ) ) |
{ |
var sCoords = htmlNode.getAttribute( 'coords', 2 ) ; |
if ( sCoords && sCoords != '0,0,0' ) |
FCKXHtml._AppendAttribute( node, 'coords', sCoords ) ; |
} |
if ( ! node.attributes.getNamedItem( 'shape' ) ) |
{ |
var sCoords = htmlNode.getAttribute( 'shape', 2 ) ; |
if ( sCoords && sCoords.length > 0 ) |
FCKXHtml._AppendAttribute( node, 'shape', sCoords ) ; |
} |
return node ; |
} |
FCKXHtml.TagProcessors['label'] = function( node, htmlNode ) |
{ |
if ( htmlNode.htmlFor.length > 0 ) |
FCKXHtml._AppendAttribute( node, 'for', htmlNode.htmlFor ) ; |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
FCKXHtml.TagProcessors['form'] = function( node, htmlNode ) |
{ |
if ( htmlNode.acceptCharset && htmlNode.acceptCharset.length > 0 && htmlNode.acceptCharset != 'UNKNOWN' ) |
FCKXHtml._AppendAttribute( node, 'accept-charset', htmlNode.acceptCharset ) ; |
if ( htmlNode.name ) |
FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
// IE doens't hold the name attribute as an attribute for the <TEXTAREA> and <SELECT> tags. |
FCKXHtml.TagProcessors['textarea'] = FCKXHtml.TagProcessors['select'] = function( node, htmlNode ) |
{ |
if ( htmlNode.name ) |
FCKXHtml._AppendAttribute( node, 'name', htmlNode.name ) ; |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
// On very rare cases, IE is loosing the "align" attribute for DIV. (right align and apply bulleted list) |
FCKXHtml.TagProcessors['div'] = function( node, htmlNode ) |
{ |
if ( htmlNode.align.length > 0 ) |
FCKXHtml._AppendAttribute( node, 'align', htmlNode.align ) ; |
FCKXHtml._AppendChildNodes( node, htmlNode ) ; |
return node ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktools_ie.js |
---|
New file |
0,0 → 1,202 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktools_ie.js |
* Utility functions. (IE version). |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
FCKTools.CancelEvent = function( e ) |
{ |
return false ; |
} |
// Appends one or more CSS files to a document. |
FCKTools._AppendStyleSheet = function( documentElement, cssFileUrl ) |
{ |
return documentElement.createStyleSheet( cssFileUrl ).owningElement ; |
} |
// Removes all attributes and values from the element. |
FCKTools.ClearElementAttributes = function( element ) |
{ |
element.clearAttributes() ; |
} |
FCKTools.GetAllChildrenIds = function( parentElement ) |
{ |
var aIds = new Array() ; |
for ( var i = 0 ; i < parentElement.all.length ; i++ ) |
{ |
var sId = parentElement.all[i].id ; |
if ( sId && sId.length > 0 ) |
aIds[ aIds.length ] = sId ; |
} |
return aIds ; |
} |
FCKTools.RemoveOuterTags = function( e ) |
{ |
e.insertAdjacentHTML( 'beforeBegin', e.innerHTML ) ; |
e.parentNode.removeChild( e ) ; |
} |
FCKTools.CreateXmlObject = function( object ) |
{ |
var aObjs ; |
switch ( object ) |
{ |
case 'XmlHttp' : |
aObjs = [ 'MSXML2.XmlHttp', 'Microsoft.XmlHttp' ] ; |
break ; |
case 'DOMDocument' : |
aObjs = [ 'MSXML2.DOMDocument', 'Microsoft.XmlDom' ] ; |
break ; |
} |
for ( var i = 0 ; i < 2 ; i++ ) |
{ |
try { return new ActiveXObject( aObjs[i] ) ; } |
catch (e) |
{} |
} |
if ( FCKLang.NoActiveX ) |
{ |
alert( FCKLang.NoActiveX ) ; |
FCKLang.NoActiveX = null ; |
} |
} |
FCKTools.DisableSelection = function( element ) |
{ |
element.unselectable = 'on' ; |
var e, i = 0 ; |
while ( e = element.all[ i++ ] ) |
{ |
switch ( e.tagName ) |
{ |
case 'IFRAME' : |
case 'TEXTAREA' : |
case 'INPUT' : |
case 'SELECT' : |
/* Ignore the above tags */ |
break ; |
default : |
e.unselectable = 'on' ; |
} |
} |
} |
FCKTools.GetScrollPosition = function( relativeWindow ) |
{ |
var oDoc = relativeWindow.document ; |
// Try with the doc element. |
var oPos = { X : oDoc.documentElement.scrollLeft, Y : oDoc.documentElement.scrollTop } ; |
if ( oPos.X > 0 || oPos.Y > 0 ) |
return oPos ; |
// If no scroll, try with the body. |
return { X : oDoc.body.scrollLeft, Y : oDoc.body.scrollTop } ; |
} |
FCKTools.AddEventListener = function( sourceObject, eventName, listener ) |
{ |
sourceObject.attachEvent( 'on' + eventName, listener ) ; |
} |
FCKTools.RemoveEventListener = function( sourceObject, eventName, listener ) |
{ |
sourceObject.detachEvent( 'on' + eventName, listener ) ; |
} |
// Listeners attached with this function cannot be detached. |
FCKTools.AddEventListenerEx = function( sourceObject, eventName, listener, paramsArray ) |
{ |
// Ok... this is a closures party, but is the only way to make it clean of memory leaks. |
var o = new Object() ; |
o.Source = sourceObject ; |
o.Params = paramsArray || [] ; // Memory leak if we have DOM objects here. |
o.Listener = function( ev ) |
{ |
return listener.apply( o.Source, [ ev ].concat( o.Params ) ) ; |
} |
if ( FCK.IECleanup ) |
FCK.IECleanup.AddItem( null, function() { o.Source = null ; o.Params = null ; } ) ; |
sourceObject.attachEvent( 'on' + eventName, o.Listener ) ; |
sourceObject = null ; // Memory leak cleaner (because of the above closure). |
paramsArray = null ; // Memory leak cleaner (because of the above closure). |
} |
// Returns and object with the "Width" and "Height" properties. |
FCKTools.GetViewPaneSize = function( win ) |
{ |
var oSizeSource ; |
var oDoc = win.document.documentElement ; |
if ( oDoc && oDoc.clientWidth ) // IE6 Strict Mode |
oSizeSource = oDoc ; |
else |
oSizeSource = top.document.body ; // Other IEs |
if ( oSizeSource ) |
return { Width : oSizeSource.clientWidth, Height : oSizeSource.clientHeight } ; |
else |
return { Width : 0, Height : 0 } ; |
} |
FCKTools.SaveStyles = function( element ) |
{ |
var oSavedStyles = new Object() ; |
if ( element.className.length > 0 ) |
{ |
oSavedStyles.Class = element.className ; |
element.className = '' ; |
} |
var sInlineStyle = element.style.cssText ; |
if ( sInlineStyle.length > 0 ) |
{ |
oSavedStyles.Inline = sInlineStyle ; |
element.style.cssText = '' ; |
} |
return oSavedStyles ; |
} |
FCKTools.RestoreStyles = function( element, savedStyles ) |
{ |
element.className = savedStyles.Class || '' ; |
element.style.cssText = savedStyles.Inline || '' ; |
} |
FCKTools.RegisterDollarFunction = function( targetWindow ) |
{ |
targetWindow.$ = targetWindow.document.getElementById ; |
} |
FCKTools.AppendElement = function( target, elementName ) |
{ |
return target.appendChild( this.GetElementDocument( target ).createElement( elementName ) ) ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fck.js |
---|
New file |
0,0 → 1,77 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fck.js |
* Creation and initialization of the "FCK" object. This is the main object |
* that represents an editor instance. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
// FCK represents the active editor instance |
var FCK = new Object() ; |
FCK.Name = FCKURLParams[ 'InstanceName' ] ; |
FCK.Status = FCK_STATUS_NOTLOADED ; |
FCK.EditMode = FCK_EDITMODE_WYSIWYG ; |
FCK.LoadLinkedFile = function() |
{ |
// There is a bug on IE... getElementById returns any META tag that has the |
// name set to the ID you are looking for. So the best way in to get the array |
// by names and look for the correct one. |
// As ASP.Net generates a ID that is different from the Name, we must also |
// look for the field based on the ID (the first one is the ID). |
var oDocument = window.parent.document ; |
var eLinkedField = oDocument.getElementById( FCK.Name ) ; |
var colElementsByName = oDocument.getElementsByName( FCK.Name ) ; |
var i = 0; |
while ( eLinkedField || i == 0 ) |
{ |
if ( eLinkedField && ( eLinkedField.tagName.toLowerCase() == 'input' || eLinkedField.tagName.toLowerCase() == 'textarea' ) ) |
{ |
FCK.LinkedField = eLinkedField ; |
break ; |
} |
eLinkedField = colElementsByName[i++] ; |
} |
} |
FCK.LoadLinkedFile() ; |
var FCKTempBin = new Object() ; |
FCKTempBin.Elements = new Array() ; |
FCKTempBin.AddElement = function( element ) |
{ |
var iIndex = this.Elements.length ; |
this.Elements[ iIndex ] = element ; |
return iIndex ; |
} |
FCKTempBin.RemoveElement = function( index ) |
{ |
var e = this.Elements[ index ] ; |
this.Elements[ index ] = null ; |
return e ; |
} |
FCKTempBin.Reset = function() |
{ |
var i = 0 ; |
while ( i < this.Elements.length ) |
this.Elements[ i++ ] == null ; |
this.Elements.length = 0 ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fckundo_ie.js |
---|
New file |
0,0 → 1,119 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fckundo_ie.js |
* IE specific implementation for the Undo/Redo system. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKUndo = new Object() ; |
FCKUndo.SavedData = new Array() ; |
FCKUndo.CurrentIndex = -1 ; |
FCKUndo.TypesCount = FCKUndo.MaxTypes = 25 ; |
FCKUndo.Typing = false ; |
FCKUndo.SaveUndoStep = function() |
{ |
if ( FCK.EditMode != FCK_EDITMODE_WYSIWYG ) |
return ; |
// Shrink the array to the current level. |
FCKUndo.SavedData = FCKUndo.SavedData.slice( 0, FCKUndo.CurrentIndex + 1 ) ; |
// Get the Actual HTML. |
var sHtml = FCK.EditorDocument.body.innerHTML ; |
// Cancel operation if the new step is identical to the previous one. |
if ( FCKUndo.CurrentIndex >= 0 && sHtml == FCKUndo.SavedData[ FCKUndo.CurrentIndex ][0] ) |
return ; |
// If we reach the Maximun number of undo levels, we must remove the first |
// entry of the list shifting all elements. |
if ( FCKUndo.CurrentIndex + 1 >= FCKConfig.MaxUndoLevels ) |
FCKUndo.SavedData.shift() ; |
else |
FCKUndo.CurrentIndex++ ; |
// Get the actual selection. |
var sBookmark ; |
if ( FCK.EditorDocument.selection.type == 'Text' ) |
sBookmark = FCK.EditorDocument.selection.createRange().getBookmark() ; |
// Save the new level in front of the actual position. |
FCKUndo.SavedData[ FCKUndo.CurrentIndex ] = [ sHtml, sBookmark ] ; |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
FCKUndo.CheckUndoState = function() |
{ |
return ( FCKUndo.Typing || FCKUndo.CurrentIndex > 0 ) ; |
} |
FCKUndo.CheckRedoState = function() |
{ |
return ( !FCKUndo.Typing && FCKUndo.CurrentIndex < ( FCKUndo.SavedData.length - 1 ) ) ; |
} |
FCKUndo.Undo = function() |
{ |
if ( FCKUndo.CheckUndoState() ) |
{ |
// If it is the first step. |
if ( FCKUndo.CurrentIndex == ( FCKUndo.SavedData.length - 1 ) ) |
{ |
// Save the actual state for a possible "Redo" call. |
FCKUndo.SaveUndoStep() ; |
} |
// Go a step back. |
FCKUndo._ApplyUndoLevel( --FCKUndo.CurrentIndex ) ; |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
} |
FCKUndo.Redo = function() |
{ |
if ( FCKUndo.CheckRedoState() ) |
{ |
// Go a step forward. |
FCKUndo._ApplyUndoLevel( ++FCKUndo.CurrentIndex ) ; |
FCK.Events.FireEvent( "OnSelectionChange" ) ; |
} |
} |
FCKUndo._ApplyUndoLevel = function(level) |
{ |
var oData = FCKUndo.SavedData[ level ] ; |
if ( !oData ) |
return ; |
// Update the editor contents with that step data. |
FCK.SetInnerHtml( oData[0] ) ; |
// FCK.EditorDocument.body.innerHTML = oData[0] ; |
if ( oData[1] ) |
{ |
var oRange = FCK.EditorDocument.selection.createRange() ; |
oRange.moveToBookmark( oData[1] ) ; |
oRange.select() ; |
} |
FCKUndo.TypesCount = 0 ; |
FCKUndo.Typing = false ; |
} |
/branches/livraison_aha/api/fckeditor/editor/_source/internals/fcktablehandler.js |
---|
New file |
0,0 → 1,383 |
/* |
* FCKeditor - The text editor for internet |
* Copyright (C) 2003-2006 Frederico Caldeira Knabben |
* |
* Licensed under the terms of the GNU Lesser General Public License: |
* http://www.opensource.org/licenses/lgpl-license.php |
* |
* For further information visit: |
* http://www.fckeditor.net/ |
* |
* "Support Open Source software. What about a donation today?" |
* |
* File Name: fcktablehandler.js |
* Manage table operations. |
* |
* File Authors: |
* Frederico Caldeira Knabben (fredck@fckeditor.net) |
*/ |
var FCKTableHandler = new Object() ; |
FCKTableHandler.InsertRow = function() |
{ |
// Get the row where the selection is placed in. |
var oRow = FCKSelection.MoveToAncestorNode("TR") ; |
if ( !oRow ) return ; |
// Create a clone of the row. |
var oNewRow = oRow.cloneNode( true ) ; |
// Insert the new row (copy) before of it. |
oRow.parentNode.insertBefore( oNewRow, oRow ) ; |
// Clean the row (it seems that the new row has been added after it). |
FCKTableHandler.ClearRow( oRow ) ; |
} |
FCKTableHandler.DeleteRows = function( row ) |
{ |
// If no row has been passed as a parameer, |
// then get the row where the selection is placed in. |
if ( !row ) |
row = FCKSelection.MoveToAncestorNode("TR") ; |
if ( !row ) return ; |
// Get the row's table. |
var oTable = FCKTools.GetElementAscensor( row, 'TABLE' ) ; |
// If just one row is available then delete the entire table. |
if ( oTable.rows.length == 1 ) |
{ |
FCKTableHandler.DeleteTable( oTable ) ; |
return ; |
} |
// Delete the row. |
row.parentNode.removeChild( row ) ; |
} |
FCKTableHandler.DeleteTable = function( table ) |
{ |
// If no table has been passed as a parameer, |
// then get the table where the selection is placed in. |
if ( !table ) |
{ |
var table = FCKSelection.GetSelectedElement() ; |
if ( !table || table.tagName != 'TABLE' ) |
table = FCKSelection.MoveToAncestorNode("TABLE") ; |
} |
if ( !table ) return ; |
// Delete the table. |
FCKSelection.SelectNode( table ) ; |
FCKSelection.Collapse(); |
table.parentNode.removeChild( table ) ; |
} |
FCKTableHandler.InsertColumn = function() |
{ |
// Get the cell where the selection is placed in. |
var oCell = FCKSelection.MoveToAncestorNode("TD") ; |
if ( !oCell ) |
oCell = FCKSelection.MoveToAncestorNode("TH") ; |
if ( !oCell ) return ; |
// Get the cell's table. |
var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ; |
// Get the index of the column to be created (based on the cell). |
var iIndex = oCell.cellIndex + 1 ; |
// Loop throw all rows available in the table. |
for ( var i = 0 ; i < oTable.rows.length ; i++ ) |
{ |
// Get the row. |
var oRow = oTable.rows[i] ; |
// If the row doens't have enought cells, ignore it. |
if ( oRow.cells.length < iIndex ) |
continue ; |
oCell = oRow.cells[iIndex-1].cloneNode(false) ; |
if ( FCKBrowserInfo.IsGecko ) |
oCell.innerHTML = GECKO_BOGUS ; |
// Get the cell that is placed in the new cell place. |
var oBaseCell = oRow.cells[iIndex] ; |
// If the cell is available (we are not in the last cell of the row). |
if ( oBaseCell ) |
oRow.insertBefore( oCell, oBaseCell ) ; // Insert the new cell just before of it. |
else |
oRow.appendChild( oCell ) ; // Append the cell at the end of the row. |
} |
} |
FCKTableHandler.DeleteColumns = function() |
{ |
// Get the cell where the selection is placed in. |
var oCell = FCKSelection.MoveToAncestorNode('TD') || FCKSelection.MoveToAncestorNode('TH') ; |
if ( !oCell ) return ; |
// Get the cell's table. |
var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ; |
// Get the cell index. |
var iIndex = oCell.cellIndex ; |
// Loop throw all rows (from down to up, because it's possible that some |
// rows will be deleted). |
for ( var i = oTable.rows.length - 1 ; i >= 0 ; i-- ) |
{ |
// Get the row. |
var oRow = oTable.rows[i] ; |
// If the cell to be removed is the first one and the row has just one cell. |
if ( iIndex == 0 && oRow.cells.length == 1 ) |
{ |
// Remove the entire row. |
FCKTableHandler.DeleteRows( oRow ) ; |
continue ; |
} |
// If the cell to be removed exists the delete it. |
if ( oRow.cells[iIndex] ) |
oRow.removeChild( oRow.cells[iIndex] ) ; |
} |
} |
FCKTableHandler.InsertCell = function( cell ) |
{ |
// Get the cell where the selection is placed in. |
var oCell = cell ? cell : FCKSelection.MoveToAncestorNode("TD") ; |
if ( !oCell ) return ; |
// Create the new cell element to be added. |
var oNewCell = FCK.EditorDocument.createElement("TD"); |
if ( FCKBrowserInfo.IsGecko ) |
oNewCell.innerHTML = GECKO_BOGUS ; |
// oNewCell.innerHTML = " " ; |
// If it is the last cell in the row. |
if ( oCell.cellIndex == oCell.parentNode.cells.length - 1 ) |
{ |
// Add the new cell at the end of the row. |
oCell.parentNode.appendChild( oNewCell ) ; |
} |
else |
{ |
// Add the new cell before the next cell (after the active one). |
oCell.parentNode.insertBefore( oNewCell, oCell.nextSibling ) ; |
} |
return oNewCell ; |
} |
FCKTableHandler.DeleteCell = function( cell ) |
{ |
// If this is the last cell in the row. |
if ( cell.parentNode.cells.length == 1 ) |
{ |
// Delete the entire row. |
FCKTableHandler.DeleteRows( FCKTools.GetElementAscensor( cell, 'TR' ) ) ; |
return ; |
} |
// Delete the cell from the row. |
cell.parentNode.removeChild( cell ) ; |
} |
FCKTableHandler.DeleteCells = function() |
{ |
var aCells = FCKTableHandler.GetSelectedCells() ; |
for ( var i = aCells.length - 1 ; i >= 0 ; i-- ) |
{ |
FCKTableHandler.DeleteCell( aCells[i] ) ; |
} |
} |
FCKTableHandler.MergeCells = function() |
{ |
// Get all selected cells. |
var aCells = FCKTableHandler.GetSelectedCells() ; |
// At least 2 cells must be selected. |
if ( aCells.length < 2 ) |
return ; |
// The merge can occour only if the selected cells are from the same row. |
if ( aCells[0].parentNode != aCells[aCells.length-1].parentNode ) |
return ; |
// Calculate the new colSpan for the first cell. |
var iColSpan = isNaN( aCells[0].colSpan ) ? 1 : aCells[0].colSpan ; |
var sHtml = '' ; |
var oCellsContents = FCK.EditorDocument.createDocumentFragment() ; |
for ( var i = aCells.length - 1 ; i >= 0 ; i-- ) |
{ |
var eCell = aCells[i] ; |
// Move its contents to the document fragment. |
for ( var c = eCell.childNodes.length - 1 ; c >= 0 ; c-- ) |
{ |
var eChild = eCell.removeChild( eCell.childNodes[c] ) ; |
if ( ( eChild.hasAttribute && eChild.hasAttribute('_moz_editor_bogus_node') ) || ( eChild.getAttribute && eChild.getAttribute( 'type', 2 ) == '_moz' ) ) |
continue ; |
oCellsContents.insertBefore( eChild, oCellsContents.firstChild ) ; |
} |
if ( i > 0 ) |
{ |
// Accumulate the colspan of the cell. |
iColSpan += isNaN( eCell.colSpan ) ? 1 : eCell.colSpan ; |
// Delete the cell. |
FCKTableHandler.DeleteCell( eCell ) ; |
} |
} |
// Set the innerHTML of the remaining cell (the first one). |
aCells[0].colSpan = iColSpan ; |
if ( FCKBrowserInfo.IsGecko && oCellsContents.childNodes.length == 0 ) |
aCells[0].innerHTML = GECKO_BOGUS ; |
else |
aCells[0].appendChild( oCellsContents ) ; |
} |
FCKTableHandler.SplitCell = function() |
{ |
// Check that just one cell is selected, otherwise return. |
var aCells = FCKTableHandler.GetSelectedCells() ; |
if ( aCells.length != 1 ) |
return ; |
var aMap = this._CreateTableMap( aCells[0].parentNode.parentNode ) ; |
var iCellIndex = FCKTableHandler._GetCellIndexSpan( aMap, aCells[0].parentNode.rowIndex , aCells[0] ) ; |
var aCollCells = this._GetCollumnCells( aMap, iCellIndex ) ; |
for ( var i = 0 ; i < aCollCells.length ; i++ ) |
{ |
if ( aCollCells[i] == aCells[0] ) |
{ |
var oNewCell = this.InsertCell( aCells[0] ) ; |
if ( !isNaN( aCells[0].rowSpan ) && aCells[0].rowSpan > 1 ) |
oNewCell.rowSpan = aCells[0].rowSpan ; |
} |
else |
{ |
if ( isNaN( aCollCells[i].colSpan ) ) |
aCollCells[i].colSpan = 2 ; |
else |
aCollCells[i].colSpan += 1 ; |
} |
} |
} |
// Get the cell index from a TableMap. |
FCKTableHandler._GetCellIndexSpan = function( tableMap, rowIndex, cell ) |
{ |
if ( tableMap.length < rowIndex + 1 ) |
return null ; |
var oRow = tableMap[ rowIndex ] ; |
for ( var c = 0 ; c < oRow.length ; c++ ) |
{ |
if ( oRow[c] == cell ) |
return c ; |
} |
return null ; |
} |
// Get the cells available in a collumn of a TableMap. |
FCKTableHandler._GetCollumnCells = function( tableMap, collumnIndex ) |
{ |
var aCollCells = new Array() ; |
for ( var r = 0 ; r < tableMap.length ; r++ ) |
{ |
var oCell = tableMap[r][collumnIndex] ; |
if ( oCell && ( aCollCells.length == 0 || aCollCells[ aCollCells.length - 1 ] != oCell ) ) |
aCollCells[ aCollCells.length ] = oCell ; |
} |
return aCollCells ; |
} |
// This function is quite hard to explain. It creates a matrix representing all cells in a table. |
// The difference here is that the "spanned" cells (colSpan and rowSpan) are duplicated on the matrix |
// cells that are "spanned". For example, a row with 3 cells where the second cell has colSpan=2 and rowSpan=3 |
// will produce a bi-dimensional matrix with the following values (representing the cells): |
// Cell1, Cell2, Cell2, Cell 3 |
// Cell4, Cell2, Cell2, Cell 5 |
FCKTableHandler._CreateTableMap = function( table ) |
{ |
var aRows = table.rows ; |
// Row and Collumn counters. |
var r = -1 ; |
var aMap = new Array() ; |
for ( var i = 0 ; i < aRows.length ; i++ ) |
{ |
r++ ; |
if ( !aMap[r] ) |
aMap[r] = new Array() ; |
var c = -1 ; |
for ( var j = 0 ; j < aRows[i].cells.length ; j++ ) |
{ |
var oCell = aRows[i].cells[j] ; |
c++ ; |
while ( aMap[r][c] ) |
c++ ; |
var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ; |
var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ; |
for ( var rs = 0 ; rs < iRowSpan ; rs++ ) |
{ |
if ( !aMap[r + rs] ) |
aMap[r + rs] = new Array() ; |
for ( var cs = 0 ; cs < iColSpan ; cs++ ) |
{ |
aMap[r + rs][c + cs] = aRows[i].cells[j] ; |
} |
} |
c += iColSpan - 1 ; |
} |
} |
return aMap ; |
} |
FCKTableHandler.ClearRow = function( tr ) |
{ |
// Get the array of row's cells. |
var aCells = tr.cells ; |
// Replace the contents of each cell with "nothing". |
for ( var i = 0 ; i < aCells.length ; i++ ) |
{ |
if ( FCKBrowserInfo.IsGecko ) |
aCells[i].innerHTML = GECKO_BOGUS ; |
else |
aCells[i].innerHTML = '' ; |
} |
} |