Index: /CKEditor/trunk/_source/plugins/basicstyles/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/basicstyles/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/basicstyles/plugin.js (revision 2985) @@ -0,0 +1,55 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +CKEDITOR.plugins.add( 'basicstyles', +{ + requires : [ 'styles', 'button' ], + + init : function( editor, pluginPath ) + { + // All buttons use the same code to register. So, to avoid + // duplications, let's use this tool function. + var addButtonCommand = function( buttonName, buttonLabel, commandName, styleDefiniton ) + { + var style = new CKEDITOR.style( styleDefiniton ); + + editor.attachStyleStateChange( style, function( state ) + { + var command = editor.getCommand( commandName ); + command.state = state; + command.fire( 'state' ); + }); + + editor.addCommand( commandName, new CKEDITOR.styleCommand( style ) ); + + editor.ui.addButton( buttonName, + { + label : buttonLabel, + command : commandName + }); + }; + + var coreStyles = editor.config.coreStyles; + var lang = editor.lang; + + addButtonCommand( 'Bold' , lang.bold , 'bold' , coreStyles.bold ); + addButtonCommand( 'Italic' , lang.italic , 'italic' , coreStyles.italic ); + addButtonCommand( 'Underline' , lang.underline , 'underline' , coreStyles.underline ); + addButtonCommand( 'Strike' , lang.strike , 'strike' , coreStyles.strike ); + addButtonCommand( 'Subscript' , lang.subscript , 'subscript' , coreStyles.subscript ); + addButtonCommand( 'Superscript' , lang.superscript , 'superscript' , coreStyles.superscript ); + } +}); + +CKEDITOR.config.coreStyles = +{ + // Basic Inline Styles. + bold : { element : 'strong', overrides : 'b' }, + italic : { element : 'em', overrides : 'i' }, + underline : { element : 'u' }, + strike : { element : 'strike' }, + subscript : { element : 'sub' }, + superscript : { element : 'sup' } +}; Index: /CKEditor/trunk/_source/plugins/button/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/button/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/button/plugin.js (revision 2985) @@ -0,0 +1,237 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +CKEDITOR.plugins.add( 'button', +{ + beforeInit : function( editor ) + { + editor.ui.addHandler( CKEDITOR.UI_BUTTON, CKEDITOR.ui.button.handler ); + } +}); + +/** + * Button UI element. + * @constant + * @example + */ +CKEDITOR.UI_BUTTON = 1; + +/** + * Represents a button UI element. This class should not be called directly. To + * create new buttons use {@link CKEDITOR.ui.prototype.addButton} instead. + * @constructor + * @param {Object} definition The button definition. + * @example + */ +CKEDITOR.ui.button = function( definition ) +{ + /** + * The button label. + * @name CKEDITOR.ui.button.prototype.label + * @type String + * @example + */ + this.label = definition.label; + + /** + * The button advisory title. It is usually displayed as the button tooltip. + * If not defined, the label is used. + * @name CKEDITOR.ui.button.prototype.title + * @type String + * @example + */ + this.title = definition.title || definition.label; + + /** + * The command name associated to the button. If no command is defined, the + * "click" event is used. + * @name CKEDITOR.ui.button.prototype.command + * @type String + * @example + */ + this.command = definition.command; + + this.className = definition.className || ( definition.command && 'cke_button_' + definition.command ) || ''; + + /** + * The function to be called when the user clicks the button. If not + * defined, the "command" property is required, and the command gets + * executed on click. + * @function + * @name CKEDITOR.ui.button.prototype.click + * @example + */ + this.click = definition.click || function( editor ) + { + editor.execCommand( definition.command ); + }; + + this._ = {}; +}; + +/** + * Transforms a button definition in a {@link CKEDITOR.ui.button} instance. + * @type Object + * @example + */ +CKEDITOR.ui.button.handler = +{ + create : function( definition ) + { + return new CKEDITOR.ui.button( definition ); + } +}; + +CKEDITOR.ui.button.prototype = +{ + /** + * Renders the button. + * @param {CKEDITOR.editor} editor The editor instance which this button is + * to be used by. + * @param {Array} output The output array to which append the HTML relative + * to this button. + * @example + */ + render : function( editor, output ) + { + var env = CKEDITOR.env; + + var id = this._.id = 'cke_' + CKEDITOR.tools.getNextNumber(); + + var instance = + { + id : id, + button : this, + editor : editor, + focus : function() + { + var element = CKEDITOR.document.getById( id ); + element.focus(); + }, + execute : function() + { + this.button.click( editor ); + } + }; + + // Get the command name. + var command = this.command; + + if ( command ) + { + // Get the command instance. + command = editor.getCommand( command ); + + if ( command ) + { + command.on( 'state', function() + { + this.setState( command.state ); + }, this); + } + } + + var index = CKEDITOR.ui.button._.instances.push( instance ) - 1; + + output.push( + '' + + '' + + '', this.label, '' + + '' ); + + return instance; + }, + + setState : function( state ) + { + var element = CKEDITOR.document.getById( this._.id ); + + switch ( state ) + { + case CKEDITOR.TRISTATE_ON : + element.addClass( 'cke_on' ); + element.removeClass( 'cke_off' ); + element.removeClass( 'cke_disabled' ); + break; + case CKEDITOR.TRISTATE_DISABLED : + element.addClass( 'cke_disabled' ); + element.removeClass( 'cke_off' ); + element.removeClass( 'cke_on' ); + break; + default : + element.addClass( 'cke_off' ); + element.removeClass( 'cke_on' ); + element.removeClass( 'cke_disabled' ); + break; + } + } +}; + +/** + * Handles a button click. + * @private + */ +CKEDITOR.ui.button._ = +{ + instances : [], + + click : function( index ) + { + CKEDITOR.ui.button._.instances[ index ].execute(); + return false; + }, + + keydown : function( index, ev ) + { + var instance = CKEDITOR.ui.button._.instances[ index ]; + + if ( instance.onkey ) + { + ev = new CKEDITOR.dom.event( ev ); + return ( instance.onkey( instance, ev.getKeystroke() ) !== false ); + } + } +}; + +/** + * Adds a button definition to the UI elements list. + * @param {String} The button name. + * @param {Object} The button definition. + * @example + * editorInstance.ui.addButton( 'MyBold', + * { + * label : 'My Bold', + * command : 'bold' + * }); + */ +CKEDITOR.ui.prototype.addButton = function( name, definition ) +{ + this.add( name, CKEDITOR.UI_BUTTON, definition ); +}; Index: /CKEditor/trunk/_source/plugins/editingblock/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/editingblock/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/editingblock/plugin.js (revision 2985) @@ -0,0 +1,157 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +/** + * @fileOverview The default editing block plugin, which holds the editing area + * and source view. + */ + +(function() +{ + var getMode = function( editor, mode ) + { + return editor._.modes && editor._.modes[ mode || editor.mode ]; + }; + + // This is a semaphore used to avoid recursive calls between + // the following data handling functions. + var isHandlingData; + + CKEDITOR.plugins.add( 'editingblock', + { + init : function( editor, pluginPath ) + { + if ( !editor.config.editingBlock ) + return; + + editor.on( 'themeSpace', function( event ) + { + if ( event.data.space == 'contents' ) + event.data.html += '
'; + }); + + editor.on( 'themeLoaded', function() + { + editor.fireOnce( 'editingBlockReady' ); + }); + + editor.on( 'uiReady', function() + { + editor.setMode( editor.config.startupMode ); + + if ( editor.config.startupFocus ) + editor.focus(); + }); + + editor.on( 'afterSetData', function() + { + if ( !isHandlingData && editor.mode ) + { + isHandlingData = true; + getMode( editor ).loadData( editor.getData() ); + isHandlingData = false; + } + }); + + editor.on( 'beforeGetData', function() + { + if ( !isHandlingData && editor.mode ) + { + isHandlingData = true; + editor.setData( getMode( editor ).getData() ); + isHandlingData = false; + } + }); + } + }); + + /** + * The current editing mode. An editing mode is basically a viewport for + * editing or content viewing. By default the possible values for this + * property are "wysiwyg" and "source". + * @type String + * @example + * alert( CKEDITOR.instances.editor1.mode ); // "wysiwyg" (e.g.) + */ + CKEDITOR.editor.prototype.mode = ''; + + /** + * Registers an editing mode. This function is to be used mainly by plugins. + * @param {String} mode The mode name. + * @param {Object} modeEditor The mode editor definition. + * @example + */ + CKEDITOR.editor.prototype.addMode = function( mode, modeEditor ) + { + modeEditor.name = mode; + ( this._.modes || ( this._.modes = {} ) )[ mode ] = modeEditor; + }; + + /** + * Sets the current editing mode in this editor instance. + * @param {String} mode A registered mode name. + * @example + * // Switch to "source" view. + * CKEDITOR.instances.editor1.setMode( 'source' ); + */ + CKEDITOR.editor.prototype.setMode = function( mode ) + { + var data, + holderElement = this.getThemeSpace( 'contents' ); + + // Unload the previous mode. + if ( this.mode ) + { + if ( mode == this.mode ) + return; + + var currentMode = getMode( this ); + data = currentMode.getData(); + currentMode.unload( holderElement ); + this.mode = ''; + } + + holderElement.setHtml( '' ); + + // Load required mode. + var modeEditor = getMode( this, mode ); + if ( !modeEditor ) + throw '[CKEDITOR.editor.setMode] Unknown mode "' + mode + '".'; + + modeEditor.load( holderElement, data || this.getData() ); + + this.mode = mode; + this.fire( 'mode' ); + }; + + /** + * Moves the selection focus to the editing are space in the editor. + */ + CKEDITOR.editor.prototype.focus = function() + { + var mode = getMode( this ); + if ( mode ) + mode.focus(); + }; +})(); + +/** + * The mode to load at the editor startup. It depends on the plugins + * loaded. By default, the "wysiwyg" and "source" modes are available. + * @type String + * @default 'wysiwyg' + * @example + * config.toolbarLocation = 'source'; + */ +CKEDITOR.config.startupMode = 'wysiwyg'; + +/** + * Sets whether the editor should have the focus when the page loads. + * @type Boolean + * @default false + */ +CKEDITOR.config.startupFocus = false; + +CKEDITOR.config.editingBlock = true; Index: /CKEditor/trunk/_source/plugins/elementspath/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/elementspath/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/elementspath/plugin.js (revision 2985) @@ -0,0 +1,177 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +/** + * @fileOverview The "elementspath" plugin. It shows all elements in the DOM + * parent tree relative to the current selection in the editing area. + */ + +(function() +{ + var commands = + { + toolbarFocus : + { + exec : function( editor ) + { + var idBase = editor._.elementsPath.idBase; + var element = CKEDITOR.document.getById( idBase + '0' ); + + if ( element ) + element.focus(); + } + } + }; + + CKEDITOR.plugins.add( 'elementspath', + { + requires : [ 'selection' ], + + init : function( editor, pluginPath ) + { + var spaceId = 'cke_path_' + editor.name; + var spaceElement; + var getSpaceElement = function() + { + if ( !spaceElement ) + spaceElement = CKEDITOR.document.getById( spaceId ); + return spaceElement; + }; + + var idBase = 'cke_elementspath_' + CKEDITOR.tools.getNextNumber() + '_'; + + editor._.elementsPath = { idBase : idBase }; + + editor.on( 'themeSpace', function( event ) + { + if ( event.data.space == 'bottom' ) + event.data.html += '

'; + }); + + editor.on( 'selectionChange', function( ev ) + { + var env = CKEDITOR.env; + + var selection = ev.data.selection; + + var element = selection.getStartElement(), + html = [], + elementsList = this._.elementsPath.list = []; + + while ( element ) + { + var index = elementsList.push( element ) - 1; + var name; + if ( element.getAttribute( '_cke_real_element_type' ) ) + name = element.getAttribute( '_cke_real_element_type' ); + else + name = element.getName(); + + // Use this variable to add conditional stuff to the + // HTML (because we are doing it in reverse order... unshift). + var extra = ''; + + // Some browsers don't cancel key events in the keydown but in the + // keypress. + // TODO: Check if really needed for Gecko+Mac. + if ( env.opera || ( env.gecko && env.mac ) ) + extra += ' onkeypress="return false;"'; + + // With Firefox, we need to force the button to redraw, otherwise it + // will remain in the focus state. + if ( env.gecko ) + extra += ' onblur="this.style.cssText = this.style.cssText;"'; + + html.unshift( + '', + name, + '' ); + + if ( name == 'body' ) + break; + + element = element.getParent(); + } + + getSpaceElement().setHtml( html.join('') ); + }); + + editor.on( 'contentDomUnload', function() + { + getSpaceElement().setHtml( '
' ); + }); + + editor.addCommand( 'elementsPathFocus', commands.toolbarFocus ); + } + }); +})(); + +/** + * Handles the click on an element in the element path. + * @private + */ +CKEDITOR._.elementsPath = +{ + click : function( instanceName, elementIndex ) + { + var editor = CKEDITOR.instances[ instanceName ]; + editor.focus(); + + var element = editor._.elementsPath.list[ elementIndex ]; + editor.getSelection().selectElement( element ); + + return false; + }, + + keydown : function( instanceName, elementIndex, ev ) + { + var instance = CKEDITOR.ui.button._.instances[ elementIndex ]; + var editor = CKEDITOR.instances[ instanceName ]; + var idBase = editor._.elementsPath.idBase; + + var element; + + ev = new CKEDITOR.dom.event( ev ); + + switch ( ev.getKeystroke() ) + { + case 37 : // LEFT-ARROW + case 9 : // TAB + element = CKEDITOR.document.getById( idBase + ( elementIndex + 1 ) ); + if ( !element ) + element = CKEDITOR.document.getById( idBase + '0' ); + element.focus(); + return false; + + case 39 : // RIGHT-ARROW + case CKEDITOR.SHIFT + 9 : // SHIFT + TAB + element = CKEDITOR.document.getById( idBase + ( elementIndex - 1 ) ); + if ( !element ) + element = CKEDITOR.document.getById( idBase + ( editor._.elementsPath.list.length - 1 ) ); + element.focus(); + return false; + + case 27 : // ESC + editor.focus(); + return false; + + case 13 : // ENTER // Opera + case 32 : // SPACE + this.click( instanceName, elementIndex ); + return false; + + //default : + // alert( ev.getKeystroke() ); + } + return true; + } +}; Index: /CKEditor/trunk/_source/plugins/htmldataprocessor/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/htmldataprocessor/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/htmldataprocessor/plugin.js (revision 2985) @@ -0,0 +1,40 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +CKEDITOR.plugins.add( 'htmldataprocessor', +{ + requires : [ 'htmlwriter' ], + + init : function( editor, pluginPath ) + { + editor.dataProcessor = new CKEDITOR.htmlDataProcessor(); + } +}); + +CKEDITOR.htmlDataProcessor = function() +{ + this.writer = new CKEDITOR.htmlWriter(); +}; + +CKEDITOR.htmlDataProcessor.prototype = +{ + toHtml : function( data ) + { + // The source data is already HTML, so just return it as is. + return data; + }, + + toDataFormat : function( element ) + { + var writer = this.writer, + fragment = CKEDITOR.htmlParser.fragment.fromHtml( element.getHtml() ); + + writer.reset(); + + fragment.writeHtml( writer ); + + return writer.getHtml( true ); + } +}; Index: /CKEditor/trunk/_source/plugins/htmlwriter/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/htmlwriter/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/htmlwriter/plugin.js (revision 2985) @@ -0,0 +1,302 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +/** + * Class used to write HTML data. + * @constructor + * @example + * var writer = new CKEDITOR.htmlWriter(); + * writer.openTag( 'p' ); + * writer.attribute( 'class', 'MyClass' ); + * writer.openTagClose( 'p' ); + * writer.text( 'Hello' ); + * writer.closeTag( 'p' ); + * alert( writer.getHtml() ); "<p class="MyClass">Hello</p>" + */ +CKEDITOR.htmlWriter = function() +{ + /** + * The characters to be used for each identation step. + * @type String + * @default "\t" (tab) + * @example + * // Use two spaces for indentation. + * editorInstance.dataProcessor.writer.indentationChars = ' '; + */ + this.indentationChars = '\t'; + + /** + * The characters to be used to close "self-closing" elements, like "br" or + * "img". + * @type String + * @default " />" + * @example + * // Use HTML4 notation for self-closing elements. + * editorInstance.dataProcessor.writer.selfClosingEnd = '>'; + */ + this.selfClosingEnd = ' />'; + + /** + * The characters to be used for line breaks. + * @type String + * @default "\n" (LF) + * @example + * // Use CRLF for line breaks. + * editorInstance.dataProcessor.writer.lineBreakChars = '\r\n'; + */ + this.lineBreakChars = '\n'; + + this._ = + { + output : [], + indent : false, + indentation : '', + rules : {} + }; + + var dtd = CKEDITOR.dtd; + + for ( var e in CKEDITOR.tools.extend( {}, dtd.$block, dtd.$listItem, dtd.$tableContent ) ) + { + this.setRules( e, + { + indent : true, + breakBeforeOpen : true, + breakAfterOpen : true, + breakBeforeClose : !dtd[ e ][ '#' ], + breakAfterClose : true + }); + } + + this.setRules( 'br', + { + breakAfterOpen : true + }); +}; + +CKEDITOR.htmlWriter.prototype = +{ + /** + * Writes the tag opening part for a opener tag. + * @param {String} tagName The element name for this tag. + * @param {Object} attributes The attributes defined for this tag. The + * attributes could be used to inspect the tag. + * @example + * // Writes "<p". + * writer.openTag( 'p', { class : 'MyClass', id : 'MyId' } ); + */ + openTag : function( tagName, attributes ) + { + var rules = this._.rules[ tagName ]; + + if ( this._.indent ) + this.indentation(); + // Do not break if indenting. + else if ( rules && rules.breakBeforeOpen ) + { + this.lineBreak(); + this.indentation(); + } + + this._.output.push( '<', tagName ); + }, + + /** + * Writes the tag closing part for a opener tag. + * @param {String} tagName The element name for this tag. + * @param {Boolean} isSelfClose Indicates that this is a self-closing tag, + * like "br" or "img". + * @example + * // Writes ">". + * writer.openTagClose( 'p', false ); + * @example + * // Writes " />". + * writer.openTagClose( 'br', true ); + */ + openTagClose : function( tagName, isSelfClose ) + { + var rules = this._.rules[ tagName ]; + + if ( isSelfClose ) + this._.output.push( this.selfClosingEnd ); + else + { + this._.output.push( '>' ); + + if ( rules && rules.indent ) + this._.indentation += this.indentationChars; + } + + if ( rules && rules.breakAfterOpen ) + this.lineBreak(); + }, + + /** + * Writes an attribute. This function should be called after opening the + * tag with {@link #openTagClose}. + * @param {String} attName The attribute name. + * @param {String} attValue The attribute value. + * @example + * // Writes ' class="MyClass"'. + * writer.attribute( 'class', 'MyClass' ); + */ + attribute : function( attName, attValue ) + { + this._.output.push( ' ', attName, '="', attValue, '"' ); + }, + + /** + * Writes a closer tag. + * @param {String} tagName The element name for this tag. + * @example + * // Writes "</p>". + * writer.closeTag( 'p' ); + */ + closeTag : function( tagName ) + { + var rules = this._.rules[ tagName ]; + + if ( rules && rules.indent ) + this._.indentation = this._.indentation.substr( this.indentationChars.length ); + + if ( this._.indent ) + this.indentation(); + // Do not break if indenting. + else if ( rules && rules.breakBeforeClose ) + { + this.lineBreak(); + this.indentation(); + } + + this._.output.push( '' ); + + if ( rules && rules.breakAfterClose ) + this.lineBreak(); + }, + + /** + * Writes text. + * @param {String} text The text value + * @example + * // Writes "Hello Word". + * writer.text( 'Hello Word' ); + */ + text : function( text ) + { + if ( this._.indent ) + { + this.indentation(); + text = CKEDITOR.tools.ltrim( text ); + } + + this._.output.push( text ); + }, + + /** + * Writes a comment. + * @param {String} comment The comment text. + * @example + * // Writes "<!-- My comment -->". + * writer.comment( ' My comment ' ); + */ + comment : function( comment ) + { + if ( this._.indent ) + this.indentation(); + + this._.output.push( '' ); + }, + + /** + * Writes a line break. It uses the {@link #lineBreakChars} property for it. + * @example + * // Writes "\n" (e.g.). + * writer.lineBreak(); + */ + lineBreak : function() + { + if ( this._.output.length > 0 ) + this._.output.push( this.lineBreakChars ); + this._.indent = true; + }, + + /** + * Writes the current indentation chars. It uses the + * {@link #indentationChars} property, repeating it for the current + * intentation steps. + * @example + * // Writes "\t" (e.g.). + * writer.indentation(); + */ + indentation : function() + { + this._.output.push( this._.indentation ); + this._.indent = false; + }, + + /** + * Empties the current output buffer. + * @example + * writer.reset(); + */ + reset : function() + { + this._.output = []; + }, + + /** + * Empties the current output buffer. + * @param {Boolean} reset Indicates that the {@link reset} function is to + * be automatically called after retrieving the HTML. + * @returns {String} The HTML written to the writer so far. + * @example + * var html = writer.getHtml(); + */ + getHtml : function( reset ) + { + var html = this._.output.join( '' ); + + if ( reset ) + this.reset(); + + return html; + }, + + /** + * Sets formatting rules for a give element. The possible rules are: + * + * + * All rules default to "false". + * + * By default, all elements available in the {@link CKEDITOR.dtd.$block), + * {@link CKEDITOR.dtd.$listItem} and {@link CKEDITOR.dtd.$tableContent} + * lists have all the above rules set to "true". Additionaly, the "br" + * element has the "breakAfterOpen" set to "true". + * @param {String} tagName The element name to which set the rules. + * @param {Object} rules An object containing the element rules. + * @example + * // Break line before and after "img" tags. + * writer.setRules( 'img', + * { + * breakBeforeOpen : true + * breakAfterOpen : true + * }); + * @example + * // Reset the rules for the "h1" tag. + * writer.setRules( 'h1', {} ); + */ + setRules : function( tagName, rules ) + { + this._.rules[ tagName ] = rules; + } +}; + +CKEDITOR.plugins.add( 'htmlwriter' ); Index: /CKEditor/trunk/_source/plugins/keystrokes/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/keystrokes/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/keystrokes/plugin.js (revision 2985) @@ -0,0 +1,158 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +// Register a plugin named "sample". +CKEDITOR.plugins.add( 'keystrokes', +{ + beforeInit : function( editor ) + { + /** + * Controls keystrokes typing in this editor instance. + * @name CKEDITOR.editor.prototype.keystrokeHandler + * @type CKEDITOR.keystrokeHandler + * @example + */ + editor.keystrokeHandler = new CKEDITOR.keystrokeHandler( editor ); + }, + + init : function( editor ) + { + var keystrokesConfig = editor.config.keystrokes, + blockedConfig = editor.config.blockedKeystrokes; + + var keystrokes = editor.keystrokeHandler.keystrokes, + blockedKeystrokes = editor.keystrokeHandler.blockedKeystrokes; + + for ( var i = 0 ; i < keystrokesConfig.length ; i++ ) + { + keystrokes[ keystrokesConfig[i][0] ] = keystrokesConfig[i][1]; + } + + for ( i = 0 ; i < blockedConfig.length ; i++ ) + { + blockedKeystrokes[ blockedConfig[i] ] = 1; + } + } +}); + +/** + * Controls keystrokes typing in an editor instance. + * @constructor + * @param {CKEDITOR.editor} editor The editor instance. + * @example + */ +CKEDITOR.keystrokeHandler = function( editor ) +{ + if ( editor.keystrokeHandler ) + return editor.keystrokeHandler; + + /** + * List of keystrokes associated to commands. Each entry points to the + * command to be executed. + * @type Object + * @example + */ + this.keystrokes = {}; + + /** + * List of keystrokes that should be blocked if not defined at + * {@link keystrokes}. In this way it is possible to block the default + * browser behavior for those keystrokes. + * @type Object + * @example + */ + this.blockedKeystrokes = {}; + + this._ = + { + editor : editor + }; + + return this; +}; + +(function() +{ + var onKeyDown = function( event ) + { + // The DOM event object is passed by the "data" property. + event = event.data; + + var keyCombination = event.getKeystroke(); + var command = this.keystrokes[ keyCombination ]; + + var cancel = !this._.editor.fire( 'key', { keyCode : keyCombination } ); + + if ( !cancel ) + { + if ( command ) + cancel = ( this._.editor.execCommand( command ) !== false ); + + if ( !cancel ) + cancel = !!this.blockedKeystrokes[ keyCombination ]; + } + + if ( cancel ) + event.preventDefault( true ); + + return !cancel; + }; + + CKEDITOR.keystrokeHandler.prototype = + { + /** + * Attaches this keystroke handle to a DOM object. Keystrokes typed + ** over this object will get handled by this keystrokeHandler. + * @param {CKEDITOR.dom.domObject} domObject The DOM object to attach + * to. + * @example + */ + attach : function( domObject ) + { + domObject.on( 'keydown', onKeyDown, this ); + } + }; +})(); + +/** + * A list of keystrokes to be blocked if not defined in the {@link #keystrokes} + * setting. In this way it is possible to block the default browser behavior + * for those keystrokes. + * @type Array + * @example + */ +CKEDITOR.config.blockedKeystrokes = +[ + CKEDITOR.CTRL + 66 /*B*/, + CKEDITOR.CTRL + 73 /*I*/, + CKEDITOR.CTRL + 85 /*U*/ +]; + +/** + * A list associating keystrokes to editor commands. Each element in the list + * is an array where the first item is the keystroke, and the second is the + * command to be executed. + * @type Array + * @example + */ +CKEDITOR.config.keystrokes = +[ + [ CKEDITOR.ALT + 121 /*F10*/, 'toolbarFocus' ], + [ CKEDITOR.ALT + 122 /*F11*/, 'elementsPathFocus' ], + + [ CKEDITOR.CTRL + 86 /*V*/, 'paste' ], + [ CKEDITOR.SHIFT + 45 /*INS*/, 'paste' ], + [ CKEDITOR.CTRL + 88 /*X*/, 'cut' ], + [ CKEDITOR.SHIFT + 46 /*DEL*/, 'cut' ], + [ CKEDITOR.CTRL + 90 /*Z*/, 'undo' ], + [ CKEDITOR.CTRL + 89 /*Y*/, 'redo' ], + [ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 /*Z*/, 'redo' ], + [ CKEDITOR.CTRL + 76 /*L*/, 'link' ], + [ CKEDITOR.CTRL + 66 /*B*/, 'bold' ], + [ CKEDITOR.CTRL + 73 /*I*/, 'italic' ], + [ CKEDITOR.CTRL + 85 /*U*/, 'underline' ], + [ CKEDITOR.CTRL + CKEDITOR.ALT + 13 /*ENTER*/, 'fitWindow' ], + [ CKEDITOR.SHIFT + 32 /*SPACE*/, 'nbsp' ] +]; Index: /CKEditor/trunk/_source/plugins/removeformat/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/removeformat/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/removeformat/plugin.js (revision 2985) @@ -0,0 +1,119 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +CKEDITOR.plugins.add( 'removeformat', +{ + requires : [ 'selection' ], + + init : function( editor, pluginPath ) + { + editor.addCommand( 'removeFormat', CKEDITOR.plugins.removeformat.commands.removeformat ); + editor.ui.addButton( 'RemoveFormat', + { + label : editor.lang.removeFormat, + command : 'removeFormat' + }); + } +}); + +CKEDITOR.plugins.removeformat = +{ + commands : + { + removeformat : + { + exec : function( editor ) + { + var tagsRegex = editor._.removeFormatRegex || + ( editor._.removeFormatRegex = new RegExp( '^(?:' + editor.config.removeFormatTags.replace( /,/g,'|' ) + ')$', 'i' ) ); + + var removeAttributes = editor._.removeAttributes || + ( editor._.removeAttributes = editor.config.removeFormatAttributes.split( ',' ) ); + + var ranges = editor.getSelection().getRanges(); + + for ( var i = 0, range ; range = ranges[ i ] ; i++ ) + { + if ( range.collapsed ) + continue; + + range.enlarge( CKEDITOR.ENLARGE_ELEMENT ); + + // Bookmark the range so we can re-select it after processing. + var bookmark = range.createBookmark(); + + // The style will be applied within the bookmark boundaries. + var startNode = bookmark.startNode; + var endNode = bookmark.endNode; + + // We need to check the selection boundaries (bookmark spans) to break + // the code in a way that we can properly remove partially selected nodes. + // For example, removing a style from + // This is [some text to show the] problem + // ... where [ and ] represent the selection, must result: + // This is [some text to show the] problem + // The strategy is simple, we just break the partial nodes before the + // removal logic, having something that could be represented this way: + // This is [some text to show the] problem + + var breakParent = function( node ) + { + // Let's start checking the start boundary. + var path = new CKEDITOR.dom.elementPath( node ); + var pathElements = path.elements; + + for ( var i = 1, pathElement ; pathElement = pathElements[ i ] ; i++ ) + { + if ( pathElement.equals( path.block ) || pathElement.equals( path.blockLimit ) ) + break; + + // If this element can be removed (even partially). + if ( tagsRegex.test( pathElement.getName() ) ) + node.breakParent( pathElement ); + } + }; + + breakParent( startNode ); + breakParent( endNode ); + + // Navigate through all nodes between the bookmarks. + var currentNode = startNode.getNextSourceNode( true, CKEDITOR.NODE_ELEMENT ); + + while ( currentNode ) + { + // If we have reached the end of the selection, stop looping. + if ( currentNode.equals( endNode ) ) + break; + + // Cache the next node to be processed. Do it now, because + // currentNode may be removed. + var nextNode = currentNode.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT ); + + // This node must not be a fake element. + if ( currentNode.getName() != 'img' || !currentNode.getAttribute( '_cke_protected_html' ) ) + { + // Remove elements nodes that match with this style rules. + if ( tagsRegex.test( currentNode.getName() ) ) + currentNode.remove( true ); + else + currentNode.removeAttributes( removeAttributes ); + } + + currentNode = nextNode; + } + + range.moveToBookmark( bookmark ); + } + + editor.getSelection().selectRanges( ranges ); + } + } + } +}; + +// Only inline elements are valid. +CKEDITOR.config.removeFormatTags = 'b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var'; + +CKEDITOR.config.removeFormatAttributes = 'class,style,lang,width,height,align,hspace,valign'; Index: /CKEditor/trunk/_source/plugins/selection/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/selection/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/selection/plugin.js (revision 2985) @@ -0,0 +1,765 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +(function() +{ + // #### checkSelectionChange : START + + // The selection change check basically saves the element parent tree of + // the current node and check it on successive requests. If there is any + // change on the tree, then the selectionChange event gets fired. + var checkSelectionChange = function() + { + // In IE, the "selectionchange" event may still get thrown when + // releasing the WYSIWYG mode, so we need to check it first. + var sel = this.getSelection(); + if ( !sel ) + return; + + var firstElement = sel.getStartElement(); + var currentPath = new CKEDITOR.dom.elementPath( firstElement ); + + if ( !currentPath.compare( this._.selectionPreviousPath ) ) + { + this._.selectionPreviousPath = currentPath; + this.fire( 'selectionChange', { selection : sel, path : currentPath, element : firstElement } ); + } + }; + + var checkSelectionChangeTimer; + var checkSelectionChangeTimeoutPending; + var checkSelectionChangeTimeout = function() + { + // Firing the "OnSelectionChange" event on every key press started to + // be too slow. This function guarantees that there will be at least + // 200ms delay between selection checks. + + checkSelectionChangeTimeoutPending = true; + + if ( checkSelectionChangeTimer ) + return; + + checkSelectionChangeTimeoutExec.call( this ); + + checkSelectionChangeTimer = CKEDITOR.tools.setTimeout( checkSelectionChangeTimeoutExec, 200, this ); + }; + + var checkSelectionChangeTimeoutExec = function() + { + checkSelectionChangeTimer = null; + + if ( checkSelectionChangeTimeoutPending ) + { + // Call this with a timeout so the browser properly moves the + // selection after the mouseup. It happened that the selection was + // being moved after the mouseup when clicking inside selected text + // with Firefox. + CKEDITOR.tools.setTimeout( checkSelectionChange, 0, this ); + + checkSelectionChangeTimeoutPending = false; + } + }; + + // #### checkSelectionChange : END + + var selectAllCmd = + { + exec : function( editor ) + { + switch ( editor.mode ) + { + case 'wysiwyg' : + editor.document.$.execCommand( 'SelectAll', false, null ); + break; + case 'source' : + // TODO + } + } + }; + + CKEDITOR.plugins.add( 'selection', + { + init : function( editor, pluginPath ) + { + editor.on( 'contentDom', function() + { + if ( CKEDITOR.env.ie ) + { + // IE is the only to provide the "selectionchange" + // event. + editor.document.on( 'selectionchange', checkSelectionChangeTimeout, editor ); + } + else + { + // In other browsers, we make the selection change + // check based on other events, like clicks or keys + // press. + + editor.document.on( 'mouseup', checkSelectionChangeTimeout, editor ); + editor.document.on( 'keyup', checkSelectionChangeTimeout, editor ); + } + }); + + editor.addCommand( 'selectAll', selectAllCmd ); + editor.ui.addButton( 'SelectAll', + { + label : editor.lang.selectAll, + command : 'selectAll' + }); + } + }); +})(); + +/** + * Gets the current selection from the editing area when in WYSIWYG mode. + * @returns {CKEDITOR.dom.selection} A selection object or null if not on + * WYSIWYG mode or no selection is available. + * @example + * var selection = CKEDITOR.instances.editor1.getSelection(); + * alert( selection.getType() ); + */ +CKEDITOR.editor.prototype.getSelection = function() +{ + var retval = this.document ? this.document.getSelection() : null; + + /** + * IE BUG: The selection's document may be a different document than the + * editor document. Return null if that's the case. + */ + if ( retval && CKEDITOR.env.ie ) + { + var range = retval.getNative().createRange(); + if ( !range ) + return null; + else if ( range.item ) + return range.item(0).ownerDocument == this.document.$ ? retval : null; + else + return range.parentElement().ownerDocument == this.document.$ ? retval : null; + } + return retval; +}; + +/** + * Gets the current selection from the document. + * @returns {CKEDITOR.dom.selection} A selection object. + * @example + * var selection = CKEDITOR.instances.editor1.document.getSelection(); + * alert( selection.getType() ); + */ +CKEDITOR.dom.document.prototype.getSelection = function() +{ + return new CKEDITOR.dom.selection( this ); +}; + +/** + * No selection. + * @constant + * @example + * if ( editor.getSelection().getType() == CKEDITOR.SELECTION_NONE ) + * alert( 'Nothing is selected' ); + */ +CKEDITOR.SELECTION_NONE = 1; + +/** + * Text or collapsed selection. + * @constant + * @example + * if ( editor.getSelection().getType() == CKEDITOR.SELECTION_TEXT ) + * alert( 'Text is selected' ); + */ +CKEDITOR.SELECTION_TEXT = 2; + +/** + * Element selection. + * @constant + * @example + * if ( editor.getSelection().getType() == CKEDITOR.SELECTION_ELEMENT ) + * alert( 'An element is selected' ); + */ +CKEDITOR.SELECTION_ELEMENT = 3; + +/** + * Manipulates the selection in a DOM document. + * @constructor + * @example + */ +CKEDITOR.dom.selection = function( document ) +{ + this.document = document; + this._ = + { + cache : {} + }; +}; + +(function() +{ + var styleObjectElements = { img:1,hr:1,li:1,table:1,tr:1,td:1,embed:1,object:1,ol:1,ul:1 }; + + CKEDITOR.dom.selection.prototype = + { + /** + * Gets the native selection object from the browser. + * @function + * @returns {Object} The native selection object. + * @example + * var selection = editor.getSelection().getNative(); + */ + getNative : + CKEDITOR.env.ie ? + function() + { + return this._.cache.nativeSel || ( this._.cache.nativeSel = this.document.$.selection ); + } + : + function() + { + return this._.cache.nativeSel || ( this._.cache.nativeSel = this.document.getWindow().$.getSelection() ); + }, + + /** + * Gets the type of the current selection. The following values are + * available: + * + * @function + * @returns {Number} One of the following constant values: + * {@link CKEDITOR.SELECTION_NONE}, {@link CKEDITOR.SELECTION_TEXT} or + * {@link CKEDITOR.SELECTION_ELEMENT}. + * @example + * if ( editor.getSelection().getType() == CKEDITOR.SELECTION_TEXT ) + * alert( 'Text is selected' ); + */ + getType : + CKEDITOR.env.ie ? + function() + { + if ( this._.cache.type ) + return this._.cache.type; + + var type = CKEDITOR.SELECTION_NONE; + + try + { + var sel = this.getNative(), + ieType = sel.type; + + if ( ieType == 'Text' ) + type = CKEDITOR.SELECTION_TEXT; + + if ( ieType == 'Control' ) + type = CKEDITOR.SELECTION_ELEMENT; + + // It is possible that we can still get a text range + // object even when type == 'None' is returned by IE. + // So we'd better check the object returned by + // createRange() rather than by looking at the type. + if ( sel.createRange().parentElement ) + type = CKEDITOR.SELECTION_TEXT; + } + catch(e) {} + + return ( this._.cache.type = type ); + } + : + function() + { + if ( this._.cache.type ) + return this._.cache.type; + + var type = CKEDITOR.SELECTION_TEXT; + + var sel = this.getNative(); + + if ( !sel ) + type = CKEDITOR.SELECTION_NONE; + else if ( sel.rangeCount == 1 ) + { + // Check if the actual selection is a control (IMG, + // TABLE, HR, etc...). + + var range = sel.getRangeAt(0), + startContainer = range.startContainer; + + if ( startContainer == range.endContainer + && startContainer.nodeType == 1 + && ( range.endOffset - range.startOffset ) == 1 + && styleObjectElements[ startContainer.childNodes[ range.startOffset ].nodeName.toLowerCase() ] ) + { + type = CKEDITOR.SELECTION_ELEMENT; + } + } + + return ( this._.cache.type = type ); + }, + + getRanges : + CKEDITOR.env.ie ? + ( function() + { + // Finds the container and offset for a specific boundary + // of an IE range. + var getBoundaryInformation = function( range, start ) + { + // Creates a collapsed range at the requested boundary. + range = range.duplicate(); + range.collapse( start ); + + // Gets the element that encloses the range entirely. + var parent = range.parentElement(); + var siblings = parent.childNodes; + + var testRange; + + for ( var i = 0 ; i < siblings.length ; i++ ) + { + var child = siblings[ i ]; + if ( child.nodeType == 1 ) + { + testRange = range.duplicate(); + + testRange.moveToElementText( child ); + testRange.collapse(); + + var comparison = testRange.compareEndPoints( 'StartToStart', range ); + + if ( comparison > 0 ) + break; + else if ( comparison === 0 ) + return { + container : parent, + offset : i + }; + + testRange = null; + } + } + + if ( !testRange ) + { + testRange = range.duplicate(); + testRange.moveToElementText( parent ); + testRange.collapse( false ); + } + + testRange.setEndPoint( 'StartToStart', range ); + var distance = testRange.text.length; + + while ( distance > 0 ) + distance -= siblings[ --i ].nodeValue.length; + + if ( distance === 0 ) + { + return { + container : parent, + offset : i + }; + } + else + { + return { + container : siblings[ i ], + offset : -distance + }; + } + }; + + return function() + { + if ( this._.cache.ranges ) + return this._.cache.ranges; + + // IE doesn't have range support (in the W3C way), so we + // need to do some magic to transform selections into + // CKEDITOR.dom.range instances. + + var sel = this.getNative(), + nativeRange = sel.createRange(), + type = this.getType(); + + if ( type == CKEDITOR.SELECTION_TEXT ) + { + var range = new CKEDITOR.dom.range( this.document ); + + var boundaryInfo = getBoundaryInformation( nativeRange, true ); + range.setStart( new CKEDITOR.dom.node( boundaryInfo.container ), boundaryInfo.offset ); + + boundaryInfo = getBoundaryInformation( nativeRange ); + range.setEnd( new CKEDITOR.dom.node( boundaryInfo.container ), boundaryInfo.offset ); + + return ( this._.cache.ranges = [ range ] ); + } + else if ( type == CKEDITOR.SELECTION_ELEMENT ) + { + var retval = this._.cache.ranges = []; + + for ( var i = 0 ; i < nativeRange.length ; i++ ) + { + var element = nativeRange.item( i ), + parentElement = element.parentNode, + j = 0, + range = new CKEDITOR.dom.range( this.document ); + for (; j < parentElement.childNodes.length && parentElement.childNodes[j] != element ; j++ ); + + range.setStart( new CKEDITOR.dom.node( parentElement ), j ); + range.setEnd( new CKEDITOR.dom.node( parentElement ), j + 1 ); + retval.push( range ); + } + + return retval; + } + + return ( this._.cache.ranges = [] ); + }; + })() + : + function() + { + if ( this._.cache.ranges ) + return this._.cache.ranges; + + // On browsers implementing the W3C range, we simply + // tranform the native ranges in CKEDITOR.dom.range + // instances. + + var ranges = []; + var sel = this.getNative(); + + for ( var i = 0 ; i < sel.rangeCount ; i++ ) + { + var nativeRange = sel.getRangeAt( i ); + var range = new CKEDITOR.dom.range( this.document ); + + range.setStart( new CKEDITOR.dom.node( nativeRange.startContainer ), nativeRange.startOffset ); + range.setEnd( new CKEDITOR.dom.node( nativeRange.endContainer ), nativeRange.endOffset ); + ranges.push( range ); + } + + return ( this._.cache.ranges = ranges ); + }, + + /** + * Gets the DOM element in which the selection starts. + * @returns {CKEDITOR.dom.element} The element at the beginning of the + * selection. + * @example + * var element = editor.getSelection().getStartElement(); + * alert( element.getName() ); + */ + getStartElement : function() + { + var node, + sel = this.getNative(); + + switch ( this.getType() ) + { + case CKEDITOR.SELECTION_ELEMENT : + return this.getSelectedElement(); + + case CKEDITOR.SELECTION_TEXT : + + var range = this.getRanges()[0]; + + if ( range ) + { + if ( !range.collapsed ) + { + range.optimize(); + + node = range.startContainer; + + if ( node.type != CKEDITOR.NODE_ELEMENT ) + return node.getParent(); + + node = node.getChild( range.startOffset ); + + if ( !node || node.type != CKEDITOR.NODE_ELEMENT ) + return range.startContainer; + + var child = node.getFirst(); + while ( child && child.type == CKEDITOR.NODE_ELEMENT ) + { + node = child; + child = child.getFirst(); + } + + return node; + } + } + + if ( CKEDITOR.env.ie ) + { + var range = sel.createRange(); + range.collapse( true ); + + node = range.parentElement(); + } + else + { + node = sel.anchorNode; + + if ( node.nodeType != 1 ) + node = node.parentNode; + } + } + + return ( node ? new CKEDITOR.dom.element( node ) : null ); + }, + + /** + * Gets the current selected element. + * @returns {CKEDITOR.dom.element} The selected element. Null if no + * selection is available or the selection type is not + * {@link CKEDITOR.SELECTION_ELEMENT}. + * @example + * var element = editor.getSelection().getSelectedElement(); + * alert( element.getName() ); + */ + getSelectedElement : function() + { + var node; + + if ( this.getType() == CKEDITOR.SELECTION_ELEMENT ) + { + var sel = this.getNative(); + + if ( CKEDITOR.env.ie ) + { + try + { + node = sel.createRange().item(0); + } + catch(e) {} + } + else + { + var range = sel.getRangeAt( 0 ); + node = range.startContainer.childNodes[ range.startOffset ]; + } + } + + return ( node ? new CKEDITOR.dom.element( node ) : null ); + }, + + reset : function() + { + this._.cache = {}; + }, + + selectElement : + CKEDITOR.env.ie ? + function( element ) + { + this.getNative().empty(); + + var range; + try + { + // Try to select the node as a control. + range = this.document.$.body.createControlRange(); + range.addElement( element.$ ); + } + catch(e) + { + // If failed, select it as a text range. + range = this.document.$.body.createTextRange(); + range.moveToElementText( element.$ ); + } + + range.select(); + } + : + function( element ) + { + // Create the range for the element. + var range = this.document.$.createRange(); + range.selectNode( element.$ ); + + // Select the range. + var sel = this.getNative(); + sel.removeAllRanges(); + sel.addRange( range ); + }, + + selectRanges : + CKEDITOR.env.ie ? + function( ranges ) + { + // IE doesn't accept multiple ranges selection, so we just + // select the first one. + if ( ranges[ 0 ] ) + ranges[ 0 ].select(); + } + : + function( ranges ) + { + var sel = this.getNative(); + sel.removeAllRanges(); + + for ( var i = 0 ; i < ranges.length ; i++ ) + { + var range = ranges[ i ]; + var nativeRange = this.document.$.createRange(); + nativeRange.setStart( range.startContainer.$, range.startOffset ); + nativeRange.setEnd( range.endContainer.$, range.endOffset ); + + // Select the range. + sel.addRange( nativeRange ); + } + }, + + createBookmarks : function() + { + var retval = [], + ranges = this.getRanges(); + for ( var i = 0 ; i < ranges.length ; i++ ) + retval.push( ranges[i].createBookmark() ); + return retval; + }, + + selectBookmarks : function( bookmarks ) + { + var ranges = []; + for ( var i = 0 ; i < bookmarks.length ; i++ ) + { + var range = new CKEDITOR.dom.range( this.document ); + range.moveToBookmark( bookmarks[i] ); + ranges.push( range ); + } + this.selectRanges( ranges ); + return this; + } + }; +})(); + +CKEDITOR.dom.range.prototype.select = + CKEDITOR.env.ie ? + // V2 + function() + { + var collapsed = this.collapsed; + var isStartMakerAlone; + var dummySpan; + + var bookmark = this.createBookmark(); + + // Create marker tags for the start and end boundaries. + var startNode = bookmark.startNode; + + var endNode; + if ( !collapsed ) + endNode = bookmark.endNode; + + // Create the main range which will be used for the selection. + var ieRange = this.document.$.body.createTextRange(); + + // Position the range at the start boundary. + ieRange.moveToElementText( startNode.$ ); + ieRange.moveStart( 'character', 1 ); + + if ( endNode ) + { + // Create a tool range for the end. + var ieRangeEnd = this.document.$.body.createTextRange(); + + // Position the tool range at the end. + ieRangeEnd.moveToElementText( endNode.$ ); + + // Move the end boundary of the main range to match the tool range. + ieRange.setEndPoint( 'EndToEnd', ieRangeEnd ); + ieRange.moveEnd( 'character', -1 ); + } + else + { + isStartMakerAlone = ( !startNode.hasPrevious() || ( startNode.getPrevious().is && startNode.getPrevious().is( 'br' ) ) ) + && !startNode.hasNext(); + + // Append a temporary  before the selection. + // This is needed to avoid IE destroying selections inside empty + // inline elements, like (#253). + // It is also needed when placing the selection right after an inline + // element to avoid the selection moving inside of it. + dummySpan = this.document.createElement( 'span' ); + dummySpan.setHtml( '' ); // Zero Width No-Break Space (U+FEFF). See #1359. + dummySpan.insertBefore( startNode ); + + if ( isStartMakerAlone ) + { + // To expand empty blocks or line spaces after
, we need + // instead to have any char, which will be later deleted using the + // selection. + // \ufeff = Zero Width No-Break Space (U+FEFF). See #1359. + this.document.createText( '\ufeff' ).insertBefore( startNode ); + } + } + + // Remove the markers (reset the position, because of the changes in the DOM tree). + this.setStartBefore( startNode ); + startNode.remove(); + + if ( collapsed ) + { + if ( isStartMakerAlone ) + { + // Move the selection start to include the temporary . + //ieRange.moveStart( 'character', -1 ); + + ieRange.select(); + + // Remove our temporary stuff. +// this.document.$.selection.clear(); + } + else + ieRange.select(); + + dummySpan.remove(); + } + else + { + this.setEndBefore( endNode ); + endNode.remove(); + ieRange.select(); + } + } + : + function() + { + var startContainer = this.startContainer; + + // If we have a collapsed range, inside an empty element, we must add + // something to it, otherwise the caret will not be visible. + if ( this.collapsed && startContainer.type == CKEDITOR.NODE_ELEMENT && !startContainer.getChildCount() ) + startContainer.append( new CKEDITOR.dom.text( '' ) ); + + var nativeRange = this.document.$.createRange(); + nativeRange.setStart( startContainer.$, this.startOffset ); + + try + { + nativeRange.setEnd( this.endContainer.$, this.endOffset ); + } + catch ( e ) + { + // There is a bug in Firefox implementation (it would be too easy + // otherwise). The new start can't be after the end (W3C says it can). + // So, let's create a new range and collapse it to the desired point. + if ( e.toString().indexOf( 'NS_ERROR_ILLEGAL_VALUE' ) >= 0 ) + { + this.collapse( true ); + nativeRange.setEnd( this.endContainer.$, this.endOffset ); + } + else + throw( e ); + } + + var selection = this.document.getSelection().getNative(); + selection.removeAllRanges(); + selection.addRange( nativeRange ); + }; Index: /CKEditor/trunk/_source/plugins/sourcearea/plugin.js =================================================================== --- /CKEditor/trunk/_source/plugins/sourcearea/plugin.js (revision 2985) +++ /CKEditor/trunk/_source/plugins/sourcearea/plugin.js (revision 2985) @@ -0,0 +1,134 @@ +/* +Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved. +For licensing, see LICENSE.html or http://ckeditor.com/license +*/ + +/** + * @fileOverview The "sourcearea" plugin. It registers the "source" editing + * mode, which displays the raw data being edited in the editor. + */ + +CKEDITOR.plugins.add( 'sourcearea', +{ + requires : [ 'editingblock' ], + + init : function( editor, pluginPath ) + { + var sourcearea = CKEDITOR.plugins.sourcearea; + + editor.on( 'editingBlockReady', function() + { + var textarea; + + editor.addMode( 'source', + { + load : function( holderElement, data ) + { + // Create the source area