ppc_logic 0.8.0

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

@@ -0,0 +1,94 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'menubutton',
+{
+	requires : [ 'button', 'contextmenu' ],
+	beforeInit : function( editor )
+	{
+		editor.ui.addHandler( CKEDITOR.UI_MENUBUTTON, CKEDITOR.ui.menuButton.handler );
+	}
+});
+
+/**
+ * Button UI element.
+ * @constant
+ * @example
+ */
+CKEDITOR.UI_MENUBUTTON = 5;
+
+(function()
+{
+	var clickFn = function( editor )
+	{
+		var _ = this._;
+
+		// Do nothing if this button is disabled.
+		if ( _.state === CKEDITOR.TRISTATE_DISABLED )
+			return;
+
+		_.previousState = _.state;
+
+		// Check if we already have a menu for it, otherwise just create it.
+		var menu = _.menu;
+		if ( !menu )
+		{
+			menu = _.menu = new CKEDITOR.plugins.contextMenu( editor );
+			menu.definition.panel.attributes[ 'aria-label' ] = editor.lang.common.options;
+
+			menu.onHide = CKEDITOR.tools.bind( function()
+				{
+					this.setState( _.previousState );
+				},
+				this );
+
+			// Initialize the menu items at this point.
+			if ( this.onMenu )
+			{
+				menu.addListener( this.onMenu );
+			}
+		}
+
+		if ( _.on )
+		{
+			menu.hide();
+			return;
+		}
+
+		this.setState( CKEDITOR.TRISTATE_ON );
+
+		menu.show( CKEDITOR.document.getById( this._.id ), 4 );
+	};
+
+
+	CKEDITOR.ui.menuButton = CKEDITOR.tools.createClass(
+	{
+		base : CKEDITOR.ui.button,
+
+		$ : function( definition )
+		{
+			// We don't want the panel definition in this object.
+			var panelDefinition = definition.panel;
+			delete definition.panel;
+
+			this.base( definition );
+
+			this.hasArrow = true;
+
+			this.click = clickFn;
+		},
+
+		statics :
+		{
+			handler :
+			{
+				create : function( definition )
+				{
+					return new CKEDITOR.ui.menuButton( definition );
+				}
+			}
+		}
+	});
+})();

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

@@ -0,0 +1,53 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Horizontal Page Break
+ */
+
+// Register a plugin named "newpage".
+CKEDITOR.plugins.add( 'newpage',
+{
+	init : function( editor )
+	{
+		editor.addCommand( 'newpage',
+			{
+				modes : { wysiwyg:1, source:1 },
+
+				exec : function( editor )
+				{
+					var command = this;
+					editor.setData( editor.config.newpage_html || '', function()
+					{
+						// Save the undo snapshot after all document changes are affected. (#4889)
+						setTimeout( function ()
+						{
+							editor.fire( 'afterCommandExec',
+							{
+								name: command.name,
+								command: command
+							} );
+
+						}, 200 );
+					} );
+					editor.focus();
+				},
+				async : true
+			});
+
+		editor.ui.addButton( 'NewPage',
+			{
+				label : editor.lang.newPage,
+				command : 'newpage'
+			});
+	}
+});
+/**
+ * The HTML to load in the editor when the "new page" command is executed.
+ * @type String
+ * @default ''
+ * @example
+ * config.newpage_html = '<p>Type your text here.</p>';
+ */

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

