typus 3.1.0.rc6 → 3.1.0.rc7

data/test/fixtures/rails_app/public/vendor/ckeditor/_source/plugins/adobeair/plugin.js

@@ -0,0 +1,228 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+	var eventNameList = [ 'click', 'keydown', 'mousedown', 'keypress', 'mouseover', 'mouseout' ];
+
+	// Inline event callbacks assigned via innerHTML/outerHTML, such as
+	// onclick/onmouseover, are ignored in AIR.
+	// Use DOM2 event listeners to substitue inline handlers instead.
+	function convertInlineHandlers( container )
+	{
+		// TODO: document.querySelectorAll is not supported in AIR.
+		var children = container.getElementsByTag( '*' ),
+			count = children.count(),
+			child;
+
+		for ( var i = 0; i < count; i++ )
+		{
+			child = children.getItem( i );
+
+			(function( node )
+			{
+				for ( var j = 0; j < eventNameList.length; j++ )
+				{
+					(function( eventName )
+					{
+						var inlineEventHandler = node.getAttribute( 'on' + eventName );
+						if ( node.hasAttribute( 'on' + eventName ) )
+						{
+							node.removeAttribute( 'on' + eventName );
+							node.on( eventName, function( evt )
+							{
+								var callFunc = /(return\s*)?CKEDITOR\.tools\.callFunction\(([^)]+)\)/.exec( inlineEventHandler ),
+									hasReturn = callFunc && callFunc[ 1 ],
+									callFuncArgs = callFunc &&  callFunc[ 2 ].split( ',' ),
+									preventDefault = /return false;/.test( inlineEventHandler );
+
+								if ( callFuncArgs )
+								{
+									var nums = callFuncArgs.length,
+										argName;
+
+									for ( var i = 0; i < nums; i++ )
+									{
+										// Trim spaces around param.
+										callFuncArgs[ i ] = argName = CKEDITOR.tools.trim( callFuncArgs[ i ] );
+
+										// String form param.
+										var strPattern = argName.match( /^(["'])([^"']*?)\1$/ );
+										if ( strPattern )
+										{
+											callFuncArgs[ i ] = strPattern[ 2 ];
+											continue;
+										}
+
+										// Integer form param.
+										if ( argName.match( /\d+/ ) )
+										{
+											callFuncArgs[ i ] = parseInt( argName, 10 );
+											continue;
+										}
+
+										// Speical variables.
+										switch( argName )
+										{
+											case 'this' :
+												callFuncArgs[ i ] = node.$;
+												break;
+											case 'event' :
+												callFuncArgs[ i ] = evt.data.$;
+												break;
+											case 'null' :
+												callFuncArgs [ i ] = null;
+												break;
+										}
+									}
+
+									var retval = CKEDITOR.tools.callFunction.apply( window, callFuncArgs );
+									if ( hasReturn && retval === false )
+										 preventDefault = 1;
+								}
+
+								if ( preventDefault )
+									evt.data.preventDefault();
+							});
+						}
+					})( eventNameList[ j ] );
+				}
+			})( child );
+		}
+	}
+
+	CKEDITOR.plugins.add( 'adobeair',
+	{
+		init : function( editor )
+		{
+			if ( !CKEDITOR.env.air )
+				return;
+
+			// Body doesn't get default margin on AIR.
+			editor.addCss( 'body { padding: 8px }' );
+
+			editor.on( 'uiReady', function()
+				{
+					convertInlineHandlers( editor.container );
+
+					if ( editor.sharedSpaces )
+					{
+						for ( var space in editor.sharedSpaces )
+							convertInlineHandlers( editor.sharedSpaces[ space ] );
+					}
+
+					editor.on( 'elementsPathUpdate', function( evt ) { convertInlineHandlers( evt.data.space ); } );
+				});
+
+			editor.on( 'contentDom', function()
+				{
+					// Hyperlinks are enabled in editable documents in Adobe
+					// AIR. Prevent their click behavior.
+					editor.document.on( 'click', function( ev )
+						{
+							ev.data.preventDefault( true );
+						});
+				});
+		}
+	});
+
+	CKEDITOR.ui.on( 'ready', function( evt )
+		{
+			var ui = evt.data;
+			// richcombo, panelbutton and menu
+			if ( ui._.panel )
+			{
+				var panel = ui._.panel._.panel,
+						holder;
+
+				( function()
+				{
+					// Adding dom event listeners off-line are not supported in AIR,
+					// waiting for panel iframe loaded.
+					if ( !panel.isLoaded )
+					{
+						setTimeout( arguments.callee, 30 );
+						return;
+					}
+					holder = panel._.holder;
+					convertInlineHandlers( holder );
+				})();
+			}
+			else if ( ui instanceof CKEDITOR.dialog )
+				convertInlineHandlers( ui._.element );
+		});
+})();
+
+CKEDITOR.dom.document.prototype.write = CKEDITOR.tools.override( CKEDITOR.dom.document.prototype.write,
+	function( original_write )
+	{
+		function appendElement( parent, tagName, fullTag, text )
+		{
+			var node = parent.append( tagName ),
+				attrs = CKEDITOR.htmlParser.fragment.fromHtml( fullTag ).children[ 0 ].attributes;
+			attrs && node.setAttributes( attrs );
+			text && node.append( parent.getDocument().createText( text ) );
+		}
+
+		return function( html, mode )
+			{
+				// document.write() or document.writeln() fail silently after
+				// the page load event in Adobe AIR.
+				// DOM manipulation could be used instead.
+				if ( this.getBody() )
+				{
+					// We're taking the below extra work only because innerHTML
+					// on <html> element doesn't work as expected.
+					var doc = this,
+						head = this.getHead();
+
+					// Create style nodes for inline css. ( <style> content doesn't applied when setting via innerHTML )
+					html = html.replace( /(<style[^>]*>)([\s\S]*?)<\/style>/gi,
+						function ( match, startTag, styleText )
+						{
+							appendElement( head, 'style', startTag, styleText );
+							return '';
+						});
+
+					html = html.replace( /<base\b[^>]*\/>/i,
+						function( match )
+						{
+							appendElement( head, 'base', match );
+							return '';
+						});
+
+					html = html.replace( /<title>([\s\S]*)<\/title>/i,
+						function( match, title )
+						{
+							doc.$.title = title;
+							return '';
+						});
+
+					// Move the rest of head stuff.
+					html = html.replace( /<head>([\s\S]*)<\/head>/i,
+						function( headHtml )
+						{
+							// Inject the <head> HTML inside a <div>.
+							// Do that before getDocumentHead because WebKit moves
+							// <link css> elements to the <head> at this point.
+							var div = new CKEDITOR.dom.element( 'div', doc );
+							div.setHtml( headHtml );
+							// Move the <div> nodes to <head>.
+							div.moveChildren( head );
+							return '';
+						});
+
+					html.replace( /(<body[^>]*>)([\s\S]*)(?=$|<\/body>)/i,
+						function( match, startTag, innerHTML )
+						{
+							doc.getBody().setHtml( innerHTML );
+							var attrs = CKEDITOR.htmlParser.fragment.fromHtml( startTag ).children[ 0 ].attributes;
+							attrs && doc.getBody().setAttributes( attrs );
+						});
+				}
+				else
+					original_write.apply( this, arguments );
+			};
+	});

