bcms_content_syncing 1.0.0

data/public/bcms/ckeditor/plugins/about/dialogs/about.js

@@ -0,0 +1,73 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.dialog.add( 'about', function( editor )
+{
+	var lang = editor.lang.about;
+
+	return {
+		title : CKEDITOR.env.ie ? lang.dlgTitle : lang.title,
+		minWidth : 390,
+		minHeight : 230,
+		contents : [
+			{
+				id : 'tab1',
+				label : '',
+				title : '',
+				expand : true,
+				padding : 0,
+				elements :
+				[
+					{
+						type : 'html',
+						html :
+							'<style type="text/css">' +
+								'.cke_about_container' +
+								'{' +
+									'color:#000 !important;' +
+									'padding:10px 10px 0;' +
+									'margin-top:5px' +
+								'}' +
+								'.cke_about_container p' +
+								'{' +
+									'margin: 0 0 10px;' +
+								'}' +
+								'.cke_about_container .cke_about_logo' +
+								'{' +
+									'height:81px;' +
+									'background-color:#fff;' +
+									'background-image:url(' + CKEDITOR.plugins.get( 'about' ).path + 'dialogs/logo_ckeditor.png);' +
+									'background-position:center; ' +
+									'background-repeat:no-repeat;' +
+									'margin-bottom:10px;' +
+								'}' +
+								'.cke_about_container a' +
+								'{' +
+									'cursor:pointer !important;' +
+									'color:blue !important;' +
+									'text-decoration:underline !important;' +
+								'}' +
+							'</style>' +
+							'<div class="cke_about_container">' +
+								'<div class="cke_about_logo"></div>' +
+								'<p>' +
+									'CKEditor ' + CKEDITOR.version + ' (revision ' + CKEDITOR.revision + ')<br>' +
+									'<a href="http://ckeditor.com/">http://ckeditor.com</a>' +
+								'</p>' +
+								'<p>' +
+									lang.moreInfo + '<br>' +
+									'<a href="http://ckeditor.com/license">http://ckeditor.com/license</a>' +
+								'</p>' +
+								'<p>' +
+									lang.copy.replace( '$1', '<a href="http://cksource.com/">CKSource</a> - Frederico Knabben' ) +
+								'</p>' +
+							'</div>'
+					}
+				]
+			}
+		],
+		buttons : [ CKEDITOR.dialog.cancelButton ]
+	};
+} );

data/public/bcms/ckeditor/plugins/about/plugin.js

@@ -0,0 +1,22 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'about',
+{
+	init : function( editor )
+	{
+		var command = editor.addCommand( 'about', new CKEDITOR.dialogCommand( 'about' ) );
+		command.modes = { wysiwyg:1, source:1 };
+		command.canUndo = false;
+
+		editor.ui.addButton( 'About',
+			{
+				label : editor.lang.about.title,
+				command : 'about'
+			});
+
+		CKEDITOR.dialog.add( 'about', this.path + 'dialogs/about.js' );
+	}
+});

data/public/bcms/ckeditor/plugins/basicstyles/plugin.js

