inline_forms 0.9.17 → 0.9.18

data/public/javascripts/ckeditor/_source/plugins/elementspath/plugin.js

@@ -0,0 +1,218 @@
+/*
+Copyright (c) 2003-2011, 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 :
+		{
+			editorFocus : false,
+			readOnly : 1,
+			exec : function( editor )
+			{
+				var idBase = editor._.elementsPath.idBase;
+				var element = CKEDITOR.document.getById( idBase + '0' );
+
+				// Make the first button focus accessible for IE. (#3417)
+				// Adobe AIR instead need while of delay.
+				element && element.focus( CKEDITOR.env.ie || CKEDITOR.env.air );
+			}
+		}
+	};
+
+	var emptyHtml = '<span class="cke_empty">&nbsp;</span>';
+
+	CKEDITOR.plugins.add( 'elementspath',
+	{
+		requires : [ 'selection' ],
+
+		init : function( editor )
+		{
+			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, filters : [] };
+
+			editor.on( 'themeSpace', function( event )
+				{
+					if ( event.data.space == 'bottom' )
+					{
+						event.data.html +=
+							'<span id="' + spaceId + '_label" class="cke_voice_label">' + editor.lang.elementsPath.eleLabel + '</span>' +
+							'<div id="' + spaceId + '" class="cke_path" role="group" aria-labelledby="' + spaceId + '_label">' + emptyHtml + '</div>';
+					}
+				});
+
+			function onClick( elementIndex )
+			{
+				editor.focus();
+				var element = editor._.elementsPath.list[ elementIndex ];
+				if ( element.is( 'body' ) )
+				{
+					var range = new CKEDITOR.dom.range( editor.document );
+					range.selectNodeContents( element );
+					range.select();
+				}
+				else
+					editor.getSelection().selectElement( element );
+			}
+
+			var onClickHanlder = CKEDITOR.tools.addFunction( onClick );
+
+			var onKeyDownHandler = CKEDITOR.tools.addFunction( function( elementIndex, ev )
+				{
+					var idBase = editor._.elementsPath.idBase,
+						element;
+
+					ev = new CKEDITOR.dom.event( ev );
+
+					var rtl = editor.lang.dir == 'rtl';
+					switch ( ev.getKeystroke() )
+					{
+						case rtl ? 39 : 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 rtl ? 37 : 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
+							onClick( elementIndex );
+							return false;
+					}
+					return true;
+				});
+
+			editor.on( 'selectionChange', function( ev )
+				{
+					var env = CKEDITOR.env,
+						selection = ev.data.selection,
+						element = selection.getStartElement(),
+						html = [],
+						editor = ev.editor,
+						elementsList = editor._.elementsPath.list = [],
+						filters = editor._.elementsPath.filters;
+
+					while ( element )
+					{
+						var ignore = 0,
+							name;
+
+						if ( element.data( 'cke-display-name' ) )
+							name = element.data( 'cke-display-name' );
+						else if ( element.data( 'cke-real-element-type' ) )
+							name = element.data( 'cke-real-element-type' );
+						else
+							name = element.getName();
+
+						for ( var i = 0; i < filters.length; i++ )
+						{
+							var ret = filters[ i ]( element, name );
+							if ( ret === false )
+							{
+								ignore = 1;
+								break;
+							}
+							name = ret || name;
+						}
+
+						if ( !ignore )
+						{
+							var index = elementsList.push( element ) - 1;
+
+							// 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;"';
+
+							var label = editor.lang.elementsPath.eleTitle.replace( /%1/, name );
+							html.unshift(
+								'<a' +
+									' id="', idBase, index, '"' +
+									' href="javascript:void(\'', name, '\')"' +
+									' tabindex="-1"' +
+									' title="', label, '"' +
+									( ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 ) ?
+									' onfocus="event.preventBubble();"' : '' ) +
+									' hidefocus="true" ' +
+									' onkeydown="return CKEDITOR.tools.callFunction(', onKeyDownHandler, ',', index, ', event );"' +
+									extra ,
+									' onclick="CKEDITOR.tools.callFunction('+ onClickHanlder, ',', index, '); return false;"',
+									' role="button" aria-labelledby="' + idBase + index + '_label">',
+										name,
+										'<span id="', idBase, index, '_label" class="cke_label">' + label + '</span>',
+								'</a>' );
+
+						}
+
+						if ( name == 'body' )
+							break;
+
+						element = element.getParent();
+					}
+
+					var space = getSpaceElement();
+					space.setHtml( html.join('') + emptyHtml );
+					editor.fire( 'elementsPathUpdate', { space : space } );
+				});
+
+			function empty()
+			{
+				spaceElement && spaceElement.setHtml( emptyHtml );
+				delete editor._.elementsPath.list;
+			}
+
+			editor.on( 'readOnly', empty );
+			editor.on( 'contentDomUnload', empty );
+
+			editor.addCommand( 'elementsPathFocus', commands.toolbarFocus );
+		}
+	});
+})();
+
+/**
+ * Fired when the contents of the elementsPath are changed
+ * @name CKEDITOR.editor#elementsPathUpdate
+ * @event
+ * @param {Object} eventData.space The elementsPath container
+ */

