ckeditor-rails 0.0.1

data/vendor/assets/ckeditor/_source/plugins/bidi/plugin.js

@@ -0,0 +1,334 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+	var guardElements = { table:1, ul:1, ol:1, blockquote:1, div:1 },
+		directSelectionGuardElements = {},
+		// All guard elements which can have a direction applied on them.
+		allGuardElements = {};
+	CKEDITOR.tools.extend( directSelectionGuardElements, guardElements, { tr:1, p:1, div:1, li:1 } );
+	CKEDITOR.tools.extend( allGuardElements, directSelectionGuardElements, { td:1 } );
+
+	function onSelectionChange( e )
+	{
+		setToolbarStates( e );
+		handleMixedDirContent( e );
+	}
+
+	function setToolbarStates( evt )
+	{
+		var editor = evt.editor,
+			path = evt.data.path;
+
+		if ( editor.readOnly )
+			return;
+
+		var useComputedState = editor.config.useComputedState,
+			selectedElement;
+
+		useComputedState = useComputedState === undefined || useComputedState;
+
+		// We can use computedState provided by the browser or traverse parents manually.
+		if ( !useComputedState )
+			selectedElement = getElementForDirection( path.lastElement );
+
+		selectedElement = selectedElement || path.block || path.blockLimit;
+
+		// If we're having BODY here, user probably done CTRL+A, let's try to get the enclosed node, if any.
+		if ( selectedElement.is( 'body' ) )
+		{
+			var enclosedNode = editor.getSelection().getRanges()[ 0 ].getEnclosedNode();
+			enclosedNode && enclosedNode.type == CKEDITOR.NODE_ELEMENT && ( selectedElement = enclosedNode );
+		}
+
+		if ( !selectedElement  )
+			return;
+
+		var selectionDir = useComputedState ?
+			selectedElement.getComputedStyle( 'direction' ) :
+			selectedElement.getStyle( 'direction' ) || selectedElement.getAttribute( 'dir' );
+
+		editor.getCommand( 'bidirtl' ).setState( selectionDir == 'rtl' ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
+		editor.getCommand( 'bidiltr' ).setState( selectionDir == 'ltr' ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
+	}
+
+	function handleMixedDirContent( evt )
+	{
+		var editor = evt.editor,
+			directionNode = evt.data.path.block || evt.data.path.blockLimit;
+
+		editor.fire( 'contentDirChanged', directionNode ? directionNode.getComputedStyle( 'direction' ) : editor.lang.dir );
+	}
+
+	/**
+	 * Returns element with possibility of applying the direction.
+	 * @param node
+	 */
+	function getElementForDirection( node )
+	{
+		while ( node && !( node.getName() in allGuardElements || node.is( 'body' ) ) )
+		{
+			var parent = node.getParent();
+			if ( !parent )
+				break;
+
+			node = parent;
+		}
+
+		return node;
+	}
+
+	function switchDir( element, dir, editor, database )
+	{
+		if ( element.isReadOnly() )
+			return;
+
+		// Mark this element as processed by switchDir.
+		CKEDITOR.dom.element.setMarker( database, element, 'bidi_processed', 1 );
+
+		// Check whether one of the ancestors has already been styled.
+		var parent = element;
+		while ( ( parent = parent.getParent() ) && !parent.is( 'body' ) )
+		{
+			if ( parent.getCustomData( 'bidi_processed' ) )
+			{
+				// Ancestor style must dominate.
+				element.removeStyle( 'direction' );
+				element.removeAttribute( 'dir' );
+				return;
+			}
+		}
+
+		var useComputedState = ( 'useComputedState' in editor.config ) ? editor.config.useComputedState : 1;
+
+		var elementDir = useComputedState ? element.getComputedStyle( 'direction' )
+			: element.getStyle( 'direction' ) || element.hasAttribute( 'dir' );
+
+		// Stop if direction is same as present.
+		if ( elementDir == dir )
+			return;
+
+		// Clear direction on this element.
+		element.removeStyle( 'direction' );
+
+		// Do the second check when computed state is ON, to check
+		// if we need to apply explicit direction on this element.
+		if ( useComputedState )
+		{
+			element.removeAttribute( 'dir' );
+			if ( dir != element.getComputedStyle( 'direction' ) )
+				element.setAttribute( 'dir', dir );
+		}
+		else
+			// Set new direction for this element.
+			element.setAttribute( 'dir', dir );
+
+		editor.forceNextSelectionCheck();
+
+		return;
+	}
+
+	function getFullySelected( range, elements, enterMode )
+	{
+		var ancestor = range.getCommonAncestor( false, true );
+
+		range = range.clone();
+		range.enlarge( enterMode == CKEDITOR.ENTER_BR ?
+				CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS
+				: CKEDITOR.ENLARGE_BLOCK_CONTENTS );
+
+		if ( range.checkBoundaryOfElement( ancestor, CKEDITOR.START )
+				&& range.checkBoundaryOfElement( ancestor, CKEDITOR.END ) )
+		{
+			var parent;
+			while ( ancestor && ancestor.type == CKEDITOR.NODE_ELEMENT
+					&& ( parent = ancestor.getParent() )
+					&& parent.getChildCount() == 1
+					&& !( ancestor.getName() in elements ) )
+				ancestor = parent;
+
+			return ancestor.type == CKEDITOR.NODE_ELEMENT
+					&& ( ancestor.getName() in elements )
+					&& ancestor;
+		}
+	}
+
+	function bidiCommand( dir )
+	{
+		return function( editor )
+		{
+			var selection = editor.getSelection(),
+				enterMode = editor.config.enterMode,
+				ranges = selection.getRanges();
+
+			if ( ranges && ranges.length )
+			{
+				var database = {};
+
+				// Creates bookmarks for selection, as we may split some blocks.
+				var bookmarks = selection.createBookmarks();
+
+				var rangeIterator = ranges.createIterator(),
+					range,
+					i = 0;
+
+				while ( ( range = rangeIterator.getNextRange( 1 ) ) )
+				{
+					// Apply do directly selected elements from guardElements.
+					var selectedElement = range.getEnclosedNode();
+
+					// If this is not our element of interest, apply to fully selected elements from guardElements.
+					if ( !selectedElement || selectedElement
+							&& !( selectedElement.type == CKEDITOR.NODE_ELEMENT && selectedElement.getName() in directSelectionGuardElements )
+						)
+						selectedElement = getFullySelected( range, guardElements, enterMode );
+
+					selectedElement && switchDir( selectedElement, dir, editor, database );
+
+					var iterator,
+						block;
+
+					// Walker searching for guardElements.
+					var walker = new CKEDITOR.dom.walker( range );
+
+					var start = bookmarks[ i ].startNode,
+						end = bookmarks[ i++ ].endNode;
+
+					walker.evaluator = function( node )
+					{
+						return !! ( node.type == CKEDITOR.NODE_ELEMENT
+								&& node.getName() in guardElements
+								&& !( node.getName() == ( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' )
+									&& node.getParent().type == CKEDITOR.NODE_ELEMENT
+									&& node.getParent().getName() == 'blockquote' )
+								// Element must be fully included in the range as well. (#6485).
+								&& node.getPosition( start ) & CKEDITOR.POSITION_FOLLOWING
+								&& ( ( node.getPosition( end ) & CKEDITOR.POSITION_PRECEDING + CKEDITOR.POSITION_CONTAINS ) == CKEDITOR.POSITION_PRECEDING ) );
+					};
+
+					while ( ( block = walker.next() ) )
+						switchDir( block, dir, editor, database );
+
+					iterator = range.createIterator();
+					iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
+
+					while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) )
+						switchDir( block, dir, editor, database );
+					}
+
+				CKEDITOR.dom.element.clearAllMarkers( database );
+
+				editor.forceNextSelectionCheck();
+				// Restore selection position.
+				selection.selectBookmarks( bookmarks );
+
+				editor.focus();
+			}
+		};
+	}
+
+	CKEDITOR.plugins.add( 'bidi',
+	{
+		requires : [ 'styles', 'button' ],
+
+		init : function( editor )
+		{
+			// All buttons use the same code to register. So, to avoid
+			// duplications, let's use this tool function.
+			var addButtonCommand = function( buttonName, buttonLabel, commandName, commandExec )
+			{
+				editor.addCommand( commandName, new CKEDITOR.command( editor, { exec : commandExec }) );
+
+				editor.ui.addButton( buttonName,
+					{
+						label : buttonLabel,
+						command : commandName
+					});
+			};
+
+			var lang = editor.lang.bidi;
+
+			addButtonCommand( 'BidiLtr', lang.ltr, 'bidiltr', bidiCommand( 'ltr' ) );
+			addButtonCommand( 'BidiRtl', lang.rtl, 'bidirtl', bidiCommand( 'rtl' ) );
+
+			editor.on( 'selectionChange', onSelectionChange );
+			editor.on( 'contentDom', function()
+			{
+				editor.document.on( 'dirChanged', function( evt )
+				{
+					editor.fire( 'dirChanged',
+						{
+							node : evt.data,
+							dir : evt.data.getDirection( 1 )
+						} );
+				});
+			});
+		}
+	});
+
+	// If the element direction changed, we need to switch the margins of
+	// the element and all its children, so it will get really reflected
+	// like a mirror. (#5910)
+	function isOffline( el )
+	{
+		var html = el.getDocument().getBody().getParent();
+		while ( el )
+		{
+			if ( el.equals( html ) )
+				return false;
+			el = el.getParent();
+		}
+		return true;
+	}
+	function dirChangeNotifier( org )
+	{
+		var isAttribute = org == elementProto.setAttribute,
+			isRemoveAttribute = org == elementProto.removeAttribute,
+			dirStyleRegexp = /\bdirection\s*:\s*(.*?)\s*(:?$|;)/;
+
+		return function( name, val )
+		{
+			if ( !this.getDocument().equals( CKEDITOR.document ) )
+			{
+				var orgDir;
+				if ( ( name == ( isAttribute || isRemoveAttribute ? 'dir' : 'direction' ) ||
+					 name == 'style' && ( isRemoveAttribute || dirStyleRegexp.test( val ) ) ) && !isOffline( this ) )
+				{
+					orgDir = this.getDirection( 1 );
+					var retval = org.apply( this, arguments );
+					if ( orgDir != this.getDirection( 1 ) )
+					{
+						this.getDocument().fire( 'dirChanged', this );
+						return retval;
+					}
+				}
+			}
+
+			return org.apply( this, arguments );
+		};
+	}
+
+	var elementProto = CKEDITOR.dom.element.prototype,
+		methods = [ 'setStyle', 'removeStyle', 'setAttribute', 'removeAttribute' ];
+	for ( var i = 0; i < methods.length; i++ )
+		elementProto[ methods[ i ] ] = CKEDITOR.tools.override( elementProto[ methods [ i ] ], dirChangeNotifier );
+})();
+
+/**
+ * Fired when the language direction of an element is changed
+ * @name CKEDITOR.editor#dirChanged
+ * @event
+ * @param {CKEDITOR.editor} editor This editor instance.
+ * @param {Object} eventData.node The element that is being changed.
+ * @param {String} eventData.dir The new direction.
+ */
+
+/**
+ * Fired when the language direction in the specific cursor position is changed
+ * @name CKEDITOR.editor#contentDirChanged
+ * @event
+ * @param {String} eventData The direction in the current position.
+ */