@@ -0,0 +1,50 @@
+/*
+Copyright (c) 2003-2009, 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.getCommand( commandName ).setState( state );
+				});
+
+			editor.addCommand( commandName, new CKEDITOR.styleCommand( style ) );
+
+			editor.ui.addButton( buttonName,
+				{
+					label : buttonLabel,
+					command : commandName
+				});
+		};
+
+		var config = editor.config;
+		var 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.
+CKEDITOR.config.coreStyles_bold			= { element : 'strong', overrides : 'b' };
+CKEDITOR.config.coreStyles_italic		= { element : 'em', overrides : 'i' };
+CKEDITOR.config.coreStyles_underline	= { element : 'u' };
+CKEDITOR.config.coreStyles_strike		= { element : 'strike' };
+CKEDITOR.config.coreStyles_subscript	= { element : 'sub' };
+CKEDITOR.config.coreStyles_superscript	= { element : 'sup' };

data/public/bcms/ckeditor/plugins/blockquote/plugin.js

@@ -0,0 +1,301 @@
+/*
+Copyright (c) 2003-2009, 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,
+			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()[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;
+
+			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' ]
+	} );
+})();

data/public/bcms/ckeditor/plugins/button/plugin.js

@@ -0,0 +1,264 @@
+/*
+Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'button',
+{
+	beforeInit : function( editor )
+	{
+		editor.ui.addHandler( CKEDITOR.UI_BUTTON, CKEDITOR.ui.button.handler );
+	}
+});
+
+/**
+ * Button UI element.
+ * @constant
+ * @example
+ */
+CKEDITOR.UI_BUTTON = 1;
+
+/**
+ * Represents a button UI element. This class should not be called directly. To
+ * create new buttons use {@link CKEDITOR.ui.prototype.addButton} instead.
+ * @constructor
+ * @param {Object} definition The button definition.
+ * @example
+ */
+CKEDITOR.ui.button = function( definition )
+{
+	// Copy all definition properties to this object.
+	CKEDITOR.tools.extend( this, definition,
+		// Set defaults.
+		{
+			title		: definition.label,
+			className	: definition.className || ( definition.command && 'cke_button_' + definition.command ) || '',
+			click		: definition.click || function( editor )
+				{
+					editor.execCommand( definition.command );
+				}
+		});
+
+	this._ = {};
+};
+
+/**
+ * Transforms a button definition in a {@link CKEDITOR.ui.button} instance.
+ * @type Object
+ * @example
+ */
+CKEDITOR.ui.button.handler =
+{
+	create : function( definition )
+	{
+		return new CKEDITOR.ui.button( definition );
+	}
+};
+
+CKEDITOR.ui.button.prototype =
+{
+	canGroup : true,
+
+	/**
+	 * Renders the button.
+	 * @param {CKEDITOR.editor} editor The editor instance which this button is
+	 *		to be used by.
+	 * @param {Array} output The output array to which append the HTML relative
+	 *		to this button.
+	 * @example
+	 */
+	render : function( editor, output )
+	{
+		var env = CKEDITOR.env;
+
+		var id = this._.id = 'cke_' + CKEDITOR.tools.getNextNumber();
+		this._.editor = editor;
+
+		var instance =
+		{
+			id : id,
+			button : this,
+			editor : editor,
+			focus : function()
+			{
+				var element = CKEDITOR.document.getById( id );
+				element.focus();
+			},
+			execute : function()
+			{
+				this.button.click( editor );
+			}
+		};
+
+		var clickFn = CKEDITOR.tools.addFunction( instance.execute, instance );
+
+		var index = CKEDITOR.ui.button._.instances.push( instance ) - 1;
+
+		var classes = '';
+
+		// Get the command name.
+		var command = this.command;
+
+		if ( this.modes )
+		{
+			editor.on( 'mode', function()
+				{
+					this.setState( this.modes[ editor.mode ] ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
+				}, this);
+		}
+		else if ( command )
+		{
+			// Get the command instance.
+			command = editor.getCommand( command );
+
+			if ( command )
+			{
+				command.on( 'state', function()
+					{
+						this.setState( command.state );
+					}, this);
+
+				classes += 'cke_' + (
+					command.state == CKEDITOR.TRISTATE_ON ? 'on' :
+					command.state == CKEDITOR.TRISTATE_DISABLED ? 'disabled' :
+					'off' );
+			}
+		}
+
+		if ( !command )
+			classes	+= 'cke_off';
+
+		if ( this.className )
+			classes += ' ' + this.className;
+
+		output.push(
+			'<span class="cke_button">',
+			'<a id="', id, '"' +
+				' class="', classes, '" href="javascript:void(\'', ( this.title || '' ).replace( "'", '' ), '\')"' +
+				' title="', this.title, '"' +
+				' tabindex="-1"' +
+				' hidefocus="true"' );
+
+		// 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 ) )
+		{
+			output.push(
+				' onkeypress="return false;"' );
+		}
+
+		// With Firefox, we need to force the button to redraw, otherwise it
+		// will remain in the focus state.
+		if ( env.gecko )
+		{
+			output.push(
+				' onblur="this.style.cssText = this.style.cssText;"' );
+		}
+
+		output.push(
+				' onkeydown="return CKEDITOR.ui.button._.keydown(', index, ', event);"' +
+				' onfocus="return CKEDITOR.ui.button._.focus(', index, ', event);"' +
+				' onclick="CKEDITOR.tools.callFunction(', clickFn, ', this); return false;">' +
+					'<span class="cke_icon"' );
+
+		if ( this.icon )
+		{
+			var offset = ( this.iconOffset || 0 ) * -16;
+			output.push( ' style="background-image:url(', CKEDITOR.getUrl( this.icon ), ');background-position:0 ' + offset + 'px;"' );
+		}
+
+		output.push(
+					'></span>' +
+					'<span class="cke_label">', this.label, '</span>' );
+
+		if ( this.hasArrow )
+		{
+			output.push(
+					'<span class="cke_buttonarrow"></span>' );
+		}
+
+		output.push(
+			'</a>',
+			'</span>' );
+
+		if ( this.onRender )
+			this.onRender();
+
+		return instance;
+	},
+
+	setState : function( state )
+	{
+		if ( this._.state == state )
+			return;
+
+		var element = CKEDITOR.document.getById( this._.id );
+
+		if ( element )
+		{
+			element.setState( state );
+
+			var htmlTitle = this.title,
+				unavailable = this._.editor.lang.common.unavailable,
+				labelElement = element.getChild( 1 );
+
+			if ( state == CKEDITOR.TRISTATE_DISABLED )
+				htmlTitle = unavailable.replace( '%1', this.title );
+
+			labelElement.setHtml( htmlTitle );
+		}
+
+		this._.state = state;
+	}
+};
+
+/**
+ * Handles a button click.
+ * @private
+ */
+CKEDITOR.ui.button._ =
+{
+	instances : [],
+
+	keydown : function( index, ev )
+	{
+		var instance = CKEDITOR.ui.button._.instances[ index ];
+
+		if ( instance.onkey )
+		{
+			ev = new CKEDITOR.dom.event( ev );
+			return ( instance.onkey( instance, ev.getKeystroke() ) !== false );
+		}
+	},
+
+	focus : function( index, ev )
+	{
+		var instance = CKEDITOR.ui.button._.instances[ index ],
+			retVal;
+
+		if ( instance.onfocus )
+			retVal = ( instance.onfocus( instance, new CKEDITOR.dom.event( ev ) ) !== false );
+
+		// FF2: prevent focus event been bubbled up to editor container, which caused unexpected editor focus.
+		if ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 )
+			ev.preventBubble();
+		return retVal;
+	}
+};
+
+/**
+ * Adds a button definition to the UI elements list.
+ * @param {String} The button name.
+ * @param {Object} The button definition.
+ * @example
+ * editorInstance.ui.addButton( 'MyBold',
+ *     {
+ *         label : 'My Bold',
+ *         command : 'bold'
+ *     });
+ */
+CKEDITOR.ui.prototype.addButton = function( name, definition )
+{
+	this.add( name, CKEDITOR.UI_BUTTON, definition );
+};