bcms_fckeditor 1.0.0

data/public/bcms/ckeditor/core/event.js

@@ -0,0 +1,335 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.event} class, which serves as the
+ *		base for classes and objects that require event handling features.
+ */
+
+if ( !CKEDITOR.event )
+{
+	/**
+	 * This is a base class for classes and objects that require event handling
+	 * features.
+	 * @constructor
+	 * @example
+	 */
+	CKEDITOR.event = function()
+	{};
+
+	/**
+	 * Implements the {@link CKEDITOR.event} features in an object.
+	 * @param {Object} targetObject The object in which implement the features.
+	 * @example
+	 * var myObject = { message : 'Example' };
+	 * <b>CKEDITOR.event.implementOn( myObject }</b>;
+	 * myObject.on( 'testEvent', function()
+	 *     {
+	 *         alert( this.message );  // "Example"
+	 *     });
+	 * myObject.fire( 'testEvent' );
+	 */
+	CKEDITOR.event.implementOn = function( targetObject, isTargetPrototype )
+	{
+		var eventProto = CKEDITOR.event.prototype;
+
+		for ( var prop in eventProto )
+		{
+			if ( targetObject[ prop ] == undefined )
+				targetObject[ prop ] = eventProto[ prop ];
+		}
+	};
+
+	CKEDITOR.event.prototype = (function()
+	{
+		// Returns the private events object for a given object.
+		var getPrivate = function( obj )
+		{
+			var _ = ( obj.getPrivate && obj.getPrivate() ) || obj._ || ( obj._ = {} );
+			return _.events || ( _.events = {} );
+		};
+
+		var eventEntry = function( eventName )
+		{
+			this.name = eventName;
+			this.listeners = [];
+		};
+
+		eventEntry.prototype =
+		{
+			// Get the listener index for a specified function.
+			// Returns -1 if not found.
+			getListenerIndex : function( listenerFunction )
+			{
+				for ( var i = 0, listeners = this.listeners ; i < listeners.length ; i++ )
+				{
+					if ( listeners[i].fn == listenerFunction )
+						return i;
+				}
+				return -1;
+			}
+		};
+
+		return /** @lends CKEDITOR.event.prototype */ {
+			/**
+			 * Registers a listener to a specific event in the current object.
+			 * @param {String} eventName The event name to which listen.
+			 * @param {Function} listenerFunction The function listening to the
+			 *		event.
+			 * @param {Object} [scopeObj] The object used to scope the listener
+			 *		call (the this object. If omitted, the current object is used.
+			 * @param {Object} [listenerData] Data to be sent as the
+			 *		{@link CKEDITOR.eventInfo#listenerData} when calling the
+			 *		listener.
+			 * @param {Number} [priority] The listener priority. Lower priority
+			 *		listeners are called first. Listeners with the same priority
+			 *		value are called in registration order. Defaults to 10.
+			 * @example
+			 * someObject.on( 'someEvent', function()
+			 *     {
+			 *         alert( this == someObject );  // "true"
+			 *     });
+			 * @example
+			 * someObject.on( 'someEvent', function()
+			 *     {
+			 *         alert( this == anotherObject );  // "true"
+			 *     }
+			 *     , anotherObject );
+			 * @example
+			 * someObject.on( 'someEvent', function( event )
+			 *     {
+			 *         alert( event.listenerData );  // "Example"
+			 *     }
+			 *     , null, 'Example' );
+			 * @example
+			 * someObject.on( 'someEvent', function() { ... } );                   // 2nd called
+			 * someObject.on( 'someEvent', function() { ... }, null, null, 100 );  // 3rd called
+			 * someObject.on( 'someEvent', function() { ... }, null, null, 1 );    // 1st called
+			 */
+			on : function( eventName, listenerFunction, scopeObj, listenerData, priority )
+			{
+				// Get the event entry (create it if needed).
+				var events = getPrivate( this ),
+					event = events[ eventName ] || ( events[ eventName ] = new eventEntry( eventName ) );
+
+				if ( event.getListenerIndex( listenerFunction ) < 0 )
+				{
+					// Get the listeners.
+					var listeners = event.listeners;
+
+					// Fill the scope.
+					if ( !scopeObj )
+						scopeObj = this;
+
+					// Default the priority, if needed.
+					if ( isNaN( priority ) )
+						priority = 10;
+
+					var me = this;
+
+					// Create the function to be fired for this listener.
+					var listenerFirer = function( editor, publisherData, stopFn, cancelFn )
+					{
+						var ev =
+						{
+							name : eventName,
+							sender : this,
+							editor : editor,
+							data : publisherData,
+							listenerData : listenerData,
+							stop : stopFn,
+							cancel : cancelFn,
+							removeListener : function()
+							{
+								me.removeListener( eventName, listenerFunction );
+							}
+						};
+
+						listenerFunction.call( scopeObj, ev );
+
+						return ev.data;
+					};
+					listenerFirer.fn = listenerFunction;
+					listenerFirer.priority = priority;
+
+					// Search for the right position for this new listener, based on its
+					// priority.
+					for ( var i = listeners.length - 1 ; i >= 0 ; i-- )
+					{
+						// Find the item which should be before the new one.
+						if ( listeners[ i ].priority <= priority )
+						{
+							// Insert the listener in the array.
+							listeners.splice( i + 1, 0, listenerFirer );
+							return;
+						}
+					}
+
+					// If no position has been found (or zero length), put it in
+					// the front of list.
+					listeners.unshift( listenerFirer );
+				}
+			},
+
+			/**
+			 * Fires an specific event in the object. All registered listeners are
+			 * called at this point.
+			 * @function
+			 * @param {String} eventName The event name to fire.
+			 * @param {Object} [data] Data to be sent as the
+			 *		{@link CKEDITOR.eventInfo#data} when calling the
+			 *		listeners.
+			 * @param {CKEDITOR.editor} [editor] The editor instance to send as the
+			 *		{@link CKEDITOR.eventInfo#editor} when calling the
+			 *		listener.
+			 * @returns {Boolean|Object} A booloan indicating that the event is to be
+			 *		canceled, or data returned by one of the listeners.
+			 * @example
+			 * someObject.on( 'someEvent', function() { ... } );
+			 * someObject.on( 'someEvent', function() { ... } );
+			 * <b>someObject.fire( 'someEvent' )</b>;  // both listeners are called
+			 * @example
+			 * someObject.on( 'someEvent', function( event )
+			 *     {
+			 *         alert( event.data );  // "Example"
+			 *     });
+			 * <b>someObject.fire( 'someEvent', 'Example' )</b>;
+			 */
+			fire : (function()
+			{
+				// Create the function that marks the event as stopped.
+				var stopped = false;
+				var stopEvent = function()
+				{
+					stopped = true;
+				};
+
+				// Create the function that marks the event as canceled.
+				var canceled = false;
+				var cancelEvent = function()
+				{
+					canceled = true;
+				};
+
+				return function( eventName, data, editor )
+				{
+					// Get the event entry.
+					var event = getPrivate( this )[ eventName ];
+
+					// Save the previous stopped and cancelled states. We may
+					// be nesting fire() calls.
+					var previousStopped = stopped,
+						previousCancelled = canceled;
+
+					// Reset the stopped and canceled flags.
+					stopped = canceled = false;
+
+					if ( event )
+					{
+						var listeners = event.listeners;
+
+						if ( listeners.length )
+						{
+							// As some listeners may remove themselves from the
+							// event, the original array length is dinamic. So,
+							// let's make a copy of all listeners, so we are
+							// sure we'll call all of them.
+							listeners = listeners.slice( 0 );
+
+							// Loop through all listeners.
+							for ( var i = 0 ; i < listeners.length ; i++ )
+							{
+								// Call the listener, passing the event data.
+								var retData = listeners[i].call( this, editor, data, stopEvent, cancelEvent );
+
+								if ( typeof retData != 'undefined' )
+									data = retData;
+
+								// No further calls is stopped or canceled.
+								if ( stopped || canceled )
+									break;
+							}
+						}
+					}
+
+					var ret = canceled || ( typeof data == 'undefined' ? false : data );
+
+					// Restore the previous stopped and canceled states.
+					stopped = previousStopped;
+					canceled = previousCancelled;
+
+					return ret;
+				};
+			})(),
+
+			/**
+			 * Fires an specific event in the object, releasing all listeners
+			 * registered to that event. The same listeners are not called again on
+			 * successive calls of it or of {@link #fire}.
+			 * @param {String} eventName The event name to fire.
+			 * @param {Object} [data] Data to be sent as the
+			 *		{@link CKEDITOR.eventInfo#data} when calling the
+			 *		listeners.
+			 * @param {CKEDITOR.editor} [editor] The editor instance to send as the
+			 *		{@link CKEDITOR.eventInfo#editor} when calling the
+			 *		listener.
+			 * @returns {Boolean|Object} A booloan indicating that the event is to be
+			 *		canceled, or data returned by one of the listeners.
+			 * @example
+			 * someObject.on( 'someEvent', function() { ... } );
+			 * someObject.fire( 'someEvent' );  // above listener called
+			 * <b>someObject.fireOnce( 'someEvent' )</b>;  // above listener called
+			 * someObject.fire( 'someEvent' );  // no listeners called
+			 */
+			fireOnce : function( eventName, data, editor )
+			{
+				var ret = this.fire( eventName, data, editor );
+				delete getPrivate( this )[ eventName ];
+				return ret;
+			},
+
+			/**
+			 * Unregisters a listener function from being called at the specified
+			 *		event. No errors are thrown if the listener has not been
+			 *		registered previously.
+			 * @param {String} eventName The event name.
+			 * @param {Function} listenerFunction The listener function to unregister.
+			 * @example
+			 * var myListener = function() { ... };
+			 * someObject.on( 'someEvent', myListener );
+			 * someObject.fire( 'someEvent' );  // myListener called
+			 * <b>someObject.removeListener( 'someEvent', myListener )</b>;
+			 * someObject.fire( 'someEvent' );  // myListener not called
+			 */
+			removeListener : function( eventName, listenerFunction )
+			{
+				// Get the event entry.
+				var event = getPrivate( this )[ eventName ];
+
+				if ( event )
+				{
+					var index = event.getListenerIndex( listenerFunction );
+					if ( index >= 0 )
+						event.listeners.splice( index, 1 );
+				}
+			},
+
+			/**
+			 * Checks if there is any listener registered to a given event.
+			 * @param {String} eventName The event name.
+			 * @example
+			 * var myListener = function() { ... };
+			 * someObject.on( 'someEvent', myListener );
+			 * alert( someObject.<b>hasListeners( 'someEvent' )</b> );  // "true"
+			 * alert( someObject.<b>hasListeners( 'noEvent' )</b> );    // "false"
+			 */
+			hasListeners : function( eventName )
+			{
+				var event = getPrivate( this )[ eventName ];
+				return ( event && event.listeners.length > 0 ) ;
+			}
+		};
+	})();
+}

