ckeditor 3.2.1

data/lib/generators/templates/ckeditor/_source/plugins/justify/plugin.js

@@ -0,0 +1,168 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Justify commands.
+ */
+
+(function()
+{
+	var alignRemoveRegex = /(-moz-|-webkit-|start|auto)/i;
+
+	function getState( editor, path )
+	{
+		var firstBlock = path.block || path.blockLimit;
+
+		if ( !firstBlock || firstBlock.getName() == 'body' )
+			return CKEDITOR.TRISTATE_OFF;
+
+		var currentAlign = firstBlock.getComputedStyle( 'text-align' ).replace( alignRemoveRegex, '' );
+		if ( ( !currentAlign && this.isDefaultAlign ) || currentAlign == this.value )
+			return CKEDITOR.TRISTATE_ON;
+		return CKEDITOR.TRISTATE_OFF;
+	}
+
+	function onSelectionChange( evt )
+	{
+		var command = evt.editor.getCommand( this.name );
+		command.state = getState.call( this, evt.editor, evt.data.path );
+		command.fire( 'state' );
+	}
+
+	function justifyCommand( editor, name, value )
+	{
+		this.name = name;
+		this.value = value;
+
+		var contentDir = editor.config.contentsLangDirection;
+		this.isDefaultAlign = ( value == 'left' && contentDir == 'ltr' ) ||
+			( value == 'right' && contentDir == 'rtl' );
+
+		var classes = editor.config.justifyClasses;
+		if ( classes )
+		{
+			switch ( value )
+			{
+				case 'left' :
+					this.cssClassName = classes[0];
+					break;
+				case 'center' :
+					this.cssClassName = classes[1];
+					break;
+				case 'right' :
+					this.cssClassName = classes[2];
+					break;
+				case 'justify' :
+					this.cssClassName = classes[3];
+					break;
+			}
+
+			this.cssClassRegex = new RegExp( '(?:^|\\s+)(?:' + classes.join( '|' ) + ')(?=$|\\s)' );
+		}
+	}
+
+	justifyCommand.prototype = {
+		exec : function( editor )
+		{
+			var selection = editor.getSelection(),
+				enterMode = editor.config.enterMode;
+
+			if ( !selection )
+				return;
+
+			var bookmarks = selection.createBookmarks(),
+				ranges = selection.getRanges();
+
+
+			var cssClassName = this.cssClassName,
+				iterator,
+				block;
+			for ( var i = ranges.length - 1 ; i >= 0 ; i-- )
+			{
+				iterator = ranges[ i ].createIterator();
+				iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
+
+				while ( ( block = iterator.getNextParagraph() ) )
+				{
+					block.removeAttribute( 'align' );
+
+					if ( cssClassName )
+					{
+						// Remove any of the alignment classes from the className.
+						var className = block.$.className =
+							CKEDITOR.tools.ltrim( block.$.className.replace( this.cssClassRegex, '' ) );
+
+						// Append the desired class name.
+						if ( this.state == CKEDITOR.TRISTATE_OFF && !this.isDefaultAlign )
+							block.addClass( cssClassName );
+						else if ( !className )
+							block.removeAttribute( 'class' );
+					}
+					else
+					{
+						if ( this.state == CKEDITOR.TRISTATE_OFF && !this.isDefaultAlign )
+							block.setStyle( 'text-align', this.value );
+						else
+							block.removeStyle( 'text-align' );
+					}
+				}
+
+			}
+
+			editor.focus();
+			editor.forceNextSelectionCheck();
+			selection.selectBookmarks( bookmarks );
+		}
+	};
+
+	CKEDITOR.plugins.add( 'justify',
+	{
+		init : function( editor )
+		{
+			var left = new justifyCommand( editor, 'justifyleft', 'left' ),
+				center = new justifyCommand( editor, 'justifycenter', 'center' ),
+				right = new justifyCommand( editor, 'justifyright', 'right' ),
+				justify = new justifyCommand( editor, 'justifyblock', 'justify' );
+
+			editor.addCommand( 'justifyleft', left );
+			editor.addCommand( 'justifycenter', center );
+			editor.addCommand( 'justifyright', right );
+			editor.addCommand( 'justifyblock', justify );
+
+			editor.ui.addButton( 'JustifyLeft',
+				{
+					label : editor.lang.justify.left,
+					command : 'justifyleft'
+				} );
+			editor.ui.addButton( 'JustifyCenter',
+				{
+					label : editor.lang.justify.center,
+					command : 'justifycenter'
+				} );
+			editor.ui.addButton( 'JustifyRight',
+				{
+					label : editor.lang.justify.right,
+					command : 'justifyright'
+				} );
+			editor.ui.addButton( 'JustifyBlock',
+				{
+					label : editor.lang.justify.block,
+					command : 'justifyblock'
+				} );
+
+			editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, left ) );
+			editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, right ) );
+			editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, center ) );
+			editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, justify ) );
+		},
+
+		requires : [ 'domiterator' ]
+	});
+})();
+
+CKEDITOR.tools.extend( CKEDITOR.config,
+	{
+		justifyClasses : null
+	} );