data/vendor/assets/ckeditor/_source/plugins/blockquote/plugin.js

@@ -0,0 +1,305 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Blockquote.
+ */
+
+(function()
+{
+	function getState( editor, path )
+	{
+		var firstBlock = path.block || path.blockLimit;
+
+		if ( !firstBlock || firstBlock.getName() == 'body' )
+			return CKEDITOR.TRISTATE_OFF;
+
+		// See if the first block has a blockquote parent.
+		if ( firstBlock.getAscendant( 'blockquote', true ) )
+			return CKEDITOR.TRISTATE_ON;
+
+		return CKEDITOR.TRISTATE_OFF;
+	}
+
+	function onSelectionChange( evt )
+	{
+		var editor = evt.editor;
+		if ( editor.readOnly )
+			return;
+
+		var command = editor.getCommand( 'blockquote' );
+		command.state = getState( editor, evt.data.path );
+		command.fire( 'state' );
+	}
+
+	function noBlockLeft( bqBlock )
+	{
+		for ( var i = 0, length = bqBlock.getChildCount(), child ; i < length && ( child = bqBlock.getChild( i ) ) ; i++ )
+		{
+			if ( child.type == CKEDITOR.NODE_ELEMENT && child.isBlockBoundary() )
+				return false;
+		}
+		return true;
+	}
+
+	var commandObject =
+	{
+		exec : function( editor )
+		{
+			var state = editor.getCommand( 'blockquote' ).state,
+				selection = editor.getSelection(),
+				range = selection && selection.getRanges( true )[0];
+
+			if ( !range )
+				return;
+
+			var bookmarks = selection.createBookmarks();
+
+			// Kludge for #1592: if the bookmark nodes are in the beginning of
+			// blockquote, then move them to the nearest block element in the
+			// blockquote.
+			if ( CKEDITOR.env.ie )
+			{
+				var bookmarkStart = bookmarks[0].startNode,
+					bookmarkEnd = bookmarks[0].endNode,
+					cursor;
+
+				if ( bookmarkStart && bookmarkStart.getParent().getName() == 'blockquote' )
+				{
+					cursor = bookmarkStart;
+					while ( ( cursor = cursor.getNext() ) )
+					{
+						if ( cursor.type == CKEDITOR.NODE_ELEMENT &&
+								cursor.isBlockBoundary() )
+						{
+							bookmarkStart.move( cursor, true );
+							break;
+						}
+					}
+				}
+
+				if ( bookmarkEnd
+						&& bookmarkEnd.getParent().getName() == 'blockquote' )
+				{
+					cursor = bookmarkEnd;
+					while ( ( cursor = cursor.getPrevious() ) )
+					{
+						if ( cursor.type == CKEDITOR.NODE_ELEMENT &&
+								cursor.isBlockBoundary() )
+						{
+							bookmarkEnd.move( cursor );
+							break;
+						}
+					}
+				}
+			}
+
+			var iterator = range.createIterator(),
+				block;
+			iterator.enlargeBr = editor.config.enterMode != CKEDITOR.ENTER_BR;
+
+			if ( state == CKEDITOR.TRISTATE_OFF )
+			{
+				var paragraphs = [];
+				while ( ( block = iterator.getNextParagraph() ) )
+					paragraphs.push( block );
+
+				// If no paragraphs, create one from the current selection position.
+				if ( paragraphs.length < 1 )
+				{
+					var para = editor.document.createElement( editor.config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ),
+						firstBookmark = bookmarks.shift();
+					range.insertNode( para );
+					para.append( new CKEDITOR.dom.text( '\ufeff', editor.document ) );
+					range.moveToBookmark( firstBookmark );
+					range.selectNodeContents( para );
+					range.collapse( true );
+					firstBookmark = range.createBookmark();
+					paragraphs.push( para );
+					bookmarks.unshift( firstBookmark );
+				}
+
+				// Make sure all paragraphs have the same parent.
+				var commonParent = paragraphs[0].getParent(),
+					tmp = [];
+				for ( var i = 0 ; i < paragraphs.length ; i++ )
+				{
+					block = paragraphs[i];
+					commonParent = commonParent.getCommonAncestor( block.getParent() );
+				}
+
+				// The common parent must not be the following tags: table, tbody, tr, ol, ul.
+				var denyTags = { table : 1, tbody : 1, tr : 1, ol : 1, ul : 1 };
+				while ( denyTags[ commonParent.getName() ] )
+					commonParent = commonParent.getParent();
+
+				// Reconstruct the block list to be processed such that all resulting blocks
+				// satisfy parentNode.equals( commonParent ).
+				var lastBlock = null;
+				while ( paragraphs.length > 0 )
+				{
+					block = paragraphs.shift();
+					while ( !block.getParent().equals( commonParent ) )
+						block = block.getParent();
+					if ( !block.equals( lastBlock ) )
+						tmp.push( block );
+					lastBlock = block;
+				}
+
+				// If any of the selected blocks is a blockquote, remove it to prevent
+				// nested blockquotes.
+				while ( tmp.length > 0 )
+				{
+					block = tmp.shift();
+					if ( block.getName() == 'blockquote' )
+					{
+						var docFrag = new CKEDITOR.dom.documentFragment( editor.document );
+						while ( block.getFirst() )
+						{
+							docFrag.append( block.getFirst().remove() );
+							paragraphs.push( docFrag.getLast() );
+						}
+
+						docFrag.replace( block );
+					}
+					else
+						paragraphs.push( block );
+				}
+
+				// Now we have all the blocks to be included in a new blockquote node.
+				var bqBlock = editor.document.createElement( 'blockquote' );
+				bqBlock.insertBefore( paragraphs[0] );
+				while ( paragraphs.length > 0 )
+				{
+					block = paragraphs.shift();
+					bqBlock.append( block );
+				}
+			}
+			else if ( state == CKEDITOR.TRISTATE_ON )
+			{
+				var moveOutNodes = [],
+					database = {};
+
+				while ( ( block = iterator.getNextParagraph() ) )
+				{
+					var bqParent = null,
+						bqChild = null;
+					while ( block.getParent() )
+					{
+						if ( block.getParent().getName() == 'blockquote' )
+						{
+							bqParent = block.getParent();
+							bqChild = block;
+							break;
+						}
+						block = block.getParent();
+					}
+
+					// Remember the blocks that were recorded down in the moveOutNodes array
+					// to prevent duplicates.
+					if ( bqParent && bqChild && !bqChild.getCustomData( 'blockquote_moveout' ) )
+					{
+						moveOutNodes.push( bqChild );
+						CKEDITOR.dom.element.setMarker( database, bqChild, 'blockquote_moveout', true );
+					}
+				}
+
+				CKEDITOR.dom.element.clearAllMarkers( database );
+
+				var movedNodes = [],
+					processedBlockquoteBlocks = [];
+
+				database = {};
+				while ( moveOutNodes.length > 0 )
+				{
+					var node = moveOutNodes.shift();
+					bqBlock = node.getParent();
+
+					// If the node is located at the beginning or the end, just take it out
+					// without splitting. Otherwise, split the blockquote node and move the
+					// paragraph in between the two blockquote nodes.
+					if ( !node.getPrevious() )
+						node.remove().insertBefore( bqBlock );
+					else if ( !node.getNext() )
+						node.remove().insertAfter( bqBlock );
+					else
+					{
+						node.breakParent( node.getParent() );
+						processedBlockquoteBlocks.push( node.getNext() );
+					}
+
+					// Remember the blockquote node so we can clear it later (if it becomes empty).
+					if ( !bqBlock.getCustomData( 'blockquote_processed' ) )
+					{
+						processedBlockquoteBlocks.push( bqBlock );
+						CKEDITOR.dom.element.setMarker( database, bqBlock, 'blockquote_processed', true );
+					}
+
+					movedNodes.push( node );
+				}
+
+				CKEDITOR.dom.element.clearAllMarkers( database );
+
+				// Clear blockquote nodes that have become empty.
+				for ( i = processedBlockquoteBlocks.length - 1 ; i >= 0 ; i-- )
+				{
+					bqBlock = processedBlockquoteBlocks[i];
+					if ( noBlockLeft( bqBlock ) )
+						bqBlock.remove();
+				}
+
+				if ( editor.config.enterMode == CKEDITOR.ENTER_BR )
+				{
+					var firstTime = true;
+					while ( movedNodes.length )
+					{
+						node = movedNodes.shift();
+
+						if ( node.getName() == 'div' )
+						{
+							docFrag = new CKEDITOR.dom.documentFragment( editor.document );
+							var needBeginBr = firstTime && node.getPrevious() &&
+									!( node.getPrevious().type == CKEDITOR.NODE_ELEMENT && node.getPrevious().isBlockBoundary() );
+							if ( needBeginBr )
+								docFrag.append( editor.document.createElement( 'br' ) );
+
+							var needEndBr = node.getNext() &&
+								!( node.getNext().type == CKEDITOR.NODE_ELEMENT && node.getNext().isBlockBoundary() );
+							while ( node.getFirst() )
+								node.getFirst().remove().appendTo( docFrag );
+
+							if ( needEndBr )
+								docFrag.append( editor.document.createElement( 'br' ) );
+
+							docFrag.replace( node );
+							firstTime = false;
+						}
+					}
+				}
+			}
+
+			selection.selectBookmarks( bookmarks );
+			editor.focus();
+		}
+	};
+
+	CKEDITOR.plugins.add( 'blockquote',
+	{
+		init : function( editor )
+		{
+			editor.addCommand( 'blockquote', commandObject );
+
+			editor.ui.addButton( 'Blockquote',
+				{
+					label : editor.lang.blockquote,
+					command : 'blockquote'
+				} );
+
+			editor.on( 'selectionChange', onSelectionChange );
+		},
+
+		requires : [ 'domiterator' ]
+	} );
+})();