data/public/bcms/ckeditor/core/eventInfo.js

@@ -0,0 +1,120 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the "virtual" {@link CKEDITOR.eventInfo} class, which
+ *		contains the defintions of the event object passed to event listeners.
+ *		This file is for documentation purposes only.
+ */
+
+/**
+ * This class is not really part of the API. It just illustrates the features
+ * of the event object passed to event listeners by a {@link CKEDITOR.event}
+ * based object.
+ * @name CKEDITOR.eventInfo
+ * @constructor
+ * @example
+ * // Do not do this.
+ * var myEvent = new CKEDITOR.eventInfo();  // Error: CKEDITOR.eventInfo is undefined
+ */
+
+/**
+ * The event name.
+ * @name CKEDITOR.eventInfo.prototype.name
+ * @field
+ * @type String
+ * @example
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         alert( <b>event.name</b> );  // "someEvent"
+ *     });
+ * someObject.fire( 'someEvent' );
+ */
+
+/**
+ * The object that publishes (sends) the event.
+ * @name CKEDITOR.eventInfo.prototype.sender
+ * @field
+ * @type Object
+ * @example
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         alert( <b>event.sender</b> == someObject );  // "true"
+ *     });
+ * someObject.fire( 'someEvent' );
+ */
+
+/**
+ * The editor instance that holds the sender. May be the same as sender. May be
+ * null if the sender is not part of an editor instance, like a component
+ * running in standalone mode.
+ * @name CKEDITOR.eventInfo.prototype.editor
+ * @field
+ * @type CKEDITOR.editor
+ * @example
+ * myButton.on( 'someEvent', function( event )
+ *     {
+ *         alert( <b>event.editor</b> == myEditor );  // "true"
+ *     });
+ * myButton.fire( 'someEvent', null, <b>myEditor</b> );
+ */
+
+/**
+ * Any kind of additional data. Its format and usage is event dependent.
+ * @name CKEDITOR.eventInfo.prototype.data
+ * @field
+ * @type Object
+ * @example
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         alert( <b>event.data</b> );  // "Example"
+ *     });
+ * someObject.fire( 'someEvent', <b>'Example'</b> );
+ */
+
+/**
+ * Any extra data appended during the listener registration.
+ * @name CKEDITOR.eventInfo.prototype.listenerData
+ * @field
+ * @type Object
+ * @example
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         alert( <b>event.listenerData</b> );  // "Example"
+ *     }
+ *     , null, <b>'Example'</b> );
+ */
+
+/**
+ * Indicates that no further listeners are to be called.
+ * @name CKEDITOR.eventInfo.prototype.stop
+ * @function
+ * @example
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         <b>event.stop()</b>;
+ *     });
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         // This one will not be called.
+ *     });
+ * alert( someObject.fire( 'someEvent' ) );  // "false"
+ */
+
+/**
+ * Indicates that the event is to be cancelled (if cancelable).
+ * @name CKEDITOR.eventInfo.prototype.cancel
+ * @function
+ * @example
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         <b>event.cancel()</b>;
+ *     });
+ * someObject.on( 'someEvent', function( event )
+ *     {
+ *         // This one will not be called.
+ *     });
+ * alert( someObject.fire( 'someEvent' ) );  // "true"
+ */