data/test/fixtures/rails_app/public/vendor/ckeditor/_source/plugins/ajax/plugin.js

@@ -0,0 +1,152 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.ajax} object, which holds ajax methods for
+ *		data loading.
+ */
+
+(function()
+{
+	CKEDITOR.plugins.add( 'ajax',
+		{
+			requires : [ 'xml' ]
+		});
+
+	/**
+	 * Ajax methods for data loading.
+	 * @namespace
+	 * @example
+	 */
+	CKEDITOR.ajax = (function()
+	{
+		var createXMLHttpRequest = function()
+		{
+			// In IE, using the native XMLHttpRequest for local files may throw
+			// "Access is Denied" errors.
+			if ( !CKEDITOR.env.ie || location.protocol != 'file:' )
+				try { return new XMLHttpRequest(); } catch(e) {}
+
+			try { return new ActiveXObject( 'Msxml2.XMLHTTP' ); } catch (e) {}
+			try { return new ActiveXObject( 'Microsoft.XMLHTTP' ); } catch (e) {}
+
+			return null;
+		};
+
+		var checkStatus = function( xhr )
+		{
+			// HTTP Status Codes:
+			//	 2xx : Success
+			//	 304 : Not Modified
+			//	   0 : Returned when running locally (file://)
+			//	1223 : IE may change 204 to 1223 (see http://dev.jquery.com/ticket/1450)
+
+			return ( xhr.readyState == 4 &&
+					(	( xhr.status >= 200 && xhr.status < 300 ) ||
+						xhr.status == 304 ||
+						xhr.status === 0 ||
+						xhr.status == 1223 ) );
+		};
+
+		var getResponseText = function( xhr )
+		{
+			if ( checkStatus( xhr ) )
+				return xhr.responseText;
+			return null;
+		};
+
+		var getResponseXml = function( xhr )
+		{
+			if ( checkStatus( xhr ) )
+			{
+				var xml = xhr.responseXML;
+				return new CKEDITOR.xml( xml && xml.firstChild ? xml : xhr.responseText );
+			}
+			return null;
+		};
+
+		var load = function( url, callback, getResponseFn )
+		{
+			var async = !!callback;
+
+			var xhr = createXMLHttpRequest();
+
+			if ( !xhr )
+				return null;
+
+			xhr.open( 'GET', url, async );
+
+			if ( async )
+			{
+				// TODO: perform leak checks on this closure.
+				/** @ignore */
+				xhr.onreadystatechange = function()
+				{
+					if ( xhr.readyState == 4 )
+					{
+						callback( getResponseFn( xhr ) );
+						xhr = null;
+					}
+				};
+			}
+
+			xhr.send(null);
+
+			return async ? '' : getResponseFn( xhr );
+		};
+
+		return 	/** @lends CKEDITOR.ajax */ {
+
+			/**
+			 * Loads data from an URL as plain text.
+			 * @param {String} url The URL from which load data.
+			 * @param {Function} [callback] A callback function to be called on
+			 *		data load. If not provided, the data will be loaded
+			 *		synchronously.
+			 * @returns {String} The loaded data. For asynchronous requests, an
+			 *		empty string. For invalid requests, null.
+			 * @example
+			 * // Load data synchronously.
+			 * var data = CKEDITOR.ajax.load( 'somedata.txt' );
+			 * alert( data );
+			 * @example
+			 * // Load data asynchronously.
+			 * var data = CKEDITOR.ajax.load( 'somedata.txt', function( data )
+			 *     {
+			 *         alert( data );
+			 *     } );
+			 */
+			load : function( url, callback )
+			{
+				return load( url, callback, getResponseText );
+			},
+
+			/**
+			 * Loads data from an URL as XML.
+			 * @param {String} url The URL from which load data.
+			 * @param {Function} [callback] A callback function to be called on
+			 *		data load. If not provided, the data will be loaded
+			 *		synchronously.
+			 * @returns {CKEDITOR.xml} An XML object holding the loaded data. For asynchronous requests, an
+			 *		empty string. For invalid requests, null.
+			 * @example
+			 * // Load XML synchronously.
+			 * var xml = CKEDITOR.ajax.loadXml( 'somedata.xml' );
+			 * alert( xml.getInnerXml( '//' ) );
+			 * @example
+			 * // Load XML asynchronously.
+			 * var data = CKEDITOR.ajax.loadXml( 'somedata.xml', function( xml )
+			 *     {
+			 *         alert( xml.getInnerXml( '//' ) );
+			 *     } );
+			 */
+			loadXml : function( url, callback )
+			{
+				return load( url, callback, getResponseXml );
+			}
+		};
+	})();
+
+})();