@@ -0,0 +1,121 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Horizontal Page Break
+ */
+
+// Register a plugin named "pagebreak".
+CKEDITOR.plugins.add( 'pagebreak',
+{
+	init : function( editor )
+	{
+		// Register the command.
+		editor.addCommand( 'pagebreak', CKEDITOR.plugins.pagebreakCmd );
+
+		// Register the toolbar button.
+		editor.ui.addButton( 'PageBreak',
+			{
+				label : editor.lang.pagebreak,
+				command : 'pagebreak'
+			});
+
+		// Add the style that renders our placeholder.
+		editor.addCss(
+			'img.cke_pagebreak' +
+			'{' +
+				'background-image: url(' + CKEDITOR.getUrl( this.path + 'images/pagebreak.gif' ) + ');' +
+				'background-position: center center;' +
+				'background-repeat: no-repeat;' +
+				'clear: both;' +
+				'display: block;' +
+				'float: none;' +
+				'width:100% !important; _width:99.9% !important;' +
+				'border-top: #999999 1px dotted;' +
+				'border-bottom: #999999 1px dotted;' +
+				'height: 5px !important;' +
+				'page-break-after: always;' +
+
+			'}' );
+	},
+
+	afterInit : function( editor )
+	{
+		// Register a filter to displaying placeholders after mode change.
+
+		var dataProcessor = editor.dataProcessor,
+			dataFilter = dataProcessor && dataProcessor.dataFilter;
+
+		if ( dataFilter )
+		{
+			dataFilter.addRules(
+				{
+					elements :
+					{
+						div : function( element )
+						{
+							var attributes = element.attributes,
+								style = attributes && attributes.style,
+								child = style && element.children.length == 1 && element.children[ 0 ],
+								childStyle = child && ( child.name == 'span' ) && child.attributes.style;
+
+							if ( childStyle && ( /page-break-after\s*:\s*always/i ).test( style ) && ( /display\s*:\s*none/i ).test( childStyle ) )
+							{
+								var fakeImg = editor.createFakeParserElement( element, 'cke_pagebreak', 'div' );
+								var label = editor.lang.pagebreakAlt;
+								fakeImg.attributes[ 'alt' ] = label;
+								fakeImg.attributes[ 'aria-label' ] = label;
+								return fakeImg;
+							}
+						}
+					}
+				});
+		}
+	},
+
+	requires : [ 'fakeobjects' ]
+});
+
+CKEDITOR.plugins.pagebreakCmd =
+{
+	exec : function( editor )
+	{
+		// Create the element that represents a print break.
+		var label = editor.lang.pagebreakAlt;
+		var breakObject = CKEDITOR.dom.element.createFromHtml( '<div style="page-break-after: always;"><span style="display: none;">&nbsp;</span></div>' );
+
+		// Creates the fake image used for this element.
+		breakObject = editor.createFakeElement( breakObject, 'cke_pagebreak', 'div' );
+		breakObject.setAttribute( 'alt', label );
+		breakObject.setAttribute( 'aria-label', label );
+
+		var ranges = editor.getSelection().getRanges( true );
+
+		editor.fire( 'saveSnapshot' );
+
+		for ( var range, i = ranges.length - 1 ; i >= 0; i-- )
+		{
+			range = ranges[ i ];
+
+			if ( i < ranges.length -1 )
+				breakObject = breakObject.clone( true );
+
+			range.splitBlock( 'p' );
+			range.insertNode( breakObject );
+			if ( i == ranges.length - 1 )
+			{
+				range.moveToPosition( breakObject, CKEDITOR.POSITION_AFTER_END );
+				range.select();
+			}
+
+			var previous = breakObject.getPrevious();
+
+			if ( previous && CKEDITOR.dtd[ previous.getName() ].div )
+				breakObject.move( previous );
+		}
+
+		editor.fire( 'saveSnapshot' );
+	}
+};

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