data/public/bcms/ckeditor/core/focusmanager.js

@@ -0,0 +1,123 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.focusManager} class, which is used
+ *		to handle the focus on editor instances..
+ */
+
+/**
+ * Manages the focus activity in an editor instance. This class is to be used
+ * mainly by UI elements coders when adding interface elements to CKEditor.
+ * @constructor
+ * @param {CKEDITOR.editor} editor The editor instance.
+ * @example
+ */
+CKEDITOR.focusManager = function( editor )
+{
+	if ( editor.focusManager )
+		return editor.focusManager;
+
+	/**
+	 * Indicates that the editor instance has focus.
+	 * @type Boolean
+	 * @example
+	 * alert( CKEDITOR.instances.editor1.focusManager.hasFocus );  // e.g "true"
+	 */
+	this.hasFocus = false;
+
+	/**
+	 * Object used to hold private stuff.
+	 * @private
+	 */
+	this._ =
+	{
+		editor : editor
+	};
+
+	return this;
+};
+
+CKEDITOR.focusManager.prototype =
+{
+	/**
+	 * Indicates that the editor instance has the focus.
+	 *
+	 * This function is not used to set the focus in the editor. Use
+	 * {@link CKEDITOR.editor#focus} for it instead.
+	 * @example
+	 * var editor = CKEDITOR.instances.editor1;
+	 * <b>editor.focusManager.focus()</b>;
+	 */
+	focus : function()
+	{
+		if ( this._.timer )
+			clearTimeout( this._.timer );
+
+		if ( !this.hasFocus )
+		{
+			// If another editor has the current focus, we first "blur" it. In
+			// this way the events happen in a more logical sequence, like:
+			//		"focus 1" > "blur 1" > "focus 2"
+			// ... instead of:
+			//		"focus 1" > "focus 2" > "blur 1"
+			if ( CKEDITOR.currentInstance )
+				CKEDITOR.currentInstance.focusManager.forceBlur();
+
+			var editor = this._.editor;
+
+			editor.container.getFirst().addClass( 'cke_focus' );
+
+			this.hasFocus = true;
+			editor.fire( 'focus' );
+		}
+	},
+
+	/**
+	 * Indicates that the editor instance has lost the focus. Note that this
+	 * functions acts asynchronously with a delay of 100ms to avoid subsequent
+	 * blur/focus effects. If you want the "blur" to happen immediately, use
+	 * the {@link #forceBlur} function instead.
+	 * @example
+	 * var editor = CKEDITOR.instances.editor1;
+	 * <b>editor.focusManager.blur()</b>;
+	 */
+	blur : function()
+	{
+		var focusManager = this;
+
+		if ( focusManager._.timer )
+			clearTimeout( focusManager._.timer );
+
+		focusManager._.timer = setTimeout(
+			function()
+			{
+				delete focusManager._.timer;
+				focusManager.forceBlur();
+			}
+			, 100 );
+	},
+
+	/**
+	 * Indicates that the editor instance has lost the focus. Unlike
+	 * {@link #blur}, this function is synchronous, marking the instance as
+	 * "blured" immediately.
+	 * @example
+	 * var editor = CKEDITOR.instances.editor1;
+	 * <b>editor.focusManager.forceBlur()</b>;
+	 */
+	forceBlur : function()
+	{
+		if ( this.hasFocus )
+		{
+			var editor = this._.editor;
+
+			editor.container.getFirst().removeClass( 'cke_focus' );
+
+			this.hasFocus = false;
+			editor.fire( 'blur' );
+		}
+	}
+};