data/test/fixtures/rails_app/public/vendor/ckeditor/_source/plugins/autogrow/plugin.js

@@ -0,0 +1,88 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file AutoGrow plugin
+ */
+(function(){
+	var resizeEditor = function( editor )
+	{
+		if ( !editor.window )
+			return;
+		var doc = editor.document,
+			currentHeight = editor.window.getViewPaneSize().height,
+			newHeight;
+
+		// We can not use documentElement to calculate the height for IE (#6061).
+		// It is not good for IE Quirks, yet using offsetHeight would also not work as expected (#6408).
+		// We do the same for FF because of the html height workaround (#6341).
+		if ( CKEDITOR.env.ie || CKEDITOR.env.gecko )
+			newHeight = doc.getBody().$.scrollHeight + ( CKEDITOR.env.ie && CKEDITOR.env.quirks ? 0 : 24 );
+		else
+			newHeight = doc.getDocumentElement().$.offsetHeight;
+
+		var min = editor.config.autoGrow_minHeight,
+			max = editor.config.autoGrow_maxHeight;
+		( min == undefined ) && ( editor.config.autoGrow_minHeight = min = 200 );
+		if ( min )
+			newHeight = Math.max( newHeight, min );
+		if ( max )
+			newHeight = Math.min( newHeight, max );
+
+		if ( newHeight != currentHeight )
+		{
+			newHeight = editor.fire( 'autoGrow', { currentHeight : currentHeight, newHeight : newHeight } ).newHeight;
+			editor.resize( editor.container.getStyle( 'width' ), newHeight, true );
+		}
+	};
+	CKEDITOR.plugins.add( 'autogrow',
+	{
+		init : function( editor )
+		{
+			for ( var eventName in { contentDom:1, key:1, selectionChange:1, insertElement:1 } )
+			{
+				editor.on( eventName, function( evt )
+				{
+					var maximize = editor.getCommand( 'maximize' );
+					// Some time is required for insertHtml, and it gives other events better performance as well.
+					if ( evt.editor.mode == 'wysiwyg' &&
+						// Disable autogrow when the editor is maximized .(#6339)
+						( !maximize || maximize.state != CKEDITOR.TRISTATE_ON ) )
+					{
+						setTimeout( function(){ resizeEditor( evt.editor ); }, 100 );
+					}
+				});
+			}
+		}
+	});
+})();
+/**
+ * The minimum height to which the editor can reach using AutoGrow.
+ * @name CKEDITOR.config.autoGrow_minHeight
+ * @type Number
+ * @default 200
+ * @since 3.4
+ * @example
+ * config.autoGrow_minHeight = 300;
+ */
+
+/**
+ * The maximum height to which the editor can reach using AutoGrow. Zero means unlimited.
+ * @name CKEDITOR.config.autoGrow_maxHeight
+ * @type Number
+ * @default 0
+ * @since 3.4
+ * @example
+ * config.autoGrow_maxHeight = 400;
+ */
+
+/**
+ * Fired when the AutoGrow plugin is about to change the size of the editor.
+ * @name CKEDITOR.editor#autogrow
+ * @event
+ * @param {Number} data.currentHeight The current height of the editor (before the resizing).
+ * @param {Number} data.newHeight The new height of the editor (after the resizing). It can be changed
+ *				to determine another height to be used instead.
+ */