data/public/javascripts/ckeditor/_source/plugins/embed/dialogs/embed.js

@@ -0,0 +1,65 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+	CKEDITOR.dialog.add( 'embed', function( editor )
+		{
+			return {
+				title : editor.lang.embed.title,
+        
+				minWidth : CKEDITOR.env.ie && CKEDITOR.env.quirks ? 368 : 350,
+				minHeight : 240,
+
+				onShow : function()
+				{
+					// Reset the textarea value.
+					this.getContentElement( 'general', 'content' ).getInputElement().setValue( '' );
+				},
+
+				onOk : function()
+				{
+					// Get the textarea value.
+					var text = this.getContentElement( 'general', 'content' ).getInputElement().getValue();
+
+					// Inserts the html.
+					this.getParentEditor().insertHtml( text );
+				},
+
+				contents :
+				[
+					{
+						label : editor.lang.common.generalTab,
+						id : 'general',
+						elements :
+						[
+							{
+								type : 'html',
+								id : 'pasteMsg',
+								html : '<div style="white-space:normal;width:340px;">' + editor.lang.embed.pasteMsg + '</div>'
+							},
+							{
+								type : 'html',
+								id : 'content',
+								style : 'width:340px;height:170px',
+								html :
+									'<textarea style="' +
+										'width:346px;' +
+										'height:170px;' +
+										'resize: none;' +
+										'border:1px solid black;' +
+										'background-color:white">' +
+									'</textarea>',
+								focus : function()
+								{
+									this.getElement().focus();
+								}
+							}
+						]
+					}
+				]
+			};
+		});
+})();

data/public/javascripts/ckeditor/_source/plugins/embed/lang/en.js

@@ -0,0 +1,9 @@
+CKEDITOR.plugins.setLang('embed', 'en',
+{
+  embed : 
+  {
+    title : "Paste embed",
+    button : "Paste embed",
+    pasteMsg : "Please, paste embed-code from Youtube, Myspace, Flickr and others sources into rectangle, using the keyboard (Ctrl + V), and click OK."
+  }
+});

data/public/javascripts/ckeditor/_source/plugins/embed/lang/ru.js

@@ -0,0 +1,9 @@
+CKEDITOR.plugins.setLang('embed', 'ru',
+{
+  embed : 
+  {
+    title : "Вставить embed",
+    button : "Вставить embed",
+    pasteMsg : "Пожалуйста, вставьте embed-код с Youtube, Myspace, Flickr и других ресурсов в прямоугольник, используя сочетание клавиш (Ctrl+V), и нажмите OK."
+  }
+});

data/public/javascripts/ckeditor/_source/plugins/embed/lang/uk.js

@@ -0,0 +1,9 @@
+CKEDITOR.plugins.setLang('embed', 'uk',
+{
+  embed : 
+  {
+    title : "Вставити embed",
+    button : "Вставити embed",
+    pasteMsg : "Будь ласка, вставте embed-код з Youtube, Myspace, Flickr та інших ресурсів в прямокутник, використовуючи (Ctrl+V), та нажміть OK."
+  }
+});

data/public/javascripts/ckeditor/_source/plugins/embed/plugin.js

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Paste as plain text plugin
+ */
+
+(function()
+{
+	// The pastetext command definition.
+	var embedCmd =
+	{
+		exec : function( editor )
+		{
+		  editor.openDialog( 'embed' );
+		  return;
+		}
+	};
+  
+	// Register the plugin.
+	CKEDITOR.plugins.add( 'embed',
+	{
+	  lang : [ 'en', 'ru', 'uk' ],
+	  requires : [ 'dialog' ],
+	  
+		init : function( editor )
+		{ 
+			var commandName = 'embed';
+			editor.addCommand( commandName, embedCmd );
+      
+			editor.ui.addButton( 'Embed',
+				{
+					label : editor.lang.embed.button,
+					command : commandName,
+					icon: this.path + "images/embed.png"
+				});
      
+			CKEDITOR.dialog.add( commandName, CKEDITOR.getUrl( this.path + 'dialogs/embed.js' ) );
+		}
+	});
+	
+})();