data/public/bcms/ckeditor/core/htmlparser/basicwriter.js

@@ -0,0 +1,140 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.htmlParser.basicWriter = CKEDITOR.tools.createClass(
+{
+	$ : function()
+	{
+		this._ =
+		{
+			output : []
+		};
+	},
+
+	proto :
+	{
+		/**
+		 * 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 )
+		{
+			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 "&gt;".
+		 * writer.openTagClose( 'p', false );
+		 * @example
+		 * // Writes " /&gt;".
+		 * writer.openTagClose( 'br', true );
+		 */
+		openTagClose : function( tagName, isSelfClose )
+		{
+			if ( isSelfClose )
+				this._.output.push( ' />' );
+			else
+				this._.output.push( '>' );
+		},
+
+		/**
+		 * 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 "&lt;/p&gt;".
+		 * writer.closeTag( 'p' );
+		 */
+		closeTag : function( tagName )
+		{
+			this._.output.push( '</', tagName, '>' );
+		},
+
+		/**
+		 * Writes text.
+		 * @param {String} text The text value
+		 * @example
+		 * // Writes "Hello Word".
+		 * writer.text( 'Hello Word' );
+		 */
+		text : function( text )
+		{
+			this._.output.push( text );
+		},
+
+		/**
+		 * Writes a comment.
+		 * @param {String} comment The comment text.
+		 * @example
+		 * // Writes "&lt;!-- My comment --&gt;".
+		 * writer.comment( ' My comment ' );
+		 */
+		comment : function( comment )
+		{
+			this._.output.push( '<!--', comment, '-->' );
+		},
+
+		/**
+		 * Writes any kind of data to the ouput.
+		 * @example
+		 * writer.write( 'This is an &lt;b&gt;example&lt;/b&gt;.' );
+		 */
+		write : function( data )
+		{
+			this._.output.push( data );
+		},
+
+		/**
+		 * 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;
+		}
+	}
+});