data/test/fixtures/rails_app/public/vendor/ckeditor/_source/plugins/basicstyles/plugin.js

@@ -0,0 +1,101 @@
+/*
+Copyright (c) 2003-2011, 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 )
+	{
+		// 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 )
+				{
+					!editor.readOnly && editor.getCommand( commandName ).setState( state );
+				});
+
+			editor.addCommand( commandName, new CKEDITOR.styleCommand( style ) );
+
+			editor.ui.addButton( buttonName,
+				{
+					label : buttonLabel,
+					command : commandName
+				});
+		};
+
+		var config = editor.config,
+			lang = editor.lang;
+
+		addButtonCommand( 'Bold'		, lang.bold		, 'bold'		, config.coreStyles_bold );
+		addButtonCommand( 'Italic'		, lang.italic		, 'italic'		, config.coreStyles_italic );
+		addButtonCommand( 'Underline'	, lang.underline		, 'underline'	, config.coreStyles_underline );
+		addButtonCommand( 'Strike'		, lang.strike		, 'strike'		, config.coreStyles_strike );
+		addButtonCommand( 'Subscript'	, lang.subscript		, 'subscript'	, config.coreStyles_subscript );
+		addButtonCommand( 'Superscript'	, lang.superscript		, 'superscript'	, config.coreStyles_superscript );
+	}
+});
+
+// Basic Inline Styles.
+
+/**
+ * The style definition to be used to apply the bold style in the text.
+ * @type Object
+ * @example
+ * config.coreStyles_bold = { element : 'b', overrides : 'strong' };
+ * @example
+ * config.coreStyles_bold = { element : 'span', attributes : {'class': 'Bold'} };
+ */
+CKEDITOR.config.coreStyles_bold = { element : 'strong', overrides : 'b' };
+
+/**
+ * The style definition to be used to apply the italic style in the text.
+ * @type Object
+ * @default { element : 'em', overrides : 'i' }
+ * @example
+ * config.coreStyles_italic = { element : 'i', overrides : 'em' };
+ * @example
+ * CKEDITOR.config.coreStyles_italic = { element : 'span', attributes : {'class': 'Italic'} };
+ */
+CKEDITOR.config.coreStyles_italic = { element : 'em', overrides : 'i' };
+
+/**
+ * The style definition to be used to apply the underline style in the text.
+ * @type Object
+ * @default { element : 'u' }
+ * @example
+ * CKEDITOR.config.coreStyles_underline = { element : 'span', attributes : {'class': 'Underline'}};
+ */
+CKEDITOR.config.coreStyles_underline = { element : 'u' };
+
+/**
+ * The style definition to be used to apply the strike style in the text.
+ * @type Object
+ * @default { element : 'strike' }
+ * @example
+ * CKEDITOR.config.coreStyles_strike = { element : 'span', attributes : {'class': 'StrikeThrough'}, overrides : 'strike' };
+ */
+CKEDITOR.config.coreStyles_strike = { element : 'strike' };
+
+/**
+ * The style definition to be used to apply the subscript style in the text.
+ * @type Object
+ * @default { element : 'sub' }
+ * @example
+ * CKEDITOR.config.coreStyles_subscript = { element : 'span', attributes : {'class': 'Subscript'}, overrides : 'sub' };
+ */
+CKEDITOR.config.coreStyles_subscript = { element : 'sub' };
+
+/**
+ * The style definition to be used to apply the superscript style in the text.
+ * @type Object
+ * @default { element : 'sup' }
+ * @example
+ * CKEDITOR.config.coreStyles_superscript = { element : 'span', attributes : {'class': 'Superscript'}, overrides : 'sup' };
+ */
+CKEDITOR.config.coreStyles_superscript = { element : 'sup' };