data/public/javascripts/ckeditor/_source/plugins/enterkey/plugin.js

@@ -0,0 +1,399 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+	CKEDITOR.plugins.add( 'enterkey',
+	{
+		requires : [ 'keystrokes', 'indent' ],
+
+		init : function( editor )
+		{
+			editor.addCommand( 'enter', {
+				modes : { wysiwyg:1 },
+				editorFocus : false,
+				exec : function( editor ){ enter( editor ); }
+			});
+
+			editor.addCommand( 'shiftEnter', {
+				modes : { wysiwyg:1 },
+				editorFocus : false,
+				exec : function( editor ){ shiftEnter( editor ); }
+			});
+
+			var keystrokes = editor.keystrokeHandler.keystrokes;
+			keystrokes[ 13 ] = 'enter';
+			keystrokes[ CKEDITOR.SHIFT + 13 ] = 'shiftEnter';
+		}
+	});
+
+	CKEDITOR.plugins.enterkey =
+	{
+		enterBlock : function( editor, mode, range, forceMode )
+		{
+			// Get the range for the current selection.
+			range = range || getRange( editor );
+
+			// We may not have valid ranges to work on, like when inside a
+			// contenteditable=false element.
+			if ( !range )
+				return;
+
+			var doc = range.document;
+
+			var atBlockStart = range.checkStartOfBlock(),
+				atBlockEnd = range.checkEndOfBlock(),
+				path = new CKEDITOR.dom.elementPath( range.startContainer ),
+				block = path.block;
+
+			// Exit the list when we're inside an empty list item block. (#5376)
+			if ( atBlockStart && atBlockEnd )
+			{
+				if ( block && ( block.is( 'li' ) || block.getParent().is( 'li' ) ) )
+				{
+					editor.execCommand( 'outdent' );
+					return;
+				}
+			}
+			// Don't split <pre> if we're in the middle of it, act as shift enter key.
+			else if ( !atBlockEnd && block && block.is( 'pre' ) )
+				enterBr( editor, mode, range, forceMode );
+
+			// Determine the block element to be used.
+			var blockTag = ( mode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
+
+			// Split the range.
+			var splitInfo = range.splitBlock( blockTag );
+
+			if ( !splitInfo )
+				return;
+
+			// Get the current blocks.
+			var previousBlock	= splitInfo.previousBlock,
+				nextBlock		= splitInfo.nextBlock;
+
+			var isStartOfBlock	= splitInfo.wasStartOfBlock,
+				isEndOfBlock	= splitInfo.wasEndOfBlock;
+
+			var node;
+
+			// If this is a block under a list item, split it as well. (#1647)
+			if ( nextBlock )
+			{
+				node = nextBlock.getParent();
+				if ( node.is( 'li' ) )
+				{
+					nextBlock.breakParent( node );
+					nextBlock.move( nextBlock.getNext(), 1 );
+				}
+			}
+			else if ( previousBlock && ( node = previousBlock.getParent() ) && node.is( 'li' ) )
+			{
+				previousBlock.breakParent( node );
+				node = previousBlock.getNext();
+				range.moveToElementEditStart( node );
+				previousBlock.move( previousBlock.getPrevious() );
+			}
+
+			// If we have both the previous and next blocks, it means that the
+			// boundaries were on separated blocks, or none of them where on the
+			// block limits (start/end).
+			if ( !isStartOfBlock && !isEndOfBlock )
+			{
+				// If the next block is an <li> with another list tree as the first
+				// child, we'll need to append a filler (<br>/NBSP) or the list item
+				// wouldn't be editable. (#1420)
+				if ( nextBlock.is( 'li' )
+					 && ( node = nextBlock.getFirst( CKEDITOR.dom.walker.invisible( true ) ) )
+					 && node.is && node.is( 'ul', 'ol' ) )
+					( CKEDITOR.env.ie ? doc.createText( '\xa0' ) : doc.createElement( 'br' ) ).insertBefore( node );
+
+				// Move the selection to the end block.
+				if ( nextBlock )
+					range.moveToElementEditStart( nextBlock );
+			}
+			else
+			{
+				var newBlock,
+					newBlockDir;
+
+				if ( previousBlock )
+				{
+					// Do not enter this block if it's a header tag, or we are in
+					// a Shift+Enter (#77). Create a new block element instead
+					// (later in the code).
+					if ( previousBlock.is( 'li' ) ||
+							! ( headerTagRegex.test( previousBlock.getName() ) || previousBlock.is( 'pre' ) ) )
+					{
+						// Otherwise, duplicate the previous block.
+						newBlock = previousBlock.clone();
+						// Value attribute of list item should not be duplicated (#7330).
+						newBlock.is( 'li' ) && newBlock.removeAttribute( 'value' );
+					}
+				}
+				else if ( nextBlock )
+					newBlock = nextBlock.clone();
+
+				if ( !newBlock )
+				{
+					// We have already created a new list item. (#6849)
+					if ( node && node.is( 'li' ) )
+						newBlock = node;
+					else
+					{
+						newBlock = doc.createElement( blockTag );
+						if ( previousBlock && ( newBlockDir = previousBlock.getDirection() ) )
+							newBlock.setAttribute( 'dir', newBlockDir );
+					}
+				}
+				// Force the enter block unless we're talking of a list item.
+				else if ( forceMode && !newBlock.is( 'li' ) )
+					newBlock.renameNode( blockTag );
+
+				// Recreate the inline elements tree, which was available
+				// before hitting enter, so the same styles will be available in
+				// the new block.
+				var elementPath = splitInfo.elementPath;
+				if ( elementPath )
+				{
+					for ( var i = 0, len = elementPath.elements.length ; i < len ; i++ )
+					{
+						var element = elementPath.elements[ i ];
+
+						if ( element.equals( elementPath.block ) || element.equals( elementPath.blockLimit ) )
+							break;
+
+						if ( CKEDITOR.dtd.$removeEmpty[ element.getName() ] )
+						{
+							element = element.clone();
+							newBlock.moveChildren( element );
+							newBlock.append( element );
+						}
+					}
+				}
+
+				if ( !CKEDITOR.env.ie )
+					newBlock.appendBogus();
+
+				if ( !newBlock.getParent() )
+					range.insertNode( newBlock );
+
+				// This is tricky, but to make the new block visible correctly
+				// we must select it.
+				// The previousBlock check has been included because it may be
+				// empty if we have fixed a block-less space (like ENTER into an
+				// empty table cell).
+				if ( CKEDITOR.env.ie && isStartOfBlock && ( !isEndOfBlock || !previousBlock.getChildCount() ) )
+				{
+					// Move the selection to the new block.
+					range.moveToElementEditStart( isEndOfBlock ? previousBlock : newBlock );
+					range.select();
+				}
+
+				// Move the selection to the new block.
+				range.moveToElementEditStart( isStartOfBlock && !isEndOfBlock ? nextBlock : newBlock );
+		}
+
+			if ( !CKEDITOR.env.ie )
+			{
+				if ( nextBlock )
+				{
+					// If we have split the block, adds a temporary span at the
+					// range position and scroll relatively to it.
+					var tmpNode = doc.createElement( 'span' );
+
+					// We need some content for Safari.
+					tmpNode.setHtml( '&nbsp;' );
+
+					range.insertNode( tmpNode );
+					tmpNode.scrollIntoView();
+					range.deleteContents();
+				}
+				else
+				{
+					// We may use the above scroll logic for the new block case
+					// too, but it gives some weird result with Opera.
+					newBlock.scrollIntoView();
+				}
+			}
+
+			range.select();
+		},
+
+		enterBr : function( editor, mode, range, forceMode )
+		{
+			// Get the range for the current selection.
+			range = range || getRange( editor );
+
+			// We may not have valid ranges to work on, like when inside a
+			// contenteditable=false element.
+			if ( !range )
+				return;
+
+			var doc = range.document;
+
+			// Determine the block element to be used.
+			var blockTag = ( mode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
+
+			var isEndOfBlock = range.checkEndOfBlock();
+
+			var elementPath = new CKEDITOR.dom.elementPath( editor.getSelection().getStartElement() );
+
+			var startBlock = elementPath.block,
+				startBlockTag = startBlock && elementPath.block.getName();
+
+			var isPre = false;
+
+			if ( !forceMode && startBlockTag == 'li' )
+			{
+				enterBlock( editor, mode, range, forceMode );
+				return;
+			}
+
+			// If we are at the end of a header block.
+			if ( !forceMode && isEndOfBlock && headerTagRegex.test( startBlockTag ) )
+			{
+				var newBlock,
+					newBlockDir;
+
+				if ( ( newBlockDir = startBlock.getDirection() ) )
+				{
+					newBlock = doc.createElement( 'div' );
+					newBlock.setAttribute( 'dir', newBlockDir );
+					newBlock.insertAfter( startBlock );
+					range.setStart( newBlock, 0 );
+				}
+				else
+				{
+					// Insert a <br> after the current paragraph.
+					doc.createElement( 'br' ).insertAfter( startBlock );
+
+					// A text node is required by Gecko only to make the cursor blink.
+					if ( CKEDITOR.env.gecko )
+						doc.createText( '' ).insertAfter( startBlock );
+
+					// IE has different behaviors regarding position.
+					range.setStartAt( startBlock.getNext(), CKEDITOR.env.ie ? CKEDITOR.POSITION_BEFORE_START : CKEDITOR.POSITION_AFTER_START );
+				}
+			}
+			else
+			{
+				var lineBreak;
+
+				isPre = ( startBlockTag == 'pre' );
+
+				// Gecko prefers <br> as line-break inside <pre> (#4711).
+				if ( isPre && !CKEDITOR.env.gecko )
+					lineBreak = doc.createText( CKEDITOR.env.ie ? '\r' : '\n' );
+				else
+					lineBreak = doc.createElement( 'br' );
+
+				range.deleteContents();
+				range.insertNode( lineBreak );
+
+				// IE has different behavior regarding position.
+				if ( CKEDITOR.env.ie )
+					range.setStartAt( lineBreak, CKEDITOR.POSITION_AFTER_END );
+				else
+				{
+					// A text node is required by Gecko only to make the cursor blink.
+					// We need some text inside of it, so the bogus <br> is properly
+					// created.
+					doc.createText( '\ufeff' ).insertAfter( lineBreak );
+
+					// If we are at the end of a block, we must be sure the bogus node is available in that block.
+					if ( isEndOfBlock )
+						lineBreak.getParent().appendBogus();
+
+					// Now we can remove the text node contents, so the caret doesn't
+					// stop on it.
+					lineBreak.getNext().$.nodeValue = '';
+
+					range.setStartAt( lineBreak.getNext(), CKEDITOR.POSITION_AFTER_START );
+
+					// Scroll into view, for non IE.
+					var dummy = null;
+
+					// BR is not positioned in Opera and Webkit.
+					if ( !CKEDITOR.env.gecko )
+					{
+						dummy = doc.createElement( 'span' );
+						// We need have some contents for Webkit to position it
+						// under parent node. ( #3681)
+						dummy.setHtml('&nbsp;');
+					}
+					else
+						dummy = doc.createElement( 'br' );
+
+					dummy.insertBefore( lineBreak.getNext() );
+					dummy.scrollIntoView();
+					dummy.remove();
+				}
+			}
+
+			// This collapse guarantees the cursor will be blinking.
+			range.collapse( true );
+
+			range.select( isPre );
+		}
+	};
+
+	var plugin = CKEDITOR.plugins.enterkey,
+		enterBr = plugin.enterBr,
+		enterBlock = plugin.enterBlock,
+		headerTagRegex = /^h[1-6]$/;
+
+	function shiftEnter( editor )
+	{
+		// Only effective within document.
+		if ( editor.mode != 'wysiwyg' )
+			return false;
+
+		// On SHIFT+ENTER:
+		// 1. We want to enforce the mode to be respected, instead
+		// of cloning the current block. (#77)
+		return enter( editor, editor.config.shiftEnterMode, 1 );
+	}
+
+	function enter( editor, mode, forceMode )
+	{
+		forceMode = editor.config.forceEnterMode || forceMode;
+
+		// Only effective within document.
+		if ( editor.mode != 'wysiwyg' )
+			return false;
+
+		if ( !mode )
+			mode = editor.config.enterMode;
+
+		// Use setTimout so the keys get cancelled immediatelly.
+		setTimeout( function()
+			{
+				editor.fire( 'saveSnapshot' );	// Save undo step.
+				if ( mode == CKEDITOR.ENTER_BR )
+					enterBr( editor, mode, null, forceMode );
+				else
+					enterBlock( editor, mode, null, forceMode );
+
+			}, 0 );
+
+		return true;
+	}
+
+	function getRange( editor )
+	{
+		// Get the selection ranges.
+		var ranges = editor.getSelection().getRanges( true );
+
+		// Delete the contents of all ranges except the first one.
+		for ( var i = ranges.length - 1 ; i > 0 ; i-- )
+		{
+			ranges[ i ].deleteContents();
+		}
+
+		// Return the first range.
+		return ranges[ 0 ];
+	}
+})();