@@ -0,0 +1,399 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'panel',
+{
+	beforeInit : function( editor )
+	{
+		editor.ui.addHandler( CKEDITOR.UI_PANEL, CKEDITOR.ui.panel.handler );
+	}
+});
+
+/**
+ * Panel UI element.
+ * @constant
+ * @example
+ */
+CKEDITOR.UI_PANEL = 2;
+
+CKEDITOR.ui.panel = function( document, definition )
+{
+	// Copy all definition properties to this object.
+	if ( definition )
+		CKEDITOR.tools.extend( this, definition );
+
+	// Set defaults.
+	CKEDITOR.tools.extend( this,
+		{
+			className : '',
+			css : []
+		});
+
+	this.id = CKEDITOR.tools.getNextId();
+	this.document = document;
+
+	this._ =
+	{
+		blocks : {}
+	};
+};
+
+/**
+ * Transforms a rich combo definition in a {@link CKEDITOR.ui.richCombo}
+ * instance.
+ * @type Object
+ * @example
+ */
+CKEDITOR.ui.panel.handler =
+{
+	create : function( definition )
+	{
+		return new CKEDITOR.ui.panel( definition );
+	}
+};
+
+CKEDITOR.ui.panel.prototype =
+{
+	renderHtml : function( editor )
+	{
+		var output = [];
+		this.render( editor, output );
+		return output.join( '' );
+	},
+
+	/**
+	 * Renders the combo.
+	 * @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 id = this.id;
+
+		output.push(
+			'<div class="', editor.skinClass ,'"' +
+				' lang="', editor.langCode, '"' +
+				' role="presentation"' +
+				// iframe loading need sometime, keep the panel hidden(#4186).
+				' style="display:none;z-index:' + ( editor.config.baseFloatZIndex + 1 ) + '">' +
+				'<div' +
+					' id=', id,
+					' dir=', editor.lang.dir,
+					' role="presentation"' +
+					' class="cke_panel cke_', editor.lang.dir );
+
+		if ( this.className )
+			output.push( ' ', this.className );
+
+		output.push(
+				'">' );
+
+		if ( this.forceIFrame || this.css.length )
+		{
+			output.push(
+						'<iframe id="', id, '_frame"' +
+							' frameborder="0"' +
+							' role="application" src="javascript:void(' );
+
+			output.push(
+							// Support for custom document.domain in IE.
+							CKEDITOR.env.isCustomDomain() ?
+								'(function(){' +
+									'document.open();' +
+									'document.domain=\'' + document.domain + '\';' +
+									'document.close();' +
+								'})()'
+							:
+								'0' );
+
+			output.push(
+						')"></iframe>' );
+		}
+
+		output.push(
+				'</div>' +
+			'</div>' );
+
+		return id;
+	},
+
+	getHolderElement : function()
+	{
+		var holder = this._.holder;
+
+		if ( !holder )
+		{
+			if ( this.forceIFrame || this.css.length )
+			{
+				var iframe = this.document.getById( this.id + '_frame' ),
+					parentDiv = iframe.getParent(),
+					dir = parentDiv.getAttribute( 'dir' ),
+					className = parentDiv.getParent().getAttribute( 'class' ),
+					langCode = parentDiv.getParent().getAttribute( 'lang' ),
+					doc = iframe.getFrameDocument();
+				// Initialize the IFRAME document body.
+				doc.$.open();
+
+				// Support for custom document.domain in IE.
+				if ( CKEDITOR.env.isCustomDomain() )
+					doc.$.domain = document.domain;
+
+				var onLoad = CKEDITOR.tools.addFunction( CKEDITOR.tools.bind( function( ev )
+					{
+						this.isLoaded = true;
+						if ( this.onLoad )
+							this.onLoad();
+					}, this ) );
+
+				doc.$.write(
+					'<!DOCTYPE html>' +
+					'<html dir="' + dir + '" class="' + className + '_container" lang="' + langCode + '">' +
+						'<head>' +
+							'<style>.' + className + '_container{visibility:hidden}</style>' +
+						'</head>' +
+						'<body class="cke_' + dir + ' cke_panel_frame ' + CKEDITOR.env.cssClass + '" style="margin:0;padding:0"' +
+						' onload="( window.CKEDITOR || window.parent.CKEDITOR ).tools.callFunction(' + onLoad + ');"></body>' +
+						// It looks strange, but for FF2, the styles must go
+						// after <body>, so it (body) becames immediatelly
+						// available. (#3031)
+						CKEDITOR.tools.buildStyleHtml( this.css ) +
+					'<\/html>' );
+				doc.$.close();
+
+				var win = doc.getWindow();
+
+				// Register the CKEDITOR global.
+				win.$.CKEDITOR = CKEDITOR;
+
+				// Arrow keys for scrolling is only preventable with 'keypress' event in Opera (#4534).
+				doc.on( 'key' + ( CKEDITOR.env.opera? 'press':'down' ), function( evt )
+					{
+						var keystroke = evt.data.getKeystroke(),
+							dir = this.document.getById( this.id ).getAttribute( 'dir' );
+
+						// Delegate key processing to block.
+						if ( this._.onKeyDown && this._.onKeyDown( keystroke ) === false )
+						{
+							evt.data.preventDefault();
+							return;
+						}
+
+						// ESC/ARROW-LEFT(ltr) OR ARROW-RIGHT(rtl)
+						if ( keystroke == 27 || keystroke == ( dir == 'rtl' ? 39 : 37 ) )
+						{
+							if ( this.onEscape && this.onEscape( keystroke ) === false )
+								evt.data.preventDefault();
+						}
+					},
+					this );
+
+				holder = doc.getBody();
+				holder.unselectable();
+			}
+			else
+				holder = this.document.getById( this.id );
+
+			this._.holder = holder;
+		}
+
+		return holder;
+	},
+
+	addBlock : function( name, block )
+	{
+		block = this._.blocks[ name ] = block instanceof CKEDITOR.ui.panel.block ?  block
+				: new CKEDITOR.ui.panel.block( this.getHolderElement(), block );
+
+		if ( !this._.currentBlock )
+			this.showBlock( name );
+
+		return block;
+	},
+
+	getBlock : function( name )
+	{
+		return this._.blocks[ name ];
+	},
+
+	showBlock : function( name )
+	{
+		var blocks = this._.blocks,
+			block = blocks[ name ],
+			current = this._.currentBlock,
+			holder = this.forceIFrame ?
+				this.document.getById( this.id + '_frame' )
+				: this._.holder;
+
+		// Disable context menu for block panel.
+		holder.getParent().getParent().disableContextMenu();
+
+		if ( current )
+		{
+			// Clean up the current block's effects on holder.
+			holder.removeAttributes( current.attributes );
+			current.hide();
+		}
+
+		this._.currentBlock = block;
+
+		holder.setAttributes( block.attributes );
+		CKEDITOR.fire( 'ariaWidget', holder );
+
+		// Reset the focus index, so it will always go into the first one.
+		block._.focusIndex = -1;
+
+		this._.onKeyDown = block.onKeyDown && CKEDITOR.tools.bind( block.onKeyDown, block );
+
+		block.onMark = function( item )
+		{
+			holder.setAttribute( 'aria-activedescendant', item.getId() + '_option' );
+		};
+
+		block.onUnmark = function()
+		{
+			holder.removeAttribute( 'aria-activedescendant' );
+		};
+
+		block.show();
+
+		return block;
+	},
+
+	destroy : function()
+	{
+		this.element && this.element.remove();
+	}
+};
+
+CKEDITOR.ui.panel.block = CKEDITOR.tools.createClass(
+{
+	$ : function( blockHolder, blockDefinition )
+	{
+		this.element = blockHolder.append(
+			blockHolder.getDocument().createElement( 'div',
+				{
+					attributes :
+					{
+						'tabIndex' : -1,
+						'class' : 'cke_panel_block',
+						'role' : 'presentation'
+					},
+					styles :
+					{
+						display : 'none'
+					}
+				}) );
+
+		// Copy all definition properties to this object.
+		if ( blockDefinition )
+			CKEDITOR.tools.extend( this, blockDefinition );
+
+		if ( !this.attributes.title )
+			this.attributes.title = this.attributes[ 'aria-label' ];
+
+		this.keys = {};
+
+		this._.focusIndex = -1;
+
+		// Disable context menu for panels.
+		this.element.disableContextMenu();
+	},
+
+	_ : {
+
+		/**
+		 * Mark the item specified by the index as current activated.
+		 */
+		markItem: function( index )
+		{
+			if ( index == -1 )
+				return;
+			var links = this.element.getElementsByTag( 'a' );
+			var item = links.getItem( this._.focusIndex = index );
+
+			// Safari need focus on the iframe window first(#3389), but we need
+			// lock the blur to avoid hiding the panel.
+			if ( CKEDITOR.env.webkit || CKEDITOR.env.opera )
+				item.getDocument().getWindow().focus();
+			item.focus();
+
+			this.onMark && this.onMark( item );
+		}
+	},
+
+	proto :
+	{
+		show : function()
+		{
+			this.element.setStyle( 'display', '' );
+		},
+
+		hide : function()
+		{
+			if ( !this.onHide || this.onHide.call( this )  !== true )
+				this.element.setStyle( 'display', 'none' );
+		},
+
+		onKeyDown : function( keystroke )
+		{
+			var keyAction = this.keys[ keystroke ];
+			switch ( keyAction )
+			{
+				// Move forward.
+				case 'next' :
+					var index = this._.focusIndex,
+						links = this.element.getElementsByTag( 'a' ),
+						link;
+
+					while ( ( link = links.getItem( ++index ) ) )
+					{
+						// Move the focus only if the element is marked with
+						// the _cke_focus and it it's visible (check if it has
+						// width).
+						if ( link.getAttribute( '_cke_focus' ) && link.$.offsetWidth )
+						{
+							this._.focusIndex = index;
+							link.focus();
+							break;
+						}
+					}
+					return false;
+
+				// Move backward.
+				case 'prev' :
+					index = this._.focusIndex;
+					links = this.element.getElementsByTag( 'a' );
+
+					while ( index > 0 && ( link = links.getItem( --index ) ) )
+					{
+						// Move the focus only if the element is marked with
+						// the _cke_focus and it it's visible (check if it has
+						// width).
+						if ( link.getAttribute( '_cke_focus' ) && link.$.offsetWidth )
+						{
+							this._.focusIndex = index;
+							link.focus();
+							break;
+						}
+					}
+					return false;
+
+				case 'click' :
+					index = this._.focusIndex;
+					link = index >= 0 && this.element.getElementsByTag( 'a' ).getItem( index );
+
+					if ( link )
+						link.$.click ? link.$.click() : link.$.onclick();
+
+					return false;
+			}
+
+			return true;
+		}
+	}
+});