data/lib/generators/templates/ckeditor/_source/plugins/keystrokes/plugin.js

@@ -0,0 +1,229 @@
+/*
+Copyright (c) 2003-2010, 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 );
+
+		editor.specialKeys = {};
+	},
+
+	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 cancel;
+
+	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 editor = this._.editor;
+
+		cancel = ( editor.fire( 'key', { keyCode : keyCombination } ) === true );
+
+		if ( !cancel )
+		{
+			if ( command )
+			{
+				var data = { from : 'keystrokeHandler' };
+				cancel = ( editor.execCommand( command, data ) !== false );
+			}
+
+			if  ( !cancel )
+			{
+				var handler = editor.specialKeys[ keyCombination ];
+				cancel = ( handler && handler( editor ) === true );
+
+				if ( !cancel )
+					cancel = !!this.blockedKeystrokes[ keyCombination ];
+			}
+		}
+
+		if ( cancel )
+			event.preventDefault( true );
+
+		return !cancel;
+	};
+
+	var onKeyPress = function( event )
+	{
+		if ( cancel )
+		{
+			cancel = false;
+			event.data.preventDefault( true );
+		}
+	};
+
+	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 )
+		{
+			// For most browsers, it is enough to listen to the keydown event
+			// only.
+			domObject.on( 'keydown', onKeyDown, this );
+
+			// Some browsers instead, don't cancel key events in the keydown, but in the
+			// keypress. So we must do a longer trip in those cases.
+			if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+				domObject.on( 'keypress', onKeyPress, this );
+		}
+	};
+})();
+
+/**
+ * A list of keystrokes to be blocked if not defined in the {@link CKEDITOR.config.keystrokes}
+ * setting. In this way it is possible to block the default browser behavior
+ * for those keystrokes.
+ * @type Array
+ * @default (see example)
+ * @example
+ * // This is actually the default value.
+ * config.blockedKeystrokes =
+ * [
+ *     CKEDITOR.CTRL + 66 &#47;*B*&#47;,
+ *     CKEDITOR.CTRL + 73 &#47;*I*&#47;,
+ *     CKEDITOR.CTRL + 85 &#47;*U*&#47;
+ * ];
+ */
+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
+ * name of the command to be executed.
+ * @type Array
+ * @default (see example)
+ * @example
+ * // This is actually the default value.
+ * config.keystrokes =
+ * [
+ *     [ CKEDITOR.ALT + 121 &#47;*F10*&#47;, 'toolbarFocus' ],
+ *     [ CKEDITOR.ALT + 122 &#47;*F11*&#47;, 'elementsPathFocus' ],
+ *
+ *     [ CKEDITOR.SHIFT + 121 &#47;*F10*&#47;, 'contextMenu' ],
+ *
+ *     [ CKEDITOR.CTRL + 90 &#47;*Z*&#47;, 'undo' ],
+ *     [ CKEDITOR.CTRL + 89 &#47;*Y*&#47;, 'redo' ],
+ *     [ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 &#47;*Z*&#47;, 'redo' ],
+ *
+ *     [ CKEDITOR.CTRL + 76 &#47;*L*&#47;, 'link' ],
+ *
+ *     [ CKEDITOR.CTRL + 66 &#47;*B*&#47;, 'bold' ],
+ *     [ CKEDITOR.CTRL + 73 &#47;*I*&#47;, 'italic' ],
+ *     [ CKEDITOR.CTRL + 85 &#47;*U*&#47;, 'underline' ],
+ *
+ *     [ CKEDITOR.ALT + 109 &#47;*-*&#47;, 'toolbarCollapse' ]
+ * ];
+ */
+CKEDITOR.config.keystrokes =
+[
+	[ CKEDITOR.ALT + 121 /*F10*/, 'toolbarFocus' ],
+	[ CKEDITOR.ALT + 122 /*F11*/, 'elementsPathFocus' ],
+
+	[ CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
+	[ CKEDITOR.CTRL + CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
+
+	[ 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.ALT + 109 /*-*/, 'toolbarCollapse' ],
+	[ CKEDITOR.ALT + 48 /*0*/, 'a11yHelp' ]
+];
+
+/**
+ * Fired when any keyboard key (or combination) is pressed into the editing area.
+ * @name CKEDITOR#key
+ * @event
+ * @param {Number} data.keyCode A number representing the key code (or
+ *		combination). It is the sum of the current key code and the
+ *		{@link CKEDITOR.CTRL}, {@link CKEDITOR.SHIFT} and {@link CKEDITOR.ALT}
+ *		constants, if those are pressed.
+ */

data/lib/generators/templates/ckeditor/_source/plugins/link/dialogs/anchor.js

@@ -0,0 +1,99 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.dialog.add( 'anchor', function( editor )
+{
+	// Function called in onShow to load selected element.
+	var loadElements = function( editor, selection, element )
+	{
+		this.editMode = true;
+		this.editObj = element;
+
+		var attributeValue = this.editObj.getAttribute( 'name' );
+		if ( attributeValue )
+			this.setValueOf( 'info','txtName', attributeValue );
+		else
+			this.setValueOf( 'info','txtName', "" );
+	};
+
+	return {
+		title : editor.lang.anchor.title,
+		minWidth : 300,
+		minHeight : 60,
+		onOk : function()
+		{
+			// Always create a new anchor, because of IE BUG.
+			var name = this.getValueOf( 'info', 'txtName' ),
+				element = CKEDITOR.env.ie ?
+				editor.document.createElement( '<a name="' + CKEDITOR.tools.htmlEncode( name ) + '">' ) :
+				editor.document.createElement( 'a' );
+
+			// Move contents and attributes of old anchor to new anchor.
+			if ( this.editMode )
+			{
+				this.editObj.copyAttributes( element, { name : 1 } );
+				this.editObj.moveChildren( element );
+			}
+
+			// Set name.
+			element.removeAttribute( '_cke_saved_name' );
+			element.setAttribute( 'name', name );
+
+			// Insert a new anchor.
+			var fakeElement = editor.createFakeElement( element, 'cke_anchor', 'anchor' );
+			if ( !this.editMode )
+				editor.insertElement( fakeElement );
+			else
+			{
+				fakeElement.replace( this.fakeObj );
+				editor.getSelection().selectElement( fakeElement );
+			}
+
+			return true;
+		},
+		onShow : function()
+		{
+			this.editObj = false;
+			this.fakeObj = false;
+			this.editMode = false;
+
+			var selection = editor.getSelection();
+			var element = selection.getSelectedElement();
+			if ( element && element.getAttribute( '_cke_real_element_type' ) && element.getAttribute( '_cke_real_element_type' ) == 'anchor' )
+			{
+				this.fakeObj = element;
+				element = editor.restoreRealElement( this.fakeObj );
+				loadElements.apply( this, [ editor, selection, element ] );
+				selection.selectElement( this.fakeObj );
+			}
+			this.getContentElement( 'info', 'txtName' ).focus();
+		},
+		contents : [
+			{
+				id : 'info',
+				label : editor.lang.anchor.title,
+				accessKey : 'I',
+				elements :
+				[
+					{
+						type : 'text',
+						id : 'txtName',
+						label : editor.lang.anchor.name,
+						required: true,
+						validate : function()
+						{
+							if ( !this.getValue() )
+							{
+								alert( editor.lang.anchor.errorName );
+								return false;
+							}
+							return true;
+						}
+					}
+				]
+			}
+		]
+	};
+} );