, specially in IE. Do not enter in this if block in this case.
+ else if ( tagName == currentName )
+ {
+ addElement( currentNode, currentNode.parent );
+ }
+ else
+ {
+ if ( nonBreakingBlocks[ currentName ] )
+ {
+ if ( !returnPoint )
+ returnPoint = currentNode;
+ }
+ else
+ {
+ addElement( currentNode, currentNode.parent, true );
+
+ if ( !optionalClose[ currentName ] )
+ {
+ // The current element is an inline element, which
+ // cannot hold the new one. Put it in the pending list,
+ // and try adding the new one after it.
+ pendingInline.unshift( currentNode );
+ }
+ }
+
+ reApply = true;
+ }
+
+ if ( addPoint )
+ currentNode = addPoint;
+ // Try adding it to the return point, or the parent element.
+ else
+ currentNode = currentNode.returnPoint || currentNode.parent;
+
+ if ( reApply )
+ {
+ parser.onTagOpen.apply( this, arguments );
+ return;
+ }
+ }
+
+ checkPending( tagName );
+ sendPendingBRs();
+
+ element.parent = currentNode;
+ element.returnPoint = returnPoint;
+ returnPoint = 0;
+
+ if ( element.isEmpty )
+ addElement( element );
+ else
+ currentNode = element;
+ };
+
+ parser.onTagClose = function( tagName )
+ {
+ // Check if there is any pending tag to be closed.
+ for ( var i = pendingInline.length - 1 ; i >= 0 ; i-- )
+ {
+ // If found, just remove it from the list.
+ if ( tagName == pendingInline[ i ].name )
+ {
+ pendingInline.splice( i, 1 );
+ return;
+ }
+ }
+
+ var pendingAdd = [],
+ newPendingInline = [],
+ candidate = currentNode;
+
+ while ( candidate.type && candidate.name != tagName )
+ {
+ // If this is an inline element, add it to the pending list, if we're
+ // really closing one of the parents element later, they will continue
+ // after it.
+ if ( !candidate._.isBlockLike )
+ newPendingInline.unshift( candidate );
+
+ // This node should be added to it's parent at this point. But,
+ // it should happen only if the closing tag is really closing
+ // one of the nodes. So, for now, we just cache it.
+ pendingAdd.push( candidate );
+
+ candidate = candidate.parent;
+ }
+
+ if ( candidate.type )
+ {
+ // Add all elements that have been found in the above loop.
+ for ( i = 0 ; i < pendingAdd.length ; i++ )
+ {
+ var node = pendingAdd[ i ];
+ addElement( node, node.parent );
+ }
+
+ currentNode = candidate;
+
+ if ( currentNode.name == 'pre' )
+ inPre = false;
+
+ if ( candidate._.isBlockLike )
+ sendPendingBRs();
+
+ addElement( candidate, candidate.parent );
+
+ // The parent should start receiving new nodes now, except if
+ // addElement changed the currentNode.
+ if ( candidate == currentNode )
+ currentNode = currentNode.parent;
+
+ pendingInline = pendingInline.concat( newPendingInline );
+ }
+
+ if ( tagName == 'body' )
+ fixForBody = false;
+ };
+
+ parser.onText = function( text )
+ {
+ // Trim empty spaces at beginning of element contents except .
+ if ( !currentNode._.hasInlineStarted && !inPre )
+ {
+ text = CKEDITOR.tools.ltrim( text );
+
+ if ( text.length === 0 )
+ return;
+ }
+
+ sendPendingBRs();
+ checkPending();
+
+ if ( fixForBody
+ && ( !currentNode.type || currentNode.name == 'body' )
+ && CKEDITOR.tools.trim( text ) )
+ {
+ this.onTagOpen( fixForBody, {} );
+ }
+
+ // Shrinking consequential spaces into one single for all elements
+ // text contents.
+ if ( !inPre )
+ text = text.replace( /[\t\r\n ]{2,}|[\t\r\n]/g, ' ' );
+
+ currentNode.add( new CKEDITOR.htmlParser.text( text ) );
+ };
+
+ parser.onCDATA = function( cdata )
+ {
+ currentNode.add( new CKEDITOR.htmlParser.cdata( cdata ) );
+ };
+
+ parser.onComment = function( comment )
+ {
+ currentNode.add( new CKEDITOR.htmlParser.comment( comment ) );
+ };
+
+ // Parse it.
+ parser.parse( fragmentHtml );
+
+ sendPendingBRs();
+
+ // Close all pending nodes.
+ while ( currentNode.type )
+ {
+ var parent = currentNode.parent,
+ node = currentNode;
+
+ if ( fixForBody
+ && ( !parent.type || parent.name == 'body' )
+ && !CKEDITOR.dtd.$body[ node.name ] )
+ {
+ currentNode = parent;
+ parser.onTagOpen( fixForBody, {} );
+ parent = currentNode;
+ }
+
+ parent.add( node );
+ currentNode = parent;
+ }
+
+ return fragment;
+ };
+
+ CKEDITOR.htmlParser.fragment.prototype =
+ {
+ /**
+ * Adds a node to this fragment.
+ * @param {Object} node The node to be added. It can be any of of the
+ * following types: {@link CKEDITOR.htmlParser.element},
+ * {@link CKEDITOR.htmlParser.text} and
+ * {@link CKEDITOR.htmlParser.comment}.
+ * @example
+ */
+ add : function( node )
+ {
+ var len = this.children.length,
+ previous = len > 0 && this.children[ len - 1 ] || null;
+
+ if ( previous )
+ {
+ // If the block to be appended is following text, trim spaces at
+ // the right of it.
+ if ( node._.isBlockLike && previous.type == CKEDITOR.NODE_TEXT )
+ {
+ previous.value = CKEDITOR.tools.rtrim( previous.value );
+
+ // If we have completely cleared the previous node.
+ if ( previous.value.length === 0 )
+ {
+ // Remove it from the list and add the node again.
+ this.children.pop();
+ this.add( node );
+ return;
+ }
+ }
+
+ previous.next = node;
+ }
+
+ node.previous = previous;
+ node.parent = this;
+
+ this.children.push( node );
+
+ this._.hasInlineStarted = node.type == CKEDITOR.NODE_TEXT || ( node.type == CKEDITOR.NODE_ELEMENT && !node._.isBlockLike );
+ },
+
+ /**
+ * Writes the fragment HTML to a CKEDITOR.htmlWriter.
+ * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+ * @example
+ * var writer = new CKEDITOR.htmlWriter();
+ * var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<P><B>Example' );
+ * fragment.writeHtml( writer )
+ * alert( writer.getHtml() ); "<p><b>Example</b></p>"
+ */
+ writeHtml : function( writer, filter )
+ {
+ var isChildrenFiltered;
+ this.filterChildren = function()
+ {
+ var writer = new CKEDITOR.htmlParser.basicWriter();
+ this.writeChildrenHtml.call( this, writer, filter, true );
+ var html = writer.getHtml();
+ this.children = new CKEDITOR.htmlParser.fragment.fromHtml( html ).children;
+ isChildrenFiltered = 1;
+ };
+
+ // Filtering the root fragment before anything else.
+ !this.name && filter && filter.onFragment( this );
+
+ this.writeChildrenHtml( writer, isChildrenFiltered ? null : filter );
+ },
+
+ writeChildrenHtml : function( writer, filter )
+ {
+ for ( var i = 0 ; i < this.children.length ; i++ )
+ this.children[i].writeHtml( writer, filter );
+ }
+ };
+})();
diff --git a/include/ckeditor/_source/core/htmlparser/text.js b/include/ckeditor/_source/core/htmlparser/text.js
new file mode 100644
index 0000000..ad4ed1f
--- /dev/null
+++ b/include/ckeditor/_source/core/htmlparser/text.js
@@ -0,0 +1,55 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+ var spacesRegex = /[\t\r\n ]{2,}|[\t\r\n]/g;
+
+ /**
+ * A lightweight representation of HTML text.
+ * @constructor
+ * @example
+ */
+ CKEDITOR.htmlParser.text = function( value )
+ {
+ /**
+ * The text value.
+ * @type String
+ * @example
+ */
+ this.value = value;
+
+ /** @private */
+ this._ =
+ {
+ isBlockLike : false
+ };
+ };
+
+ CKEDITOR.htmlParser.text.prototype =
+ {
+ /**
+ * The node type. This is a constant value set to {@link CKEDITOR.NODE_TEXT}.
+ * @type Number
+ * @example
+ */
+ type : CKEDITOR.NODE_TEXT,
+
+ /**
+ * Writes the HTML representation of this text to a CKEDITOR.htmlWriter.
+ * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+ * @example
+ */
+ writeHtml : function( writer, filter )
+ {
+ var text = this.value;
+
+ if ( filter && !( text = filter.onText( text, this ) ) )
+ return;
+
+ writer.text( text );
+ }
+ };
+})();
diff --git a/include/ckeditor/_source/core/imagecacher.js b/include/ckeditor/_source/core/imagecacher.js
new file mode 100644
index 0000000..64dd124
--- /dev/null
+++ b/include/ckeditor/_source/core/imagecacher.js
@@ -0,0 +1,59 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+ var loaded = {};
+
+ var loadImage = function( image, callback )
+ {
+ var doCallback = function()
+ {
+ img.removeAllListeners();
+ loaded[ image ] = 1;
+ callback();
+ };
+
+ var img = new CKEDITOR.dom.element( 'img' );
+ img.on( 'load', doCallback );
+ img.on( 'error', doCallback );
+ img.setAttribute( 'src', image );
+ };
+
+ /**
+ * Load images into the browser cache.
+ * @namespace
+ * @example
+ */
+ CKEDITOR.imageCacher =
+ {
+ /**
+ * Loads one or more images.
+ * @param {Array} images The URLs for the images to be loaded.
+ * @param {Function} callback The function to be called once all images
+ * are loaded.
+ */
+ load : function( images, callback )
+ {
+ var pendingCount = images.length;
+
+ var checkPending = function()
+ {
+ if ( --pendingCount === 0 )
+ callback();
+ };
+
+ for ( var i = 0 ; i < images.length ; i++ )
+ {
+ var image = images[ i ];
+
+ if ( loaded[ image ] )
+ checkPending();
+ else
+ loadImage( image, checkPending );
+ }
+ }
+ };
+})();
diff --git a/include/ckeditor/_source/core/lang.js b/include/ckeditor/_source/core/lang.js
new file mode 100644
index 0000000..5519668
--- /dev/null
+++ b/include/ckeditor/_source/core/lang.js
@@ -0,0 +1,152 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+ var loadedLangs = {};
+
+ CKEDITOR.lang =
+ {
+ /**
+ * The list of languages available in the editor core.
+ * @type Object
+ * @example
+ * alert( CKEDITOR.lang.en ); // "true"
+ */
+ languages :
+ {
+ 'af' : 1,
+ 'ar' : 1,
+ 'bg' : 1,
+ 'bn' : 1,
+ 'bs' : 1,
+ 'ca' : 1,
+ 'cs' : 1,
+ 'cy' : 1,
+ 'da' : 1,
+ 'de' : 1,
+ 'el' : 1,
+ 'en-au' : 1,
+ 'en-ca' : 1,
+ 'en-gb' : 1,
+ 'en' : 1,
+ 'eo' : 1,
+ 'es' : 1,
+ 'et' : 1,
+ 'eu' : 1,
+ 'fa' : 1,
+ 'fi' : 1,
+ 'fo' : 1,
+ 'fr-ca' : 1,
+ 'fr' : 1,
+ 'gl' : 1,
+ 'gu' : 1,
+ 'he' : 1,
+ 'hi' : 1,
+ 'hr' : 1,
+ 'hu' : 1,
+ 'is' : 1,
+ 'it' : 1,
+ 'ja' : 1,
+ 'km' : 1,
+ 'ko' : 1,
+ 'lt' : 1,
+ 'lv' : 1,
+ 'mn' : 1,
+ 'ms' : 1,
+ 'nb' : 1,
+ 'nl' : 1,
+ 'no' : 1,
+ 'pl' : 1,
+ 'pt-br' : 1,
+ 'pt' : 1,
+ 'ro' : 1,
+ 'ru' : 1,
+ 'sk' : 1,
+ 'sl' : 1,
+ 'sr-latn' : 1,
+ 'sr' : 1,
+ 'sv' : 1,
+ 'th' : 1,
+ 'tr' : 1,
+ 'uk' : 1,
+ 'vi' : 1,
+ 'zh-cn' : 1,
+ 'zh' : 1
+ },
+
+ /**
+ * Loads a specific language file, or auto detect it. A callback is
+ * then called when the file gets loaded.
+ * @param {String} languageCode The code of the language file to be
+ * loaded. If "autoDetect" is set to true, this language will be
+ * used as the default one, if the detect language is not
+ * available in the core.
+ * @param {Boolean} autoDetect Indicates that the function must try to
+ * detect the user language and load it instead.
+ * @param {Function} callback The function to be called once the
+ * language file is loaded. Two parameters are passed to this
+ * function: the language code and the loaded language entries.
+ * @example
+ */
+ load : function( languageCode, defaultLanguage, callback )
+ {
+ // If no languageCode - fallback to browser or default.
+ // If languageCode - fallback to no-localized version or default.
+ if ( !languageCode || !CKEDITOR.lang.languages[ languageCode ] )
+ languageCode = this.detect( defaultLanguage, languageCode );
+
+ if ( !this[ languageCode ] )
+ {
+ CKEDITOR.scriptLoader.load( CKEDITOR.getUrl(
+ '_source/' + // @Packager.RemoveLine
+ 'lang/' + languageCode + '.js' ),
+ function()
+ {
+ callback( languageCode, this[ languageCode ] );
+ }
+ , this );
+ }
+ else
+ callback( languageCode, this[ languageCode ] );
+ },
+
+ /**
+ * Returns the language that best fit the user language. For example,
+ * suppose that the user language is "pt-br". If this language is
+ * supported by the editor, it is returned. Otherwise, if only "pt" is
+ * supported, it is returned instead. If none of the previous are
+ * supported, a default language is then returned.
+ * @param {String} defaultLanguage The default language to be returned
+ * if the user language is not supported.
+ * @returns {String} The detected language code.
+ * @example
+ * alert( CKEDITOR.lang.detect( 'en' ) ); // e.g., in a German browser: "de"
+ */
+ detect : function( defaultLanguage, probeLanguage )
+ {
+ var languages = this.languages;
+ probeLanguage = probeLanguage || navigator.userLanguage || navigator.language;
+
+ var parts = probeLanguage
+ .toLowerCase()
+ .match( /([a-z]+)(?:-([a-z]+))?/ ),
+ lang = parts[1],
+ locale = parts[2];
+
+ if ( languages[ lang + '-' + locale ] )
+ lang = lang + '-' + locale;
+ else if ( !languages[ lang ] )
+ lang = null;
+
+ CKEDITOR.lang.detect = lang ?
+ function() { return lang; } :
+ function( defaultLanguage ) { return defaultLanguage; };
+
+ return lang || defaultLanguage;
+ }
+ };
+
+})();
diff --git a/include/ckeditor/_source/core/loader.js b/include/ckeditor/_source/core/loader.js
new file mode 100644
index 0000000..88c4fb4
--- /dev/null
+++ b/include/ckeditor/_source/core/loader.js
@@ -0,0 +1,242 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.loader} objects, which is used to
+ * load core scripts and their dependencies from _source.
+ */
+
+if ( typeof CKEDITOR == 'undefined' )
+ CKEDITOR = {};
+
+if ( !CKEDITOR.loader )
+{
+ /**
+ * Load core scripts and their dependencies from _source.
+ * @namespace
+ * @example
+ */
+ CKEDITOR.loader = (function()
+ {
+ // Table of script names and their dependencies.
+ var scripts =
+ {
+ 'core/_bootstrap' : [ 'core/config', 'core/ckeditor', 'core/plugins', 'core/scriptloader', 'core/tools', /* The following are entries that we want to force loading at the end to avoid dependence recursion */ 'core/dom/comment', 'core/dom/elementpath', 'core/dom/text', 'core/dom/range' ],
+ 'core/ajax' : [ 'core/xml' ],
+ 'core/ckeditor' : [ 'core/ckeditor_basic', 'core/dom', 'core/dtd', 'core/dom/document', 'core/dom/element', 'core/editor', 'core/event', 'core/htmlparser', 'core/htmlparser/element', 'core/htmlparser/fragment', 'core/htmlparser/filter', 'core/htmlparser/basicwriter', 'core/tools' ],
+ 'core/ckeditor_base' : [],
+ 'core/ckeditor_basic' : [ 'core/editor_basic', 'core/env', 'core/event' ],
+ 'core/command' : [],
+ 'core/config' : [ 'core/ckeditor_base' ],
+ 'core/dom' : [],
+ 'core/dom/comment' : [ 'core/dom/node' ],
+ 'core/dom/document' : [ 'core/dom', 'core/dom/domobject', 'core/dom/window' ],
+ 'core/dom/documentfragment' : [ 'core/dom/element' ],
+ 'core/dom/element' : [ 'core/dom', 'core/dom/document', 'core/dom/domobject', 'core/dom/node', 'core/dom/nodelist', 'core/tools' ],
+ 'core/dom/elementpath' : [ 'core/dom/element' ],
+ 'core/dom/event' : [],
+ 'core/dom/node' : [ 'core/dom/domobject', 'core/tools' ],
+ 'core/dom/nodelist' : [ 'core/dom/node' ],
+ 'core/dom/domobject' : [ 'core/dom/event' ],
+ 'core/dom/range' : [ 'core/dom/document', 'core/dom/documentfragment', 'core/dom/element', 'core/dom/walker' ],
+ 'core/dom/text' : [ 'core/dom/node', 'core/dom/domobject' ],
+ 'core/dom/walker' : [ 'core/dom/node' ],
+ 'core/dom/window' : [ 'core/dom/domobject' ],
+ 'core/dtd' : [ 'core/tools' ],
+ 'core/editor' : [ 'core/command', 'core/config', 'core/editor_basic', 'core/focusmanager', 'core/lang', 'core/plugins', 'core/skins', 'core/themes', 'core/tools', 'core/ui' ],
+ 'core/editor_basic' : [ 'core/event' ],
+ 'core/env' : [],
+ 'core/event' : [],
+ 'core/focusmanager' : [],
+ 'core/htmlparser' : [],
+ 'core/htmlparser/comment' : [ 'core/htmlparser' ],
+ 'core/htmlparser/element' : [ 'core/htmlparser', 'core/htmlparser/fragment' ],
+ 'core/htmlparser/fragment' : [ 'core/htmlparser', 'core/htmlparser/comment', 'core/htmlparser/text', 'core/htmlparser/cdata' ],
+ 'core/htmlparser/text' : [ 'core/htmlparser' ],
+ 'core/htmlparser/cdata' : [ 'core/htmlparser' ],
+ 'core/htmlparser/filter' : [ 'core/htmlparser' ],
+ 'core/htmlparser/basicwriter': [ 'core/htmlparser' ],
+ 'core/imagecacher' : [ 'core/dom/element' ],
+ 'core/lang' : [],
+ 'core/plugins' : [ 'core/resourcemanager' ],
+ 'core/resourcemanager' : [ 'core/scriptloader', 'core/tools' ],
+ 'core/scriptloader' : [ 'core/dom/element', 'core/env' ],
+ 'core/skins' : [ 'core/imagecacher', 'core/scriptloader' ],
+ 'core/themes' : [ 'core/resourcemanager' ],
+ 'core/tools' : [ 'core/env' ],
+ 'core/ui' : [],
+ 'core/xml' : [ 'core/env' ]
+ };
+
+ var basePath = (function()
+ {
+ // This is a copy of CKEDITOR.basePath, but requires the script having
+ // "_source/core/loader.js".
+ if ( CKEDITOR && CKEDITOR.basePath )
+ return CKEDITOR.basePath;
+
+ // Find out the editor directory path, based on its ';
+
+ var iframe = CKEDITOR.dom.element.createFromHtml(
+ '' );
+
+ iframe.on( 'load', function( e )
+ {
+ e.removeListener();
+ var doc = iframe.getFrameDocument().$;
+ // Custom domain handling is needed after each document.open().
+ doc.open();
+ if ( isCustomDomain )
+ doc.domain = document.domain;
+ doc.write( htmlToLoad );
+ doc.close();
+ }, this );
+
+ iframe.setStyles(
+ {
+ width : '346px',
+ height : '130px',
+ 'background-color' : 'white',
+ border : '1px solid black'
+ } );
+ iframe.setCustomData( 'dialog', this );
+
+ var field = this.getContentElement( 'general', 'editing_area' ),
+ container = field.getElement();
+ container.setHtml( '' );
+ container.append( iframe );
+
+ field.getInputElement = function(){ return iframe; };
+
+ // Force container to scale in IE.
+ if ( CKEDITOR.env.ie )
+ {
+ container.setStyle( 'display', 'block' );
+ container.setStyle( 'height', ( iframe.$.offsetHeight + 2 ) + 'px' );
+ }
+ },
+
+ onHide : function()
+ {
+ if ( CKEDITOR.env.ie )
+ this.getParentEditor().document.getBody().$.contentEditable = 'true';
+ },
+
+ onLoad : function()
+ {
+ if ( ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) && editor.lang.dir == 'rtl' )
+ this.parts.contents.setStyle( 'overflow', 'hidden' );
+ },
+
+ onOk : function()
+ {
+ var container = this.getContentElement( 'general', 'editing_area' ).getElement(),
+ iframe = container.getElementsByTag( 'iframe' ).getItem( 0 ),
+ editor = this.getParentEditor(),
+ html = iframe.$.contentWindow.document.body.innerHTML;
+
+ setTimeout( function(){
+ editor.fire( 'paste', { 'html' : html } );
+ }, 0 );
+
+ },
+
+ contents : [
+ {
+ id : 'general',
+ label : editor.lang.common.generalTab,
+ elements : [
+ {
+ type : 'html',
+ id : 'securityMsg',
+ html : '' + lang.securityMsg + '
'
+ },
+ {
+ type : 'html',
+ id : 'pasteMsg',
+ html : ''+lang.pasteMsg +'
'
+ },
+ {
+ type : 'html',
+ id : 'editing_area',
+ style : 'width: 100%; height: 100%;',
+ html : '',
+ focus : function()
+ {
+ var win = this.getInputElement().$.contentWindow,
+ body = win && win.document.body;
+
+ // #3291 : JAWS needs the 500ms delay to detect that the editor iframe
+ // iframe is no longer editable. So that it will put the focus into the
+ // Paste from Word dialog's editable area instead.
+ setTimeout( function()
+ {
+ // Reactivate design mode for IE to make the cursor blinking.
+ CKEDITOR.env.ie && body && ( body.contentEditable = "true" );
+ win.focus();
+ }, 500 );
+ }
+ }
+ ]
+ }
+ ]
+ };
+});
diff --git a/include/ckeditor/_source/plugins/clipboard/plugin.js b/include/ckeditor/_source/plugins/clipboard/plugin.js
new file mode 100644
index 0000000..3674f79
--- /dev/null
+++ b/include/ckeditor/_source/plugins/clipboard/plugin.js
@@ -0,0 +1,379 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Clipboard support
+ */
+
+(function()
+{
+ // Tries to execute any of the paste, cut or copy commands in IE. Returns a
+ // boolean indicating that the operation succeeded.
+ var execIECommand = function( editor, command )
+ {
+ var doc = editor.document,
+ body = doc.getBody();
+
+ var enabled = false;
+ var onExec = function()
+ {
+ enabled = true;
+ };
+
+ // The following seems to be the only reliable way to detect that
+ // clipboard commands are enabled in IE. It will fire the
+ // onpaste/oncut/oncopy events only if the security settings allowed
+ // the command to execute.
+ body.on( command, onExec );
+
+ // IE6/7: document.execCommand has problem to paste into positioned element.
+ ( CKEDITOR.env.version > 7 ? doc.$ : doc.$.selection.createRange() ) [ 'execCommand' ]( command );
+
+ body.removeListener( command, onExec );
+
+ return enabled;
+ };
+
+ // Attempts to execute the Cut and Copy operations.
+ var tryToCutCopy =
+ CKEDITOR.env.ie ?
+ function( editor, type )
+ {
+ return execIECommand( editor, type );
+ }
+ : // !IE.
+ function( editor, type )
+ {
+ try
+ {
+ // Other browsers throw an error if the command is disabled.
+ return editor.document.$.execCommand( type );
+ }
+ catch( e )
+ {
+ return false;
+ }
+ };
+
+ // A class that represents one of the cut or copy commands.
+ var cutCopyCmd = function( type )
+ {
+ this.type = type;
+ this.canUndo = ( this.type == 'cut' ); // We can't undo copy to clipboard.
+ };
+
+ cutCopyCmd.prototype =
+ {
+ exec : function( editor, data )
+ {
+ var success = tryToCutCopy( editor, this.type );
+
+ if ( !success )
+ alert( editor.lang.clipboard[ this.type + 'Error' ] ); // Show cutError or copyError.
+
+ return success;
+ }
+ };
+
+ // Paste command.
+ var pasteCmd =
+ {
+ canUndo : false,
+
+ exec :
+ CKEDITOR.env.ie ?
+ function( editor )
+ {
+ // Prevent IE from pasting at the begining of the document.
+ editor.focus();
+
+ if ( !editor.document.getBody().fire( 'beforepaste' )
+ && !execIECommand( editor, 'paste' ) )
+ {
+ editor.fire( 'pasteDialog' );
+ return false;
+ }
+ }
+ :
+ function( editor )
+ {
+ try
+ {
+ if ( !editor.document.getBody().fire( 'beforepaste' )
+ && !editor.document.$.execCommand( 'Paste', false, null ) )
+ {
+ throw 0;
+ }
+ }
+ catch ( e )
+ {
+ setTimeout( function()
+ {
+ editor.fire( 'pasteDialog' );
+ }, 0 );
+ return false;
+ }
+ }
+ };
+
+ // Listens for some clipboard related keystrokes, so they get customized.
+ var onKey = function( event )
+ {
+ if ( this.mode != 'wysiwyg' )
+ return;
+
+ switch ( event.data.keyCode )
+ {
+ // Paste
+ case CKEDITOR.CTRL + 86 : // CTRL+V
+ case CKEDITOR.SHIFT + 45 : // SHIFT+INS
+
+ var body = this.document.getBody();
+
+ // Simulate 'beforepaste' event for all none-IEs.
+ if ( !CKEDITOR.env.ie && body.fire( 'beforepaste' ) )
+ event.cancel();
+ // Simulate 'paste' event for Opera/Firefox2.
+ else if ( CKEDITOR.env.opera
+ || CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 )
+ body.fire( 'paste' );
+ return;
+
+ // Cut
+ case CKEDITOR.CTRL + 88 : // CTRL+X
+ case CKEDITOR.SHIFT + 46 : // SHIFT+DEL
+
+ // Save Undo snapshot.
+ var editor = this;
+ this.fire( 'saveSnapshot' ); // Save before paste
+ setTimeout( function()
+ {
+ editor.fire( 'saveSnapshot' ); // Save after paste
+ }, 0 );
+ }
+ };
+
+ // Allow to peek clipboard content by redirecting the
+ // pasting content into a temporary bin and grab the content of it.
+ function getClipboardData( evt, mode, callback )
+ {
+ var doc = this.document;
+
+ // Avoid recursions on 'paste' event for IE.
+ if ( CKEDITOR.env.ie && doc.getById( 'cke_pastebin' ) )
+ return;
+
+ // If the browser supports it, get the data directly
+ if (mode == 'text' && evt.data && evt.data.$.clipboardData)
+ {
+ // evt.data.$.clipboardData.types contains all the flavours in Mac's Safari, but not on windows.
+ var plain = evt.data.$.clipboardData.getData( 'text/plain' );
+ if (plain)
+ {
+ evt.data.preventDefault();
+ callback( plain );
+ return;
+ }
+ }
+
+ var sel = this.getSelection(),
+ range = new CKEDITOR.dom.range( doc );
+
+ // Create container to paste into
+ var pastebin = new CKEDITOR.dom.element( mode == 'text' ? 'textarea' : 'div', doc );
+ pastebin.setAttribute( 'id', 'cke_pastebin' );
+ // Safari requires a filler node inside the div to have the content pasted into it. (#4882)
+ CKEDITOR.env.webkit && pastebin.append( doc.createText( '\xa0' ) );
+ doc.getBody().append( pastebin );
+
+ // It's definitely a better user experience if we make the paste-bin pretty unnoticed
+ // by pulling it off the screen.
+ pastebin.setStyles(
+ {
+ position : 'absolute',
+ left : '-1000px',
+ // Position the bin exactly at the position of the selected element
+ // to avoid any subsequent document scroll.
+ top : sel.getStartElement().getDocumentPosition().y + 'px',
+ width : '1px',
+ height : '1px',
+ overflow : 'hidden'
+ });
+
+ var bms = sel.createBookmarks();
+
+ // Turn off design mode temporarily before give focus to the paste bin.
+ if ( mode == 'text' )
+ {
+ if ( CKEDITOR.env.ie )
+ {
+ var ieRange = doc.getBody().$.createTextRange();
+ ieRange.moveToElementText( pastebin.$ );
+ ieRange.execCommand( 'Paste' );
+ evt.data.preventDefault();
+ }
+ else
+ {
+ doc.$.designMode = 'off';
+ pastebin.$.focus();
+ }
+ }
+ else
+ {
+ range.setStartAt( pastebin, CKEDITOR.POSITION_AFTER_START );
+ range.setEndAt( pastebin, CKEDITOR.POSITION_BEFORE_END );
+ range.select( true );
+ }
+
+ // Wait a while and grab the pasted contents
+ window.setTimeout( function()
+ {
+ mode == 'text' && !CKEDITOR.env.ie && ( doc.$.designMode = 'on' );
+ pastebin.remove();
+
+ // Grab the HTML contents.
+ // We need to look for a apple style wrapper on webkit it also adds
+ // a div wrapper if you copy/paste the body of the editor.
+ // Remove hidden div and restore selection.
+ var bogusSpan;
+ pastebin = ( CKEDITOR.env.webkit
+ && ( bogusSpan = pastebin.getFirst() )
+ && ( bogusSpan.is && bogusSpan.hasClass( 'Apple-style-span' ) ) ?
+ bogusSpan : pastebin );
+
+ sel.selectBookmarks( bms );
+ callback( pastebin[ 'get' + ( mode == 'text' ? 'Value' : 'Html' ) ]() );
+ }, 0 );
+ }
+
+ // Register the plugin.
+ CKEDITOR.plugins.add( 'clipboard',
+ {
+ requires : [ 'dialog', 'htmldataprocessor' ],
+ init : function( editor )
+ {
+ // Inserts processed data into the editor at the end of the
+ // events chain.
+ editor.on( 'paste', function( evt )
+ {
+ var data = evt.data;
+ if ( data[ 'html' ] )
+ editor.insertHtml( data[ 'html' ] );
+ else if ( data[ 'text' ] )
+ editor.insertText( data[ 'text' ] );
+
+ }, null, null, 1000 );
+
+ editor.on( 'pasteDialog', function( evt )
+ {
+ setTimeout( function()
+ {
+ // Open default paste dialog.
+ editor.openDialog( 'paste' );
+ }, 0 );
+ });
+
+ function addButtonCommand( buttonName, commandName, command, ctxMenuOrder )
+ {
+ var lang = editor.lang[ commandName ];
+
+ editor.addCommand( commandName, command );
+ editor.ui.addButton( buttonName,
+ {
+ label : lang,
+ command : commandName
+ });
+
+ // If the "menu" plugin is loaded, register the menu item.
+ if ( editor.addMenuItems )
+ {
+ editor.addMenuItem( commandName,
+ {
+ label : lang,
+ command : commandName,
+ group : 'clipboard',
+ order : ctxMenuOrder
+ });
+ }
+ }
+
+ addButtonCommand( 'Cut', 'cut', new cutCopyCmd( 'cut' ), 1 );
+ addButtonCommand( 'Copy', 'copy', new cutCopyCmd( 'copy' ), 4 );
+ addButtonCommand( 'Paste', 'paste', pasteCmd, 8 );
+
+ CKEDITOR.dialog.add( 'paste', CKEDITOR.getUrl( this.path + 'dialogs/paste.js' ) );
+
+ editor.on( 'key', onKey, editor );
+
+ var mode = editor.config.forcePasteAsPlainText ? 'text' : 'html';
+
+ // We'll be catching all pasted content in one line, regardless of whether the
+ // it's introduced by a document command execution (e.g. toolbar buttons) or
+ // user paste behaviors. (e.g. Ctrl-V)
+ editor.on( 'contentDom', function()
+ {
+ var body = editor.document.getBody();
+ body.on( ( (mode == 'text' && CKEDITOR.env.ie) || CKEDITOR.env.webkit ) ? 'paste' : 'beforepaste',
+ function( evt )
+ {
+ if ( depressBeforePasteEvent )
+ return;
+
+ getClipboardData.call( editor, evt, mode, function ( data )
+ {
+ // The very last guard to make sure the
+ // paste has successfully happened.
+ if ( !data )
+ return;
+
+ var dataTransfer = {};
+ dataTransfer[ mode ] = data;
+ editor.fire( 'paste', dataTransfer );
+ } );
+ });
+
+ });
+
+ // If the "contextmenu" plugin is loaded, register the listeners.
+ if ( editor.contextMenu )
+ {
+ var depressBeforePasteEvent;
+ function stateFromNamedCommand( command )
+ {
+ // IE Bug: queryCommandEnabled('paste') fires also 'beforepaste',
+ // guard to distinguish from the ordinary sources( either
+ // keyboard paste or execCommand ) (#4874).
+ CKEDITOR.env.ie && command == 'Paste'&& ( depressBeforePasteEvent = 1 );
+
+ var retval = editor.document.$.queryCommandEnabled( command ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED;
+ depressBeforePasteEvent = 0;
+ return retval;
+ }
+
+ editor.contextMenu.addListener( function()
+ {
+ return {
+ cut : stateFromNamedCommand( 'Cut' ),
+
+ // Browser bug: 'Cut' has the correct states for both Copy and Cut.
+ copy : stateFromNamedCommand( 'Cut' ),
+ paste : CKEDITOR.env.webkit ? CKEDITOR.TRISTATE_OFF : stateFromNamedCommand( 'Paste' )
+ };
+ });
+ }
+ }
+ });
+})();
+
+/**
+ * Fired when a clipboard operation is about to be taken into the editor.
+ * Listeners can manipulate the data to be pasted before having it effectively
+ * inserted into the document.
+ * @name CKEDITOR.editor#paste
+ * @since 3.1
+ * @event
+ * @param {String} [data.html] The HTML data to be pasted. If not available, e.data.text will be defined.
+ * @param {String} [data.text] The plain text data to be pasted, available when plain text operations are to used. If not available, e.data.html will be defined.
+ */
diff --git a/include/ckeditor/_source/plugins/colorbutton/plugin.js b/include/ckeditor/_source/plugins/colorbutton/plugin.js
new file mode 100644
index 0000000..f159e52
--- /dev/null
+++ b/include/ckeditor/_source/plugins/colorbutton/plugin.js
@@ -0,0 +1,247 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'colorbutton',
+{
+ requires : [ 'panelbutton', 'floatpanel', 'styles' ],
+
+ init : function( editor )
+ {
+ var config = editor.config,
+ lang = editor.lang.colorButton;
+
+ var clickFn;
+
+ if ( !CKEDITOR.env.hc )
+ {
+ addButton( 'TextColor', 'fore', lang.textColorTitle );
+ addButton( 'BGColor', 'back', lang.bgColorTitle );
+ }
+
+ function addButton( name, type, title )
+ {
+ editor.ui.add( name, CKEDITOR.UI_PANELBUTTON,
+ {
+ label : title,
+ title : title,
+ className : 'cke_button_' + name.toLowerCase(),
+ modes : { wysiwyg : 1 },
+
+ panel :
+ {
+ css : editor.skin.editor.css,
+ attributes : { role : 'listbox', 'aria-label' : lang.panelTitle }
+ },
+
+ onBlock : function( panel, block )
+ {
+ block.autoSize = true;
+ block.element.addClass( 'cke_colorblock' );
+ block.element.setHtml( renderColors( panel, type ) );
+
+ var keys = block.keys;
+ keys[ 39 ] = 'next'; // ARROW-RIGHT
+ keys[ 40 ] = 'next'; // ARROW-DOWN
+ keys[ 9 ] = 'next'; // TAB
+ keys[ 37 ] = 'prev'; // ARROW-LEFT
+ keys[ 38 ] = 'prev'; // ARROW-UP
+ keys[ CKEDITOR.SHIFT + 9 ] = 'prev'; // SHIFT + TAB
+ keys[ 32 ] = 'click'; // SPACE
+ }
+ });
+ }
+
+
+ function renderColors( panel, type )
+ {
+ var output = [],
+ colors = config.colorButton_colors.split( ',' ),
+ total = colors.length + ( config.colorButton_enableMore ? 2 : 1 );
+
+ var clickFn = CKEDITOR.tools.addFunction( function( color, type )
+ {
+ if ( color == '?' )
+ {
+ var applyColorStyle = arguments.callee;
+ function onColorDialogClose( evt )
+ {
+ this.removeListener( 'ok', onColorDialogClose );
+ this.removeListener( 'cancel', onColorDialogClose );
+
+ evt.name == 'ok' && applyColorStyle( this.getContentElement( 'picker', 'selectedColor' ).getValue(), type );
+ }
+
+ editor.openDialog( 'colordialog', function()
+ {
+ this.on( 'ok', onColorDialogClose );
+ this.on( 'cancel', onColorDialogClose );
+ } );
+
+ return;
+ }
+
+ editor.focus();
+
+ panel.hide();
+
+
+ editor.fire( 'saveSnapshot' );
+
+ // Clean up any conflicting style within the range.
+ new CKEDITOR.style( config['colorButton_' + type + 'Style'], { color : 'inherit' } ).remove( editor.document );
+
+ if ( color )
+ {
+ var colorStyle = config['colorButton_' + type + 'Style'];
+
+ colorStyle.childRule = type == 'back' ?
+ // It's better to apply background color as the innermost style. (#3599)
+ function(){ return false; } :
+ // Fore color style must be applied inside links instead of around it.
+ function( element ){ return element.getName() != 'a'; };
+
+ new CKEDITOR.style( colorStyle, { color : color } ).apply( editor.document );
+ }
+
+ editor.fire( 'saveSnapshot' );
+ });
+
+ // Render the "Automatic" button.
+ output.push(
+ '' +
+ '' +
+ '' +
+ '| ' +
+ '' +
+ ' | ' +
+ '',
+ lang.auto,
+ ' | ' +
+ '
' +
+ '
' +
+ '' +
+ '' );
+
+ // Render the color boxes.
+ for ( var i = 0 ; i < colors.length ; i++ )
+ {
+ if ( ( i % 8 ) === 0 )
+ output.push( '' );
+
+ var parts = colors[ i ].split( '/' ),
+ colorName = parts[ 0 ],
+ colorCode = parts[ 1 ] || colorName;
+
+ // The data can be only a color code (without #) or colorName + color code
+ // If only a color code is provided, then the colorName is the color with the hash
+ if (!parts[1])
+ colorName = '#' + colorName;
+
+ var colorLabel = editor.lang.colors[ colorCode ] || colorCode;
+ output.push(
+ '| ' +
+ '' +
+ '' +
+ '' +
+ ' | ' );
+ }
+
+ // Render the "More Colors" button.
+ if ( config.colorButton_enableMore )
+ {
+ output.push(
+ '
' +
+ '' +
+ '| ' +
+ '',
+ lang.more,
+ '' +
+ ' | ' ); // It is later in the code.
+ }
+
+ output.push( '
' );
+
+ return output.join( '' );
+ }
+ }
+});
+
+/**
+ * Whether to enable the "More Colors..." button in the color selectors.
+ * @default false
+ * @type Boolean
+ * @example
+ * config.colorButton_enableMore = false;
+ */
+CKEDITOR.config.colorButton_enableMore = true;
+
+/**
+ * Defines the colors to be displayed in the color selectors. It's a string
+ * containing the hexadecimal notation for HTML colors, without the "#" prefix.
+ *
+ * Since 3.3: A name may be optionally defined by prefixing the entries with the
+ * name and the slash character. For example, "FontColor1/FF9900" will be
+ * displayed as the color #FF9900 in the selector, but will be outputted as "FontColor1".
+ * @type String
+ * @default '000,800000,8B4513,2F4F4F,008080,000080,4B0082,696969,B22222,A52A2A,DAA520,006400,40E0D0,0000CD,800080,808080,F00,FF8C00,FFD700,008000,0FF,00F,EE82EE,A9A9A9,FFA07A,FFA500,FFFF00,00FF00,AFEEEE,ADD8E6,DDA0DD,D3D3D3,FFF0F5,FAEBD7,FFFFE0,F0FFF0,F0FFFF,F0F8FF,E6E6FA,FFF'
+ * @example
+ * // Brazil colors only.
+ * config.colorButton_colors = '00923E,F8C100,28166F';
+ * @example
+ * config.colorButton_colors = 'FontColor1/FF9900,FontColor2/0066CC,FontColor3/F00'
+ */
+CKEDITOR.config.colorButton_colors =
+ '000,800000,8B4513,2F4F4F,008080,000080,4B0082,696969,' +
+ 'B22222,A52A2A,DAA520,006400,40E0D0,0000CD,800080,808080,' +
+ 'F00,FF8C00,FFD700,008000,0FF,00F,EE82EE,A9A9A9,' +
+ 'FFA07A,FFA500,FFFF00,00FF00,AFEEEE,ADD8E6,DDA0DD,D3D3D3,' +
+ 'FFF0F5,FAEBD7,FFFFE0,F0FFF0,F0FFFF,F0F8FF,E6E6FA,FFF';
+
+/**
+ * Holds the style definition to be used to apply the text foreground color.
+ * @type Object
+ * @example
+ * // This is basically the default setting value.
+ * config.colorButton_foreStyle =
+ * {
+ * element : 'span',
+ * styles : { 'color' : '#(color)' }
+ * };
+ */
+CKEDITOR.config.colorButton_foreStyle =
+ {
+ element : 'span',
+ styles : { 'color' : '#(color)' },
+ overrides : [ { element : 'font', attributes : { 'color' : null } } ]
+ };
+
+/**
+ * Holds the style definition to be used to apply the text background color.
+ * @type Object
+ * @example
+ * // This is basically the default setting value.
+ * config.colorButton_backStyle =
+ * {
+ * element : 'span',
+ * styles : { 'background-color' : '#(color)' }
+ * };
+ */
+CKEDITOR.config.colorButton_backStyle =
+ {
+ element : 'span',
+ styles : { 'background-color' : '#(color)' }
+ };
diff --git a/include/ckeditor/_source/plugins/colordialog/dialogs/colordialog.js b/include/ckeditor/_source/plugins/colordialog/dialogs/colordialog.js
new file mode 100644
index 0000000..63dfa2b
--- /dev/null
+++ b/include/ckeditor/_source/plugins/colordialog/dialogs/colordialog.js
@@ -0,0 +1,191 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.dialog.add( 'colordialog', function( editor )
+ {
+ // Define some shorthands.
+ var $el = CKEDITOR.dom.element,
+ $doc = CKEDITOR.document,
+ $tools = CKEDITOR.tools,
+ lang = editor.lang.colordialog;
+
+ // Reference the dialog.
+ var dialog;
+
+ function spacer()
+ {
+ return {
+ type : 'html',
+ html : ' '
+ };
+ }
+
+ var table = new $el( 'table' );
+ createColorTable();
+
+ var cellMouseover = function( event )
+ {
+ var color = new $el( event.data.getTarget() ).getAttribute( 'title' );
+ $doc.getById( 'hicolor' ).setStyle( 'background-color', color );
+ $doc.getById( 'hicolortext' ).setHtml( color );
+ };
+
+ var cellClick = function( event )
+ {
+ var color = new $el( event.data.getTarget() ).getAttribute( 'title' );
+ dialog.getContentElement( 'picker', 'selectedColor' ).setValue( color );
+ };
+
+ function createColorTable()
+ {
+ // Create the base colors array.
+ var aColors = ['00','33','66','99','cc','ff'];
+
+ // This function combines two ranges of three values from the color array into a row.
+ function appendColorRow( rangeA, rangeB )
+ {
+ for ( var i = rangeA ; i < rangeA + 3 ; i++ )
+ {
+ var row = table.$.insertRow(-1);
+
+ for ( var j = rangeB ; j < rangeB + 3 ; j++ )
+ {
+ for ( var n = 0 ; n < 6 ; n++ )
+ {
+ appendColorCell( row, '#' + aColors[j] + aColors[n] + aColors[i] );
+ }
+ }
+ }
+ }
+
+ // This function create a single color cell in the color table.
+ function appendColorCell( targetRow, color )
+ {
+ var cell = new $el( targetRow.insertCell( -1 ) );
+ cell.setAttribute( 'class', 'ColorCell' );
+ cell.setStyle( 'background-color', color );
+
+ cell.setStyle( 'width', '15px' );
+ cell.setStyle( 'height', '15px' );
+
+ // Pass unparsed color value in some markup-degradable form.
+ cell.setAttribute( 'title', color );
+ }
+
+ appendColorRow( 0, 0 );
+ appendColorRow( 3, 0 );
+ appendColorRow( 0, 3 );
+ appendColorRow( 3, 3 );
+
+ // Create the last row.
+ var oRow = table.$.insertRow(-1) ;
+
+ // Create the gray scale colors cells.
+ for ( var n = 0 ; n < 6 ; n++ )
+ {
+ appendColorCell( oRow, '#' + aColors[n] + aColors[n] + aColors[n] ) ;
+ }
+
+ // Fill the row with black cells.
+ for ( var i = 0 ; i < 12 ; i++ )
+ {
+ appendColorCell( oRow, '#000000' ) ;
+ }
+ }
+
+ function clear()
+ {
+ $doc.getById( 'selhicolor' ).removeStyle( 'background-color' );
+ dialog.getContentElement( 'picker', 'selectedColor' ).setValue( '' );
+ }
+
+ var clearActual = $tools.addFunction( function()
+ {
+ $doc.getById( 'hicolor' ).removeStyle( 'background-color' );
+ $doc.getById( 'hicolortext' ).setHtml( ' ' );
+ } );
+
+ return {
+ title : lang.title,
+ minWidth : 360,
+ minHeight : 220,
+ onLoad : function()
+ {
+ // Update reference.
+ dialog = this;
+ },
+ contents : [
+ {
+ id : 'picker',
+ label : lang.title,
+ accessKey : 'I',
+ elements :
+ [
+ {
+ type : 'hbox',
+ padding : 0,
+ widths : [ '70%', '10%', '30%' ],
+ children :
+ [
+ {
+ type : 'html',
+ html : '',
+ onLoad : function()
+ {
+ var table = CKEDITOR.document.getById( this.domId );
+ table.on( 'mouseover', cellMouseover );
+ table.on( 'click', cellClick );
+ }
+ },
+ spacer(),
+ {
+ type : 'vbox',
+ padding : 0,
+ widths : [ '70%', '5%', '25%' ],
+ children :
+ [
+ {
+ type : 'html',
+ html : '' + lang.highlight +'\
+ \
+
\
+ ' + lang.selected +'\
+ '
+ },
+ {
+ type : 'text',
+ id : 'selectedColor',
+ style : 'width: 74px',
+ onChange : function()
+ {
+ // Try to update color preview with new value. If fails, then set it no none.
+ try
+ {
+ $doc.getById( 'selhicolor' ).setStyle( 'background-color', this.getValue() );
+ }
+ catch ( e )
+ {
+ clear();
+ }
+ }
+ },
+ spacer(),
+ {
+ type : 'button',
+ id : 'clear',
+ style : 'margin-top: 5px',
+ label : lang.clear,
+ onClick : clear
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ };
+ }
+ );
diff --git a/include/ckeditor/_source/plugins/colordialog/plugin.js b/include/ckeditor/_source/plugins/colordialog/plugin.js
new file mode 100644
index 0000000..e320aa6
--- /dev/null
+++ b/include/ckeditor/_source/plugins/colordialog/plugin.js
@@ -0,0 +1,13 @@
+( function()
+{
+ CKEDITOR.plugins.colordialog =
+ {
+ init : function( editor )
+ {
+ editor.addCommand( 'colordialog', new CKEDITOR.dialogCommand( 'colordialog' ) );
+ CKEDITOR.dialog.add( 'colordialog', this.path + 'dialogs/colordialog.js' );
+ }
+ };
+
+ CKEDITOR.plugins.add( 'colordialog', CKEDITOR.plugins.colordialog );
+} )();
diff --git a/include/ckeditor/_source/plugins/contextmenu/plugin.js b/include/ckeditor/_source/plugins/contextmenu/plugin.js
new file mode 100644
index 0000000..c00692b
--- /dev/null
+++ b/include/ckeditor/_source/plugins/contextmenu/plugin.js
@@ -0,0 +1,274 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'contextmenu',
+{
+ requires : [ 'menu' ],
+
+ beforeInit : function( editor )
+ {
+ editor.contextMenu = new CKEDITOR.plugins.contextMenu( editor );
+
+ editor.addCommand( 'contextMenu',
+ {
+ exec : function()
+ {
+ editor.contextMenu.show( editor.document.getBody() );
+ }
+ });
+ }
+});
+
+CKEDITOR.plugins.contextMenu = CKEDITOR.tools.createClass(
+{
+ $ : function( editor )
+ {
+ this.id = 'cke_' + CKEDITOR.tools.getNextNumber();
+ this.editor = editor;
+ this._.listeners = [];
+ this._.functionId = CKEDITOR.tools.addFunction( function( commandName )
+ {
+ this._.panel.hide();
+ editor.focus();
+ editor.execCommand( commandName );
+ },
+ this);
+
+ this.definition =
+ {
+ panel:
+ {
+ className : editor.skinClass + ' cke_contextmenu',
+ attributes :
+ {
+ 'aria-label' : editor.lang.contextmenu.options
+ }
+ }
+ };
+ },
+
+ _ :
+ {
+ onMenu : function( offsetParent, corner, offsetX, offsetY )
+ {
+ var menu = this._.menu,
+ editor = this.editor;
+
+ if ( menu )
+ {
+ menu.hide();
+ menu.removeAll();
+ }
+ else
+ {
+ menu = this._.menu = new CKEDITOR.menu( editor, this.definition );
+ menu.onClick = CKEDITOR.tools.bind( function( item )
+ {
+ menu.hide();
+
+ if ( item.onClick )
+ item.onClick();
+ else if ( item.command )
+ editor.execCommand( item.command );
+
+ }, this );
+
+ menu.onEscape = function( keystroke )
+ {
+ var parent = this.parent;
+ // 1. If it's sub-menu, restore the last focused item
+ // of upper level menu.
+ // 2. In case of a top-menu, close it.
+ if ( parent )
+ {
+ parent._.panel.hideChild();
+ // Restore parent block item focus.
+ var parentBlock = parent._.panel._.panel._.currentBlock,
+ parentFocusIndex = parentBlock._.focusIndex;
+ parentBlock._.markItem( parentFocusIndex );
+ }
+ else if ( keystroke == 27 )
+ {
+ this.hide();
+ editor.focus();
+ }
+ return false;
+ };
+ }
+
+ var listeners = this._.listeners,
+ includedItems = [];
+
+ var selection = this.editor.getSelection(),
+ element = selection && selection.getStartElement();
+
+ menu.onHide = CKEDITOR.tools.bind( function()
+ {
+ menu.onHide = null;
+
+ if ( CKEDITOR.env.ie )
+ {
+ var selection = editor.getSelection();
+ selection && selection.unlock();
+ }
+
+ this.onHide && this.onHide();
+ },
+ this );
+
+ // Call all listeners, filling the list of items to be displayed.
+ for ( var i = 0 ; i < listeners.length ; i++ )
+ {
+ var listenerItems = listeners[ i ]( element, selection );
+
+ if ( listenerItems )
+ {
+ for ( var itemName in listenerItems )
+ {
+ var item = this.editor.getMenuItem( itemName );
+
+ if ( item )
+ {
+ item.state = listenerItems[ itemName ];
+ menu.add( item );
+ }
+ }
+ }
+ }
+
+ // Don't show context menu with zero items.
+ menu.items.length && menu.show( offsetParent, corner || ( editor.lang.dir == 'rtl' ? 2 : 1 ), offsetX, offsetY );
+ }
+ },
+
+ proto :
+ {
+ addTarget : function( element, nativeContextMenuOnCtrl )
+ {
+ // Opera doesn't support 'contextmenu' event, we have duo approaches employed here:
+ // 1. Inherit the 'button override' hack we introduced in v2 (#4530), while this require the Opera browser
+ // option 'Allow script to detect context menu/right click events' to be always turned on.
+ // 2. Considering the fact that ctrl/meta key is not been occupied
+ // for multiple range selecting (like Gecko), we use this key
+ // combination as a fallback for triggering context-menu. (#4530)
+ if ( CKEDITOR.env.opera )
+ {
+ var contextMenuOverrideButton;
+ element.on( 'mousedown', function( evt )
+ {
+ evt = evt.data;
+ if ( evt.$.button != 2 )
+ {
+ if ( evt.getKeystroke() == CKEDITOR.CTRL + 1 )
+ element.fire( 'contextmenu', evt );
+ return;
+ }
+
+ if ( nativeContextMenuOnCtrl
+ && ( evt.$.ctrlKey || evt.$.metaKey ) )
+ return;
+
+ var target = evt.getTarget();
+
+ if ( !contextMenuOverrideButton )
+ {
+ var ownerDoc = target.getDocument();
+ contextMenuOverrideButton = ownerDoc.createElement( 'input' ) ;
+ contextMenuOverrideButton.$.type = 'button' ;
+ ownerDoc.getBody().append( contextMenuOverrideButton ) ;
+ }
+
+ contextMenuOverrideButton.setAttribute( 'style', 'position:absolute;top:' + ( evt.$.clientY - 2 ) +
+ 'px;left:' + ( evt.$.clientX - 2 ) +
+ 'px;width:5px;height:5px;opacity:0.01' );
+
+ } );
+
+ element.on( 'mouseup', function ( evt )
+ {
+ if ( contextMenuOverrideButton )
+ {
+ contextMenuOverrideButton.remove();
+ contextMenuOverrideButton = undefined;
+ // Simulate 'contextmenu' event.
+ element.fire( 'contextmenu', evt.data );
+ }
+ } );
+ }
+
+ element.on( 'contextmenu', function( event )
+ {
+ var domEvent = event.data;
+
+ if ( nativeContextMenuOnCtrl &&
+ // Safari on Windows always show 'ctrlKey' as true in 'contextmenu' event,
+ // which make this property unreliable. (#4826)
+ ( CKEDITOR.env.webkit ? holdCtrlKey : domEvent.$.ctrlKey || domEvent.$.metaKey ) )
+ return;
+
+ // Selection will be unavailable after context menu shows up
+ // in IE, lock it now.
+ if ( CKEDITOR.env.ie )
+ {
+ var selection = this.editor.getSelection();
+ selection && selection.lock();
+ }
+
+ // Cancel the browser context menu.
+ domEvent.preventDefault();
+
+ var offsetParent = domEvent.getTarget().getDocument().getDocumentElement(),
+ offsetX = domEvent.$.clientX,
+ offsetY = domEvent.$.clientY;
+
+ CKEDITOR.tools.setTimeout( function()
+ {
+ this.show( offsetParent, null, offsetX, offsetY );
+ },
+ 0, this );
+ },
+ this );
+
+ if ( CKEDITOR.env.webkit )
+ {
+ var holdCtrlKey,
+ onKeyDown = function( event )
+ {
+ holdCtrlKey = event.data.$.ctrlKey || event.data.$.metaKey;
+ },
+ resetOnKeyUp = function()
+ {
+ holdCtrlKey = 0;
+ };
+
+ element.on( 'keydown', onKeyDown );
+ element.on( 'keyup', resetOnKeyUp );
+ element.on( 'contextmenu', resetOnKeyUp );
+ }
+ },
+
+ addListener : function( listenerFn )
+ {
+ this._.listeners.push( listenerFn );
+ },
+
+ show : function( offsetParent, corner, offsetX, offsetY )
+ {
+ this.editor.focus();
+ this._.onMenu( offsetParent || CKEDITOR.document.getDocumentElement(), corner, offsetX || 0, offsetY || 0 );
+ }
+ }
+});
+
+/**
+ * Whether to show the browser native context menu when the CTRL or the
+ * META (Mac) key is pressed while opening the context menu.
+ * @name CKEDITOR.config.browserContextMenuOnCtrl
+ * @since 3.0.2
+ * @type Boolean
+ * @default true
+ * @example
+ * config.browserContextMenuOnCtrl = false;
+ */
diff --git a/include/ckeditor/_source/plugins/dialog/dialogDefinition.js b/include/ckeditor/_source/plugins/dialog/dialogDefinition.js
new file mode 100644
index 0000000..9dd252f
--- /dev/null
+++ b/include/ckeditor/_source/plugins/dialog/dialogDefinition.js
@@ -0,0 +1,315 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the "virtual" dialog, dialog content and dialog button
+ * definition classes.
+ */
+
+/**
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialogs.
+ * @name CKEDITOR.dialog.dialogDefinition
+ * @constructor
+ * @example
+ * // There is no constructor for this class, the user just has to define an
+ * // object with the appropriate properties.
+ *
+ * CKEDITOR.dialog.add( 'testOnly', function( editor )
+ * {
+ * return {
+ * title : 'Test Dialog',
+ * resizable : CKEDITOR.DIALOG_RESIZE_BOTH,
+ * minWidth : 500,
+ * minHeight : 400,
+ * contents : [
+ * {
+ * id : 'tab1',
+ * label : 'First Tab',
+ * title : 'First Tab Title',
+ * accessKey : 'Q',
+ * elements : [
+ * {
+ * type : 'text',
+ * label : 'Test Text 1',
+ * id : 'testText1',
+ * 'default' : 'hello world!'
+ * }
+ * ]
+ * }
+ * ]
+ * };
+ * });
+ */
+
+/**
+ * The dialog title, displayed in the dialog's header. Required.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.title
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * How the dialog can be resized, must be one of the four contents defined below.
+ *
+ * CKEDITOR.DIALOG_RESIZE_NONE
+ * CKEDITOR.DIALOG_RESIZE_WIDTH
+ * CKEDITOR.DIALOG_RESIZE_HEIGHT
+ * CKEDITOR.DIALOG_RESIZE_BOTH
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.resizable
+ * @field
+ * @type Number
+ * @default CKEDITOR.DIALOG_RESIZE_NONE
+ * @example
+ */
+
+/**
+ * The minimum width of the dialog, in pixels.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.minWidth
+ * @field
+ * @type Number
+ * @default 600
+ * @example
+ */
+
+/**
+ * The minimum height of the dialog, in pixels.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.minHeight
+ * @field
+ * @type Number
+ * @default 400
+ * @example
+ */
+
+/**
+ * The buttons in the dialog, defined as an array of
+ * {@link CKEDITOR.dialog.buttonDefinition} objects.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.buttons
+ * @field
+ * @type Array
+ * @default [ CKEDITOR.dialog.okButton, CKEDITOR.dialog.cancelButton ]
+ * @example
+ */
+
+/**
+ * The contents in the dialog, defined as an array of
+ * {@link CKEDITOR.dialog.contentDefinition} objects. Required.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.contents
+ * @field
+ * @type Array
+ * @example
+ */
+
+/**
+ * The function to execute when OK is pressed.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.onOk
+ * @field
+ * @type Function
+ * @example
+ */
+
+/**
+ * The function to execute when Cancel is pressed.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.onCancel
+ * @field
+ * @type Function
+ * @example
+ */
+
+/**
+ * The function to execute when the dialog is displayed for the first time.
+ * @name CKEDITOR.dialog.dialogDefinition.prototype.onLoad
+ * @field
+ * @type Function
+ * @example
+ */
+
+/**
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialog content pages.
+ * @name CKEDITOR.dialog.contentDefinition
+ * @constructor
+ * @example
+ * // There is no constructor for this class, the user just has to define an
+ * // object with the appropriate properties.
+ */
+
+/**
+ * The id of the content page.
+ * @name CKEDITOR.dialog.contentDefinition.prototype.id
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * The tab label of the content page.
+ * @name CKEDITOR.dialog.contentDefinition.prototype.label
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * The popup message of the tab label.
+ * @name CKEDITOR.dialog.contentDefinition.prototype.title
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * The CTRL hotkey for switching to the tab.
+ * @name CKEDITOR.dialog.contentDefinition.prototype.accessKey
+ * @field
+ * @type String
+ * @example
+ * contentDefinition.accessKey = 'Q'; // Switch to this page when CTRL-Q is pressed.
+ */
+
+/**
+ * The UI elements contained in this content page, defined as an array of
+ * {@link CKEDITOR.dialog.uiElementDefinition} objects.
+ * @name CKEDITOR.dialog.contentDefinition.prototype.elements
+ * @field
+ * @type Array
+ * @example
+ */
+
+/**
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialog buttons.
+ * @name CKEDITOR.dialog.buttonDefinition
+ * @constructor
+ * @example
+ * // There is no constructor for this class, the user just has to define an
+ * // object with the appropriate properties.
+ */
+
+/**
+ * The id of the dialog button. Required.
+ * @name CKEDITOR.dialog.buttonDefinition.prototype.id
+ * @type String
+ * @field
+ * @example
+ */
+
+/**
+ * The label of the dialog button. Required.
+ * @name CKEDITOR.dialog.buttonDefinition.prototype.label
+ * @type String
+ * @field
+ * @example
+ */
+
+/**
+ * The popup message of the dialog button.
+ * @name CKEDITOR.dialog.buttonDefinition.prototype.title
+ * @type String
+ * @field
+ * @example
+ */
+
+/**
+ * The CTRL hotkey for the button.
+ * @name CKEDITOR.dialog.buttonDefinition.prototype.accessKey
+ * @type String
+ * @field
+ * @example
+ * exitButton.accessKey = 'X'; // Button will be pressed when user presses CTRL-X
+ */
+
+/**
+ * Whether the button is disabled.
+ * @name CKEDITOR.dialog.buttonDefinition.prototype.disabled
+ * @type Boolean
+ * @field
+ * @default false
+ * @example
+ */
+
+/**
+ * The function to execute when the button is clicked.
+ * @name CKEDITOR.dialog.buttonDefinition.prototype.onClick
+ * @type Function
+ * @field
+ * @example
+ */
+
+/**
+ * This class is not really part of the API. It just illustrates the properties
+ * that developers can use to define and create dialog UI elements.
+ * @name CKEDITOR.dialog.uiElementDefinition
+ * @constructor
+ * @see CKEDITOR.ui.dialog.uiElement
+ * @example
+ * // There is no constructor for this class, the user just has to define an
+ * // object with the appropriate properties.
+ */
+
+/**
+ * The id of the UI element.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.id
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * The type of the UI element. Required.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.type
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * The popup label of the UI element.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.title
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * CSS class names to append to the UI element.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.className
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * Inline CSS classes to append to the UI element.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.style
+ * @field
+ * @type String
+ * @example
+ */
+
+/**
+ * Function to execute the first time the UI element is displayed.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.onLoad
+ * @field
+ * @type Function
+ * @example
+ */
+
+/**
+ * Function to execute whenever the UI element's parent dialog is displayed.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.onShow
+ * @field
+ * @type Function
+ * @example
+ */
+
+/**
+ * Function to execute whenever the UI element's parent dialog is closed.
+ * @name CKEDITOR.dialog.uiElementDefinition.prototype.onHide
+ * @field
+ * @type Function
+ * @example
+ */
diff --git a/include/ckeditor/_source/plugins/dialog/plugin.js b/include/ckeditor/_source/plugins/dialog/plugin.js
new file mode 100644
index 0000000..a6b9f72
--- /dev/null
+++ b/include/ckeditor/_source/plugins/dialog/plugin.js
@@ -0,0 +1,2913 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview The floating dialog plugin.
+ */
+
+/**
+ * No resize for this dialog.
+ * @constant
+ */
+CKEDITOR.DIALOG_RESIZE_NONE = 0;
+
+/**
+ * Only allow horizontal resizing for this dialog, disable vertical resizing.
+ * @constant
+ */
+CKEDITOR.DIALOG_RESIZE_WIDTH = 1;
+
+/**
+ * Only allow vertical resizing for this dialog, disable horizontal resizing.
+ * @constant
+ */
+CKEDITOR.DIALOG_RESIZE_HEIGHT = 2;
+
+/*
+ * Allow the dialog to be resized in both directions.
+ * @constant
+ */
+CKEDITOR.DIALOG_RESIZE_BOTH = 3;
+
+(function()
+{
+ function isTabVisible( tabId )
+ {
+ return !!this._.tabs[ tabId ][ 0 ].$.offsetHeight;
+ }
+
+ function getPreviousVisibleTab()
+ {
+ var tabId = this._.currentTabId,
+ length = this._.tabIdList.length,
+ tabIndex = CKEDITOR.tools.indexOf( this._.tabIdList, tabId ) + length;
+
+ for ( var i = tabIndex - 1 ; i > tabIndex - length ; i-- )
+ {
+ if ( isTabVisible.call( this, this._.tabIdList[ i % length ] ) )
+ return this._.tabIdList[ i % length ];
+ }
+
+ return null;
+ }
+
+ function getNextVisibleTab()
+ {
+ var tabId = this._.currentTabId,
+ length = this._.tabIdList.length,
+ tabIndex = CKEDITOR.tools.indexOf( this._.tabIdList, tabId );
+
+ for ( var i = tabIndex + 1 ; i < tabIndex + length ; i++ )
+ {
+ if ( isTabVisible.call( this, this._.tabIdList[ i % length ] ) )
+ return this._.tabIdList[ i % length ];
+ }
+
+ return null;
+ }
+
+ /**
+ * This is the base class for runtime dialog objects. An instance of this
+ * class represents a single named dialog for a single editor instance.
+ * @param {Object} editor The editor which created the dialog.
+ * @param {String} dialogName The dialog's registered name.
+ * @constructor
+ * @example
+ * var dialogObj = new CKEDITOR.dialog( editor, 'smiley' );
+ */
+ CKEDITOR.dialog = function( editor, dialogName )
+ {
+ // Load the dialog definition.
+ var definition = CKEDITOR.dialog._.dialogDefinitions[ dialogName ];
+
+ // Completes the definition with the default values.
+ definition = CKEDITOR.tools.extend( definition( editor ), defaultDialogDefinition );
+
+ // Clone a functionally independent copy for this dialog.
+ definition = CKEDITOR.tools.clone( definition );
+
+ // Create a complex definition object, extending it with the API
+ // functions.
+ definition = new definitionObject( this, definition );
+
+
+ var doc = CKEDITOR.document;
+
+ var themeBuilt = editor.theme.buildDialog( editor );
+
+ // Initialize some basic parameters.
+ this._ =
+ {
+ editor : editor,
+ element : themeBuilt.element,
+ name : dialogName,
+ contentSize : { width : 0, height : 0 },
+ size : { width : 0, height : 0 },
+ updateSize : false,
+ contents : {},
+ buttons : {},
+ accessKeyMap : {},
+
+ // Initialize the tab and page map.
+ tabs : {},
+ tabIdList : [],
+ currentTabId : null,
+ currentTabIndex : null,
+ pageCount : 0,
+ lastTab : null,
+ tabBarMode : false,
+
+ // Initialize the tab order array for input widgets.
+ focusList : [],
+ currentFocusIndex : 0,
+ hasFocus : false
+ };
+
+ this.parts = themeBuilt.parts;
+
+ CKEDITOR.tools.setTimeout( function()
+ {
+ editor.fire( 'ariaWidget', this.parts.contents );
+ },
+ 0, this );
+
+ // Set the startup styles for the dialog, avoiding it enlarging the
+ // page size on the dialog creation.
+ this.parts.dialog.setStyles(
+ {
+ position : CKEDITOR.env.ie6Compat ? 'absolute' : 'fixed',
+ top : 0,
+ left: 0,
+ visibility : 'hidden'
+ });
+
+ // Call the CKEDITOR.event constructor to initialize this instance.
+ CKEDITOR.event.call( this );
+
+ // Fire the "dialogDefinition" event, making it possible to customize
+ // the dialog definition.
+ this.definition = definition = CKEDITOR.fire( 'dialogDefinition',
+ {
+ name : dialogName,
+ definition : definition
+ }
+ , editor ).definition;
+ // Initialize load, show, hide, ok and cancel events.
+ if ( definition.onLoad )
+ this.on( 'load', definition.onLoad );
+
+ if ( definition.onShow )
+ this.on( 'show', definition.onShow );
+
+ if ( definition.onHide )
+ this.on( 'hide', definition.onHide );
+
+ if ( definition.onOk )
+ {
+ this.on( 'ok', function( evt )
+ {
+ if ( definition.onOk.call( this, evt ) === false )
+ evt.data.hide = false;
+ });
+ }
+
+ if ( definition.onCancel )
+ {
+ this.on( 'cancel', function( evt )
+ {
+ if ( definition.onCancel.call( this, evt ) === false )
+ evt.data.hide = false;
+ });
+ }
+
+ var me = this;
+
+ // Iterates over all items inside all content in the dialog, calling a
+ // function for each of them.
+ var iterContents = function( func )
+ {
+ var contents = me._.contents,
+ stop = false;
+
+ for ( var i in contents )
+ {
+ for ( var j in contents[i] )
+ {
+ stop = func.call( this, contents[i][j] );
+ if ( stop )
+ return;
+ }
+ }
+ };
+
+ this.on( 'ok', function( evt )
+ {
+ iterContents( function( item )
+ {
+ if ( item.validate )
+ {
+ var isValid = item.validate( this );
+
+ if ( typeof isValid == 'string' )
+ {
+ alert( isValid );
+ isValid = false;
+ }
+
+ if ( isValid === false )
+ {
+ if ( item.select )
+ item.select();
+ else
+ item.focus();
+
+ evt.data.hide = false;
+ evt.stop();
+ return true;
+ }
+ }
+ });
+ }, this, null, 0 );
+
+ this.on( 'cancel', function( evt )
+ {
+ iterContents( function( item )
+ {
+ if ( item.isChanged() )
+ {
+ if ( !confirm( editor.lang.common.confirmCancel ) )
+ evt.data.hide = false;
+ return true;
+ }
+ });
+ }, this, null, 0 );
+
+ this.parts.close.on( 'click', function( evt )
+ {
+ if ( this.fire( 'cancel', { hide : true } ).hide !== false )
+ this.hide();
+ }, this );
+
+ // Sort focus list according to tab order definitions.
+ function setupFocus()
+ {
+ var focusList = me._.focusList;
+ focusList.sort( function( a, b )
+ {
+ // Mimics browser tab order logics;
+ if ( a.tabIndex != b.tabIndex )
+ return b.tabIndex - a.tabIndex;
+ // Sort is not stable in some browsers,
+ // fall-back the comparator to 'focusIndex';
+ else
+ return a.focusIndex - b.focusIndex;
+ });
+
+ var size = focusList.length;
+ for ( var i = 0; i < size; i++ )
+ focusList[ i ].focusIndex = i;
+ }
+
+ function changeFocus( forward )
+ {
+ var focusList = me._.focusList,
+ offset = forward ? 1 : -1;
+ if ( focusList.length < 1 )
+ return;
+
+ var current = me._.currentFocusIndex;
+
+ // Trigger the 'blur' event of any input element before anything,
+ // since certain UI updates may depend on it.
+ try
+ {
+ focusList[ current ].getInputElement().$.blur();
+ }
+ catch( e ){}
+
+ var startIndex = ( current + offset + focusList.length ) % focusList.length,
+ currentIndex = startIndex;
+ while ( !focusList[ currentIndex ].isFocusable() )
+ {
+ currentIndex = ( currentIndex + offset + focusList.length ) % focusList.length;
+ if ( currentIndex == startIndex )
+ break;
+ }
+ focusList[ currentIndex ].focus();
+
+ // Select whole field content.
+ if ( focusList[ currentIndex ].type == 'text' )
+ focusList[ currentIndex ].select();
+ }
+
+ this.changeFocus = changeFocus;
+
+ var processed;
+
+ function focusKeydownHandler( evt )
+ {
+ // If I'm not the top dialog, ignore.
+ if ( me != CKEDITOR.dialog._.currentTop )
+ return;
+
+ var keystroke = evt.data.getKeystroke();
+
+ processed = 0;
+ if ( keystroke == 9 || keystroke == CKEDITOR.SHIFT + 9 )
+ {
+ var shiftPressed = ( keystroke == CKEDITOR.SHIFT + 9 );
+
+ // Handling Tab and Shift-Tab.
+ if ( me._.tabBarMode )
+ {
+ // Change tabs.
+ var nextId = shiftPressed ? getPreviousVisibleTab.call( me ) : getNextVisibleTab.call( me );
+ me.selectPage( nextId );
+ me._.tabs[ nextId ][ 0 ].focus();
+ }
+ else
+ {
+ // Change the focus of inputs.
+ changeFocus( !shiftPressed );
+ }
+
+ processed = 1;
+ }
+ else if ( keystroke == CKEDITOR.ALT + 121 && !me._.tabBarMode && me.getPageCount() > 1 )
+ {
+ // Alt-F10 puts focus into the current tab item in the tab bar.
+ me._.tabBarMode = true;
+ me._.tabs[ me._.currentTabId ][ 0 ].focus();
+ processed = 1;
+ }
+ else if ( ( keystroke == 37 || keystroke == 39 ) && me._.tabBarMode )
+ {
+ // Arrow keys - used for changing tabs.
+ nextId = ( keystroke == 37 ? getPreviousVisibleTab.call( me ) : getNextVisibleTab.call( me ) );
+ me.selectPage( nextId );
+ me._.tabs[ nextId ][ 0 ].focus();
+ processed = 1;
+ }
+ else if ( ( keystroke == 13 || keystroke == 32 ) && me._.tabBarMode )
+ {
+ this.selectPage( this._.currentTabId );
+ this._.tabBarMode = false;
+ this._.currentFocusIndex = -1;
+ changeFocus( true );
+ processed = 1;
+ }
+
+ if ( processed )
+ {
+ evt.stop();
+ evt.data.preventDefault();
+ }
+ }
+
+ function focusKeyPressHandler( evt )
+ {
+ processed && evt.data.preventDefault();
+ }
+
+ var dialogElement = this._.element;
+ // Add the dialog keyboard handlers.
+ this.on( 'show', function()
+ {
+ dialogElement.on( 'keydown', focusKeydownHandler, this, null, 0 );
+ // Some browsers instead, don't cancel key events in the keydown, but in the
+ // keypress. So we must do a longer trip in those cases. (#4531)
+ if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+ dialogElement.on( 'keypress', focusKeyPressHandler, this );
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ var coverDoc = coverElement.getChild( 0 ).getFrameDocument();
+ coverDoc.on( 'keydown', focusKeydownHandler, this, null, 0 );
+ }
+ } );
+ this.on( 'hide', function()
+ {
+ dialogElement.removeListener( 'keydown', focusKeydownHandler );
+ if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+ dialogElement.removeListener( 'keypress', focusKeyPressHandler );
+ } );
+ this.on( 'iframeAdded', function( evt )
+ {
+ var doc = new CKEDITOR.dom.document( evt.data.iframe.$.contentWindow.document );
+ doc.on( 'keydown', focusKeydownHandler, this, null, 0 );
+ } );
+
+ // Auto-focus logic in dialog.
+ this.on( 'show', function()
+ {
+ // Setup tabIndex on showing the dialog instead of on loading
+ // to allow dynamic tab order happen in dialog definition.
+ setupFocus();
+
+ if ( editor.config.dialog_startupFocusTab
+ && me._.tabIdList.length > 1 )
+ {
+ me._.tabBarMode = true;
+ me._.tabs[ me._.currentTabId ][ 0 ].focus();
+ }
+ else if ( !this._.hasFocus )
+ {
+ this._.currentFocusIndex = -1;
+
+ // Decide where to put the initial focus.
+ if ( definition.onFocus )
+ {
+ var initialFocus = definition.onFocus.call( this );
+ // Focus the field that the user specified.
+ initialFocus && initialFocus.focus();
+ }
+ // Focus the first field in layout order.
+ else
+ changeFocus( true );
+
+ /*
+ * IE BUG: If the initial focus went into a non-text element (e.g. button),
+ * then IE would still leave the caret inside the editing area.
+ */
+ if ( this._.editor.mode == 'wysiwyg' && CKEDITOR.env.ie )
+ {
+ var $selection = editor.document.$.selection,
+ $range = $selection.createRange();
+
+ if ( $range )
+ {
+ if ( $range.parentElement && $range.parentElement().ownerDocument == editor.document.$
+ || $range.item && $range.item( 0 ).ownerDocument == editor.document.$ )
+ {
+ var $myRange = document.body.createTextRange();
+ $myRange.moveToElementText( this.getElement().getFirst().$ );
+ $myRange.collapse( true );
+ $myRange.select();
+ }
+ }
+ }
+ }
+ }, this, null, 0xffffffff );
+
+ // IE6 BUG: Text fields and text areas are only half-rendered the first time the dialog appears in IE6 (#2661).
+ // This is still needed after [2708] and [2709] because text fields in hidden TR tags are still broken.
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ this.on( 'load', function( evt )
+ {
+ var outer = this.getElement(),
+ inner = outer.getFirst();
+ inner.remove();
+ inner.appendTo( outer );
+ }, this );
+ }
+
+ initDragAndDrop( this );
+ initResizeHandles( this );
+
+ // Insert the title.
+ ( new CKEDITOR.dom.text( definition.title, CKEDITOR.document ) ).appendTo( this.parts.title );
+
+ // Insert the tabs and contents.
+ for ( var i = 0 ; i < definition.contents.length ; i++ )
+ this.addPage( definition.contents[i] );
+
+ this.parts['tabs'].on( 'click', function( evt )
+ {
+ var target = evt.data.getTarget();
+ // If we aren't inside a tab, bail out.
+ if ( target.hasClass( 'cke_dialog_tab' ) )
+ {
+ var id = target.$.id;
+ this.selectPage( id.substr( 0, id.lastIndexOf( '_' ) ) );
+ if ( this._.tabBarMode )
+ {
+ this._.tabBarMode = false;
+ this._.currentFocusIndex = -1;
+ changeFocus( true );
+ }
+ evt.data.preventDefault();
+ }
+ }, this );
+
+ // Insert buttons.
+ var buttonsHtml = [],
+ buttons = CKEDITOR.dialog._.uiElementBuilders.hbox.build( this,
+ {
+ type : 'hbox',
+ className : 'cke_dialog_footer_buttons',
+ widths : [],
+ children : definition.buttons
+ }, buttonsHtml ).getChild();
+ this.parts.footer.setHtml( buttonsHtml.join( '' ) );
+
+ for ( i = 0 ; i < buttons.length ; i++ )
+ this._.buttons[ buttons[i].id ] = buttons[i];
+ };
+
+ // Focusable interface. Use it via dialog.addFocusable.
+ function Focusable( dialog, element, index )
+ {
+ this.element = element;
+ this.focusIndex = index;
+ // TODO: support tabIndex for focusables.
+ this.tabIndex = 0;
+ this.isFocusable = function()
+ {
+ return !element.getAttribute( 'disabled' ) && element.isVisible();
+ };
+ this.focus = function()
+ {
+ dialog._.currentFocusIndex = this.focusIndex;
+ this.element.focus();
+ };
+ // Bind events
+ element.on( 'keydown', function( e )
+ {
+ if ( e.data.getKeystroke() in { 32:1, 13:1 } )
+ this.fire( 'click' );
+ } );
+ element.on( 'focus', function()
+ {
+ this.fire( 'mouseover' );
+ } );
+ element.on( 'blur', function()
+ {
+ this.fire( 'mouseout' );
+ } );
+ }
+
+ CKEDITOR.dialog.prototype =
+ {
+ /**
+ * Resizes the dialog.
+ * @param {Number} width The width of the dialog in pixels.
+ * @param {Number} height The height of the dialog in pixels.
+ * @function
+ * @example
+ * dialogObj.resize( 800, 640 );
+ */
+ resize : (function()
+ {
+ return function( width, height )
+ {
+ if ( this._.contentSize && this._.contentSize.width == width && this._.contentSize.height == height )
+ return;
+
+ CKEDITOR.dialog.fire( 'resize',
+ {
+ dialog : this,
+ skin : this._.editor.skinName,
+ width : width,
+ height : height
+ }, this._.editor );
+
+ this._.contentSize = { width : width, height : height };
+ this._.updateSize = true;
+ };
+ })(),
+
+ /**
+ * Gets the current size of the dialog in pixels.
+ * @returns {Object} An object with "width" and "height" properties.
+ * @example
+ * var width = dialogObj.getSize().width;
+ */
+ getSize : function()
+ {
+ if ( !this._.updateSize )
+ return this._.size;
+ var element = this._.element.getFirst();
+ var size = this._.size = { width : element.$.offsetWidth || 0, height : element.$.offsetHeight || 0};
+
+ // If either the offsetWidth or offsetHeight is 0, the element isn't visible.
+ this._.updateSize = !size.width || !size.height;
+
+ return size;
+ },
+
+ /**
+ * Moves the dialog to an (x, y) coordinate relative to the window.
+ * @function
+ * @param {Number} x The target x-coordinate.
+ * @param {Number} y The target y-coordinate.
+ * @example
+ * dialogObj.move( 10, 40 );
+ */
+ move : (function()
+ {
+ var isFixed;
+ return function( x, y )
+ {
+ // The dialog may be fixed positioned or absolute positioned. Ask the
+ // browser what is the current situation first.
+ var element = this._.element.getFirst();
+ if ( isFixed === undefined )
+ isFixed = element.getComputedStyle( 'position' ) == 'fixed';
+
+ if ( isFixed && this._.position && this._.position.x == x && this._.position.y == y )
+ return;
+
+ // Save the current position.
+ this._.position = { x : x, y : y };
+
+ // If not fixed positioned, add scroll position to the coordinates.
+ if ( !isFixed )
+ {
+ var scrollPosition = CKEDITOR.document.getWindow().getScrollPosition();
+ x += scrollPosition.x;
+ y += scrollPosition.y;
+ }
+
+ element.setStyles(
+ {
+ 'left' : ( x > 0 ? x : 0 ) + 'px',
+ 'top' : ( y > 0 ? y : 0 ) + 'px'
+ });
+ };
+ })(),
+
+ /**
+ * Gets the dialog's position in the window.
+ * @returns {Object} An object with "x" and "y" properties.
+ * @example
+ * var dialogX = dialogObj.getPosition().x;
+ */
+ getPosition : function(){ return CKEDITOR.tools.extend( {}, this._.position ); },
+
+ /**
+ * Shows the dialog box.
+ * @example
+ * dialogObj.show();
+ */
+ show : function()
+ {
+ var editor = this._.editor;
+ if ( editor.mode == 'wysiwyg' && CKEDITOR.env.ie )
+ {
+ var selection = editor.getSelection();
+ selection && selection.lock();
+ }
+
+ // Insert the dialog's element to the root document.
+ var element = this._.element;
+ var definition = this.definition;
+ if ( !( element.getParent() && element.getParent().equals( CKEDITOR.document.getBody() ) ) )
+ element.appendTo( CKEDITOR.document.getBody() );
+ else
+ return;
+
+ // FIREFOX BUG: Fix vanishing caret for Firefox 2 or Gecko 1.8.
+ if ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 )
+ {
+ var dialogElement = this.parts.dialog;
+ dialogElement.setStyle( 'position', 'absolute' );
+ setTimeout( function()
+ {
+ dialogElement.setStyle( 'position', 'fixed' );
+ }, 0 );
+ }
+
+
+ // First, set the dialog to an appropriate size.
+ this.resize( definition.minWidth, definition.minHeight );
+
+ // Select the first tab by default.
+ this.selectPage( this.definition.contents[0].id );
+
+ // Reset all inputs back to their default value.
+ this.reset();
+
+ // Set z-index.
+ if ( CKEDITOR.dialog._.currentZIndex === null )
+ CKEDITOR.dialog._.currentZIndex = this._.editor.config.baseFloatZIndex;
+ this._.element.getFirst().setStyle( 'z-index', CKEDITOR.dialog._.currentZIndex += 10 );
+
+ // Maintain the dialog ordering and dialog cover.
+ // Also register key handlers if first dialog.
+ if ( CKEDITOR.dialog._.currentTop === null )
+ {
+ CKEDITOR.dialog._.currentTop = this;
+ this._.parentDialog = null;
+ addCover( this._.editor );
+
+ element.on( 'keydown', accessKeyDownHandler );
+ element.on( CKEDITOR.env.opera ? 'keypress' : 'keyup', accessKeyUpHandler );
+
+ // Prevent some keys from bubbling up. (#4269)
+ for ( var event in { keyup :1, keydown :1, keypress :1 } )
+ element.on( event, preventKeyBubbling );
+ }
+ else
+ {
+ this._.parentDialog = CKEDITOR.dialog._.currentTop;
+ var parentElement = this._.parentDialog.getElement().getFirst();
+ parentElement.$.style.zIndex -= Math.floor( this._.editor.config.baseFloatZIndex / 2 );
+ CKEDITOR.dialog._.currentTop = this;
+ }
+
+ // Register the Esc hotkeys.
+ registerAccessKey( this, this, '\x1b', null, function()
+ {
+ this.getButton( 'cancel' ) && this.getButton( 'cancel' ).click();
+ } );
+
+ // Reset the hasFocus state.
+ this._.hasFocus = false;
+
+ // Rearrange the dialog to the middle of the window.
+ CKEDITOR.tools.setTimeout( function()
+ {
+ var viewSize = CKEDITOR.document.getWindow().getViewPaneSize();
+ var dialogSize = this.getSize();
+
+ // We're using definition size for initial position because of
+ // offten corrupted data in offsetWidth at this point. (#4084)
+ this.move( ( viewSize.width - definition.minWidth ) / 2, ( viewSize.height - dialogSize.height ) / 2 );
+
+ this.parts.dialog.setStyle( 'visibility', '' );
+
+ // Execute onLoad for the first show.
+ this.fireOnce( 'load', {} );
+ this.fire( 'show', {} );
+ this._.editor.fire( 'dialogShow', this );
+
+ // Save the initial values of the dialog.
+ this.foreach( function( contentObj ) { contentObj.setInitValue && contentObj.setInitValue(); } );
+
+ },
+ 100, this );
+ },
+
+ /**
+ * Executes a function for each UI element.
+ * @param {Function} fn Function to execute for each UI element.
+ * @returns {CKEDITOR.dialog} The current dialog object.
+ */
+ foreach : function( fn )
+ {
+ for ( var i in this._.contents )
+ {
+ for ( var j in this._.contents[i] )
+ fn( this._.contents[i][j]);
+ }
+ return this;
+ },
+
+ /**
+ * Resets all input values in the dialog.
+ * @example
+ * dialogObj.reset();
+ * @returns {CKEDITOR.dialog} The current dialog object.
+ */
+ reset : (function()
+ {
+ var fn = function( widget ){ if ( widget.reset ) widget.reset(); };
+ return function(){ this.foreach( fn ); return this; };
+ })(),
+
+ setupContent : function()
+ {
+ var args = arguments;
+ this.foreach( function( widget )
+ {
+ if ( widget.setup )
+ widget.setup.apply( widget, args );
+ });
+ },
+
+ commitContent : function()
+ {
+ var args = arguments;
+ this.foreach( function( widget )
+ {
+ if ( widget.commit )
+ widget.commit.apply( widget, args );
+ });
+ },
+
+ /**
+ * Hides the dialog box.
+ * @example
+ * dialogObj.hide();
+ */
+ hide : function()
+ {
+ this.fire( 'hide', {} );
+ this._.editor.fire( 'dialogHide', this );
+
+ // Remove the dialog's element from the root document.
+ var element = this._.element;
+ if ( !element.getParent() )
+ return;
+
+ element.remove();
+ this.parts.dialog.setStyle( 'visibility', 'hidden' );
+
+ // Unregister all access keys associated with this dialog.
+ unregisterAccessKey( this );
+
+ // Maintain dialog ordering and remove cover if needed.
+ if ( !this._.parentDialog )
+ removeCover();
+ else
+ {
+ var parentElement = this._.parentDialog.getElement().getFirst();
+ parentElement.setStyle( 'z-index', parseInt( parentElement.$.style.zIndex, 10 ) + Math.floor( this._.editor.config.baseFloatZIndex / 2 ) );
+ }
+ CKEDITOR.dialog._.currentTop = this._.parentDialog;
+
+ // Deduct or clear the z-index.
+ if ( !this._.parentDialog )
+ {
+ CKEDITOR.dialog._.currentZIndex = null;
+
+ // Remove access key handlers.
+ element.removeListener( 'keydown', accessKeyDownHandler );
+ element.removeListener( CKEDITOR.env.opera ? 'keypress' : 'keyup', accessKeyUpHandler );
+
+ // Remove bubbling-prevention handler. (#4269)
+ for ( var event in { keyup :1, keydown :1, keypress :1 } )
+ element.removeListener( event, preventKeyBubbling );
+
+ var editor = this._.editor;
+ editor.focus();
+
+ if ( editor.mode == 'wysiwyg' && CKEDITOR.env.ie )
+ {
+ var selection = editor.getSelection();
+ selection && selection.unlock( true );
+ }
+ }
+ else
+ CKEDITOR.dialog._.currentZIndex -= 10;
+
+
+ // Reset the initial values of the dialog.
+ this.foreach( function( contentObj ) { contentObj.resetInitValue && contentObj.resetInitValue(); } );
+ },
+
+ /**
+ * Adds a tabbed page into the dialog.
+ * @param {Object} contents Content definition.
+ * @example
+ */
+ addPage : function( contents )
+ {
+ var pageHtml = [],
+ titleHtml = contents.label ? ' title="' + CKEDITOR.tools.htmlEncode( contents.label ) + '"' : '',
+ elements = contents.elements,
+ vbox = CKEDITOR.dialog._.uiElementBuilders.vbox.build( this,
+ {
+ type : 'vbox',
+ className : 'cke_dialog_page_contents',
+ children : contents.elements,
+ expand : !!contents.expand,
+ padding : contents.padding,
+ style : contents.style || 'width: 100%; height: 100%;'
+ }, pageHtml );
+
+ // Create the HTML for the tab and the content block.
+ var page = CKEDITOR.dom.element.createFromHtml( pageHtml.join( '' ) );
+ page.setAttribute( 'role', 'tabpanel' );
+
+ var env = CKEDITOR.env;
+ var tabId = contents.id + '_' + CKEDITOR.tools.getNextNumber(),
+ tab = CKEDITOR.dom.element.createFromHtml( [
+ ' 0 ? ' cke_last' : 'cke_first' ),
+ titleHtml,
+ ( !!contents.hidden ? ' style="display:none"' : '' ),
+ ' id="', tabId, '"',
+ env.gecko && env.version >= 10900 && !env.hc ? '' : ' href="javascript:void(0)"',
+ ' tabIndex="-1"',
+ ' hidefocus="true"',
+ ' role="tab">',
+ contents.label,
+ ''
+ ].join( '' ) );
+
+ page.setAttribute( 'aria-labelledby', tabId );
+
+ // Take records for the tabs and elements created.
+ this._.tabs[ contents.id ] = [ tab, page ];
+ this._.tabIdList.push( contents.id );
+ !contents.hidden && this._.pageCount++;
+ this._.lastTab = tab;
+ this.updateStyle();
+
+ var contentMap = this._.contents[ contents.id ] = {},
+ cursor,
+ children = vbox.getChild();
+
+ while ( ( cursor = children.shift() ) )
+ {
+ contentMap[ cursor.id ] = cursor;
+ if ( typeof( cursor.getChild ) == 'function' )
+ children.push.apply( children, cursor.getChild() );
+ }
+
+ // Attach the DOM nodes.
+
+ page.setAttribute( 'name', contents.id );
+ page.appendTo( this.parts.contents );
+
+ tab.unselectable();
+ this.parts.tabs.append( tab );
+
+ // Add access key handlers if access key is defined.
+ if ( contents.accessKey )
+ {
+ registerAccessKey( this, this, 'CTRL+' + contents.accessKey,
+ tabAccessKeyDown, tabAccessKeyUp );
+ this._.accessKeyMap[ 'CTRL+' + contents.accessKey ] = contents.id;
+ }
+ },
+
+ /**
+ * Activates a tab page in the dialog by its id.
+ * @param {String} id The id of the dialog tab to be activated.
+ * @example
+ * dialogObj.selectPage( 'tab_1' );
+ */
+ selectPage : function( id )
+ {
+ // Hide the non-selected tabs and pages.
+ for ( var i in this._.tabs )
+ {
+ var tab = this._.tabs[i][0],
+ page = this._.tabs[i][1];
+ if ( i != id )
+ {
+ tab.removeClass( 'cke_dialog_tab_selected' );
+ page.hide();
+ }
+ page.setAttribute( 'aria-hidden', i != id );
+ }
+
+ var selected = this._.tabs[id];
+ selected[0].addClass( 'cke_dialog_tab_selected' );
+ selected[1].show();
+ this._.currentTabId = id;
+ this._.currentTabIndex = CKEDITOR.tools.indexOf( this._.tabIdList, id );
+ },
+
+ // Dialog state-specific style updates.
+ updateStyle : function()
+ {
+ // If only a single page shown, a different style is used in the central pane.
+ this.parts.dialog[ ( this._.pageCount === 1 ? 'add' : 'remove' ) + 'Class' ]( 'cke_single_page' );
+ },
+
+ /**
+ * Hides a page's tab away from the dialog.
+ * @param {String} id The page's Id.
+ * @example
+ * dialog.hidePage( 'tab_3' );
+ */
+ hidePage : function( id )
+ {
+ var tab = this._.tabs[id] && this._.tabs[id][0];
+ if ( !tab || this._.pageCount == 1 )
+ return;
+ // Switch to other tab first when we're hiding the active tab.
+ else if ( id == this._.currentTabId )
+ this.selectPage( getPreviousVisibleTab.call( this ) );
+
+ tab.hide();
+ this._.pageCount--;
+ this.updateStyle();
+ },
+
+ /**
+ * Unhides a page's tab.
+ * @param {String} id The page's Id.
+ * @example
+ * dialog.showPage( 'tab_2' );
+ */
+ showPage : function( id )
+ {
+ var tab = this._.tabs[id] && this._.tabs[id][0];
+ if ( !tab )
+ return;
+ tab.show();
+ this._.pageCount++;
+ this.updateStyle();
+ },
+
+ /**
+ * Gets the root DOM element of the dialog.
+ * @returns {CKEDITOR.dom.element} The <span> element containing this dialog.
+ * @example
+ * var dialogElement = dialogObj.getElement().getFirst();
+ * dialogElement.setStyle( 'padding', '5px' );
+ */
+ getElement : function()
+ {
+ return this._.element;
+ },
+
+ /**
+ * Gets the name of the dialog.
+ * @returns {String} The name of this dialog.
+ * @example
+ * var dialogName = dialogObj.getName();
+ */
+ getName : function()
+ {
+ return this._.name;
+ },
+
+ /**
+ * Gets a dialog UI element object from a dialog page.
+ * @param {String} pageId id of dialog page.
+ * @param {String} elementId id of UI element.
+ * @example
+ * @returns {CKEDITOR.ui.dialog.uiElement} The dialog UI element.
+ */
+ getContentElement : function( pageId, elementId )
+ {
+ var page = this._.contents[ pageId ];
+ return page && page[ elementId ];
+ },
+
+ /**
+ * Gets the value of a dialog UI element.
+ * @param {String} pageId id of dialog page.
+ * @param {String} elementId id of UI element.
+ * @example
+ * @returns {Object} The value of the UI element.
+ */
+ getValueOf : function( pageId, elementId )
+ {
+ return this.getContentElement( pageId, elementId ).getValue();
+ },
+
+ /**
+ * Sets the value of a dialog UI element.
+ * @param {String} pageId id of the dialog page.
+ * @param {String} elementId id of the UI element.
+ * @param {Object} value The new value of the UI element.
+ * @example
+ */
+ setValueOf : function( pageId, elementId, value )
+ {
+ return this.getContentElement( pageId, elementId ).setValue( value );
+ },
+
+ /**
+ * Gets the UI element of a button in the dialog's button row.
+ * @param {String} id The id of the button.
+ * @example
+ * @returns {CKEDITOR.ui.dialog.button} The button object.
+ */
+ getButton : function( id )
+ {
+ return this._.buttons[ id ];
+ },
+
+ /**
+ * Simulates a click to a dialog button in the dialog's button row.
+ * @param {String} id The id of the button.
+ * @example
+ * @returns The return value of the dialog's "click" event.
+ */
+ click : function( id )
+ {
+ return this._.buttons[ id ].click();
+ },
+
+ /**
+ * Disables a dialog button.
+ * @param {String} id The id of the button.
+ * @example
+ */
+ disableButton : function( id )
+ {
+ return this._.buttons[ id ].disable();
+ },
+
+ /**
+ * Enables a dialog button.
+ * @param {String} id The id of the button.
+ * @example
+ */
+ enableButton : function( id )
+ {
+ return this._.buttons[ id ].enable();
+ },
+
+ /**
+ * Gets the number of pages in the dialog.
+ * @returns {Number} Page count.
+ */
+ getPageCount : function()
+ {
+ return this._.pageCount;
+ },
+
+ /**
+ * Gets the editor instance which opened this dialog.
+ * @returns {CKEDITOR.editor} Parent editor instances.
+ */
+ getParentEditor : function()
+ {
+ return this._.editor;
+ },
+
+ /**
+ * Gets the element that was selected when opening the dialog, if any.
+ * @returns {CKEDITOR.dom.element} The element that was selected, or null.
+ */
+ getSelectedElement : function()
+ {
+ return this.getParentEditor().getSelection().getSelectedElement();
+ },
+
+ /**
+ * Adds element to dialog's focusable list.
+ *
+ * @param {CKEDITOR.dom.element} element
+ * @param {Number} [index]
+ */
+ addFocusable: function( element, index ) {
+ if ( typeof index == 'undefined' )
+ {
+ index = this._.focusList.length;
+ this._.focusList.push( new Focusable( this, element, index ) );
+ }
+ else
+ {
+ this._.focusList.splice( index, 0, new Focusable( this, element, index ) );
+ for ( var i = index + 1 ; i < this._.focusList.length ; i++ )
+ this._.focusList[ i ].focusIndex++;
+ }
+ }
+ };
+
+ CKEDITOR.tools.extend( CKEDITOR.dialog,
+ /**
+ * @lends CKEDITOR.dialog
+ */
+ {
+ /**
+ * Registers a dialog.
+ * @param {String} name The dialog's name.
+ * @param {Function|String} dialogDefinition
+ * A function returning the dialog's definition, or the URL to the .js file holding the function.
+ * The function should accept an argument "editor" which is the current editor instance, and
+ * return an object conforming to {@link CKEDITOR.dialog.dialogDefinition}.
+ * @example
+ * @see CKEDITOR.dialog.dialogDefinition
+ */
+ add : function( name, dialogDefinition )
+ {
+ // Avoid path registration from multiple instances override definition.
+ if ( !this._.dialogDefinitions[name]
+ || typeof dialogDefinition == 'function' )
+ this._.dialogDefinitions[name] = dialogDefinition;
+ },
+
+ exists : function( name )
+ {
+ return !!this._.dialogDefinitions[ name ];
+ },
+
+ getCurrent : function()
+ {
+ return CKEDITOR.dialog._.currentTop;
+ },
+
+ /**
+ * The default OK button for dialogs. Fires the "ok" event and closes the dialog if the event succeeds.
+ * @static
+ * @field
+ * @example
+ * @type Function
+ */
+ okButton : (function()
+ {
+ var retval = function( editor, override )
+ {
+ override = override || {};
+ return CKEDITOR.tools.extend( {
+ id : 'ok',
+ type : 'button',
+ label : editor.lang.common.ok,
+ 'class' : 'cke_dialog_ui_button_ok',
+ onClick : function( evt )
+ {
+ var dialog = evt.data.dialog;
+ if ( dialog.fire( 'ok', { hide : true } ).hide !== false )
+ dialog.hide();
+ }
+ }, override, true );
+ };
+ retval.type = 'button';
+ retval.override = function( override )
+ {
+ return CKEDITOR.tools.extend( function( editor ){ return retval( editor, override ); },
+ { type : 'button' }, true );
+ };
+ return retval;
+ })(),
+
+ /**
+ * The default cancel button for dialogs. Fires the "cancel" event and closes the dialog if no UI element value changed.
+ * @static
+ * @field
+ * @example
+ * @type Function
+ */
+ cancelButton : (function()
+ {
+ var retval = function( editor, override )
+ {
+ override = override || {};
+ return CKEDITOR.tools.extend( {
+ id : 'cancel',
+ type : 'button',
+ label : editor.lang.common.cancel,
+ 'class' : 'cke_dialog_ui_button_cancel',
+ onClick : function( evt )
+ {
+ var dialog = evt.data.dialog;
+ if ( dialog.fire( 'cancel', { hide : true } ).hide !== false )
+ dialog.hide();
+ }
+ }, override, true );
+ };
+ retval.type = 'button';
+ retval.override = function( override )
+ {
+ return CKEDITOR.tools.extend( function( editor ){ return retval( editor, override ); },
+ { type : 'button' }, true );
+ };
+ return retval;
+ })(),
+
+ /**
+ * Registers a dialog UI element.
+ * @param {String} typeName The name of the UI element.
+ * @param {Function} builder The function to build the UI element.
+ * @example
+ */
+ addUIElement : function( typeName, builder )
+ {
+ this._.uiElementBuilders[ typeName ] = builder;
+ }
+ });
+
+ CKEDITOR.dialog._ =
+ {
+ uiElementBuilders : {},
+
+ dialogDefinitions : {},
+
+ currentTop : null,
+
+ currentZIndex : null
+ };
+
+ // "Inherit" (copy actually) from CKEDITOR.event.
+ CKEDITOR.event.implementOn( CKEDITOR.dialog );
+ CKEDITOR.event.implementOn( CKEDITOR.dialog.prototype, true );
+
+ var defaultDialogDefinition =
+ {
+ resizable : CKEDITOR.DIALOG_RESIZE_BOTH,
+ minWidth : 600,
+ minHeight : 400,
+ buttons : [ CKEDITOR.dialog.okButton, CKEDITOR.dialog.cancelButton ]
+ };
+
+ // The buttons in MacOS Apps are in reverse order #4750
+ CKEDITOR.env.mac && defaultDialogDefinition.buttons.reverse();
+
+ // Tool function used to return an item from an array based on its id
+ // property.
+ var getById = function( array, id, recurse )
+ {
+ for ( var i = 0, item ; ( item = array[ i ] ) ; i++ )
+ {
+ if ( item.id == id )
+ return item;
+ if ( recurse && item[ recurse ] )
+ {
+ var retval = getById( item[ recurse ], id, recurse ) ;
+ if ( retval )
+ return retval;
+ }
+ }
+ return null;
+ };
+
+ // Tool function used to add an item into an array.
+ var addById = function( array, newItem, nextSiblingId, recurse, nullIfNotFound )
+ {
+ if ( nextSiblingId )
+ {
+ for ( var i = 0, item ; ( item = array[ i ] ) ; i++ )
+ {
+ if ( item.id == nextSiblingId )
+ {
+ array.splice( i, 0, newItem );
+ return newItem;
+ }
+
+ if ( recurse && item[ recurse ] )
+ {
+ var retval = addById( item[ recurse ], newItem, nextSiblingId, recurse, true );
+ if ( retval )
+ return retval;
+ }
+ }
+
+ if ( nullIfNotFound )
+ return null;
+ }
+
+ array.push( newItem );
+ return newItem;
+ };
+
+ // Tool function used to remove an item from an array based on its id.
+ var removeById = function( array, id, recurse )
+ {
+ for ( var i = 0, item ; ( item = array[ i ] ) ; i++ )
+ {
+ if ( item.id == id )
+ return array.splice( i, 1 );
+ if ( recurse && item[ recurse ] )
+ {
+ var retval = removeById( item[ recurse ], id, recurse );
+ if ( retval )
+ return retval;
+ }
+ }
+ return null;
+ };
+
+ /**
+ * This class is not really part of the API. It is the "definition" property value
+ * passed to "dialogDefinition" event handlers.
+ * @constructor
+ * @name CKEDITOR.dialog.dialogDefinitionObject
+ * @extends CKEDITOR.dialog.dialogDefinition
+ * @example
+ * CKEDITOR.on( 'dialogDefinition', function( evt )
+ * {
+ * var definition = evt.data.definition;
+ * var content = definition.getContents( 'page1' );
+ * ...
+ * } );
+ */
+ var definitionObject = function( dialog, dialogDefinition )
+ {
+ // TODO : Check if needed.
+ this.dialog = dialog;
+
+ // Transform the contents entries in contentObjects.
+ var contents = dialogDefinition.contents;
+ for ( var i = 0, content ; ( content = contents[i] ) ; i++ )
+ contents[ i ] = new contentObject( dialog, content );
+
+ CKEDITOR.tools.extend( this, dialogDefinition );
+ };
+
+ definitionObject.prototype =
+ /** @lends CKEDITOR.dialog.dialogDefinitionObject.prototype */
+ {
+ /**
+ * Gets a content definition.
+ * @param {String} id The id of the content definition.
+ * @returns {CKEDITOR.dialog.contentDefinition} The content definition
+ * matching id.
+ */
+ getContents : function( id )
+ {
+ return getById( this.contents, id );
+ },
+
+ /**
+ * Gets a button definition.
+ * @param {String} id The id of the button definition.
+ * @returns {CKEDITOR.dialog.buttonDefinition} The button definition
+ * matching id.
+ */
+ getButton : function( id )
+ {
+ return getById( this.buttons, id );
+ },
+
+ /**
+ * Adds a content definition object under this dialog definition.
+ * @param {CKEDITOR.dialog.contentDefinition} contentDefinition The
+ * content definition.
+ * @param {String} [nextSiblingId] The id of an existing content
+ * definition which the new content definition will be inserted
+ * before. Omit if the new content definition is to be inserted as
+ * the last item.
+ * @returns {CKEDITOR.dialog.contentDefinition} The inserted content
+ * definition.
+ */
+ addContents : function( contentDefinition, nextSiblingId )
+ {
+ return addById( this.contents, contentDefinition, nextSiblingId );
+ },
+
+ /**
+ * Adds a button definition object under this dialog definition.
+ * @param {CKEDITOR.dialog.buttonDefinition} buttonDefinition The
+ * button definition.
+ * @param {String} [nextSiblingId] The id of an existing button
+ * definition which the new button definition will be inserted
+ * before. Omit if the new button definition is to be inserted as
+ * the last item.
+ * @returns {CKEDITOR.dialog.buttonDefinition} The inserted button
+ * definition.
+ */
+ addButton : function( buttonDefinition, nextSiblingId )
+ {
+ return addById( this.buttons, buttonDefinition, nextSiblingId );
+ },
+
+ /**
+ * Removes a content definition from this dialog definition.
+ * @param {String} id The id of the content definition to be removed.
+ * @returns {CKEDITOR.dialog.contentDefinition} The removed content
+ * definition.
+ */
+ removeContents : function( id )
+ {
+ removeById( this.contents, id );
+ },
+
+ /**
+ * Removes a button definition from the dialog definition.
+ * @param {String} id The id of the button definition to be removed.
+ * @returns {CKEDITOR.dialog.buttonDefinition} The removed button
+ * definition.
+ */
+ removeButton : function( id )
+ {
+ removeById( this.buttons, id );
+ }
+ };
+
+ /**
+ * This class is not really part of the API. It is the template of the
+ * objects representing content pages inside the
+ * CKEDITOR.dialog.dialogDefinitionObject.
+ * @constructor
+ * @name CKEDITOR.dialog.contentDefinitionObject
+ * @example
+ * CKEDITOR.on( 'dialogDefinition', function( evt )
+ * {
+ * var definition = evt.data.definition;
+ * var content = definition.getContents( 'page1' );
+ * content.remove( 'textInput1' );
+ * ...
+ * } );
+ */
+ function contentObject( dialog, contentDefinition )
+ {
+ this._ =
+ {
+ dialog : dialog
+ };
+
+ CKEDITOR.tools.extend( this, contentDefinition );
+ }
+
+ contentObject.prototype =
+ /** @lends CKEDITOR.dialog.contentDefinitionObject.prototype */
+ {
+ /**
+ * Gets a UI element definition under the content definition.
+ * @param {String} id The id of the UI element definition.
+ * @returns {CKEDITOR.dialog.uiElementDefinition}
+ */
+ get : function( id )
+ {
+ return getById( this.elements, id, 'children' );
+ },
+
+ /**
+ * Adds a UI element definition to the content definition.
+ * @param {CKEDITOR.dialog.uiElementDefinition} elementDefinition The
+ * UI elemnet definition to be added.
+ * @param {String} nextSiblingId The id of an existing UI element
+ * definition which the new UI element definition will be inserted
+ * before. Omit if the new button definition is to be inserted as
+ * the last item.
+ * @returns {CKEDITOR.dialog.uiElementDefinition} The element
+ * definition inserted.
+ */
+ add : function( elementDefinition, nextSiblingId )
+ {
+ return addById( this.elements, elementDefinition, nextSiblingId, 'children' );
+ },
+
+ /**
+ * Removes a UI element definition from the content definition.
+ * @param {String} id The id of the UI element definition to be
+ * removed.
+ * @returns {CKEDITOR.dialog.uiElementDefinition} The element
+ * definition removed.
+ * @example
+ */
+ remove : function( id )
+ {
+ removeById( this.elements, id, 'children' );
+ }
+ };
+
+ function initDragAndDrop( dialog )
+ {
+ var lastCoords = null,
+ abstractDialogCoords = null,
+ element = dialog.getElement().getFirst(),
+ editor = dialog.getParentEditor(),
+ magnetDistance = editor.config.dialog_magnetDistance,
+ margins = editor.skin.margins || [ 0, 0, 0, 0 ];
+
+ if ( typeof magnetDistance == 'undefined' )
+ magnetDistance = 20;
+
+ function mouseMoveHandler( evt )
+ {
+ var dialogSize = dialog.getSize(),
+ viewPaneSize = CKEDITOR.document.getWindow().getViewPaneSize(),
+ x = evt.data.$.screenX,
+ y = evt.data.$.screenY,
+ dx = x - lastCoords.x,
+ dy = y - lastCoords.y,
+ realX, realY;
+
+ lastCoords = { x : x, y : y };
+ abstractDialogCoords.x += dx;
+ abstractDialogCoords.y += dy;
+
+ if ( abstractDialogCoords.x + margins[3] < magnetDistance )
+ realX = - margins[3];
+ else if ( abstractDialogCoords.x - margins[1] > viewPaneSize.width - dialogSize.width - magnetDistance )
+ realX = viewPaneSize.width - dialogSize.width + margins[1];
+ else
+ realX = abstractDialogCoords.x;
+
+ if ( abstractDialogCoords.y + margins[0] < magnetDistance )
+ realY = - margins[0];
+ else if ( abstractDialogCoords.y - margins[2] > viewPaneSize.height - dialogSize.height - magnetDistance )
+ realY = viewPaneSize.height - dialogSize.height + margins[2];
+ else
+ realY = abstractDialogCoords.y;
+
+ dialog.move( realX, realY );
+
+ evt.data.preventDefault();
+ }
+
+ function mouseUpHandler( evt )
+ {
+ CKEDITOR.document.removeListener( 'mousemove', mouseMoveHandler );
+ CKEDITOR.document.removeListener( 'mouseup', mouseUpHandler );
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ var coverDoc = coverElement.getChild( 0 ).getFrameDocument();
+ coverDoc.removeListener( 'mousemove', mouseMoveHandler );
+ coverDoc.removeListener( 'mouseup', mouseUpHandler );
+ }
+ }
+
+ dialog.parts.title.on( 'mousedown', function( evt )
+ {
+ dialog._.updateSize = true;
+
+ lastCoords = { x : evt.data.$.screenX, y : evt.data.$.screenY };
+
+ CKEDITOR.document.on( 'mousemove', mouseMoveHandler );
+ CKEDITOR.document.on( 'mouseup', mouseUpHandler );
+ abstractDialogCoords = dialog.getPosition();
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ var coverDoc = coverElement.getChild( 0 ).getFrameDocument();
+ coverDoc.on( 'mousemove', mouseMoveHandler );
+ coverDoc.on( 'mouseup', mouseUpHandler );
+ }
+
+ evt.data.preventDefault();
+ }, dialog );
+ }
+
+ function initResizeHandles( dialog )
+ {
+ var definition = dialog.definition,
+ minWidth = definition.minWidth || 0,
+ minHeight = definition.minHeight || 0,
+ resizable = definition.resizable,
+ margins = dialog.getParentEditor().skin.margins || [ 0, 0, 0, 0 ];
+
+ function topSizer( coords, dy )
+ {
+ coords.y += dy;
+ }
+
+ function rightSizer( coords, dx )
+ {
+ coords.x2 += dx;
+ }
+
+ function bottomSizer( coords, dy )
+ {
+ coords.y2 += dy;
+ }
+
+ function leftSizer( coords, dx )
+ {
+ coords.x += dx;
+ }
+
+ var lastCoords = null,
+ abstractDialogCoords = null,
+ magnetDistance = dialog._.editor.config.magnetDistance,
+ parts = [ 'tl', 't', 'tr', 'l', 'r', 'bl', 'b', 'br' ];
+
+ function mouseDownHandler( evt )
+ {
+ var partName = evt.listenerData.part, size = dialog.getSize();
+ abstractDialogCoords = dialog.getPosition();
+ CKEDITOR.tools.extend( abstractDialogCoords,
+ {
+ x2 : abstractDialogCoords.x + size.width,
+ y2 : abstractDialogCoords.y + size.height
+ } );
+ lastCoords = { x : evt.data.$.screenX, y : evt.data.$.screenY };
+
+ CKEDITOR.document.on( 'mousemove', mouseMoveHandler, dialog, { part : partName } );
+ CKEDITOR.document.on( 'mouseup', mouseUpHandler, dialog, { part : partName } );
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ var coverDoc = coverElement.getChild( 0 ).getFrameDocument();
+ coverDoc.on( 'mousemove', mouseMoveHandler, dialog, { part : partName } );
+ coverDoc.on( 'mouseup', mouseUpHandler, dialog, { part : partName } );
+ }
+
+ evt.data.preventDefault();
+ }
+
+ function mouseMoveHandler( evt )
+ {
+ var x = evt.data.$.screenX,
+ y = evt.data.$.screenY,
+ dx = x - lastCoords.x,
+ dy = y - lastCoords.y,
+ viewPaneSize = CKEDITOR.document.getWindow().getViewPaneSize(),
+ partName = evt.listenerData.part;
+
+ if ( partName.search( 't' ) != -1 )
+ topSizer( abstractDialogCoords, dy );
+ if ( partName.search( 'l' ) != -1 )
+ leftSizer( abstractDialogCoords, dx );
+ if ( partName.search( 'b' ) != -1 )
+ bottomSizer( abstractDialogCoords, dy );
+ if ( partName.search( 'r' ) != -1 )
+ rightSizer( abstractDialogCoords, dx );
+
+ lastCoords = { x : x, y : y };
+
+ var realX, realY, realX2, realY2;
+
+ if ( abstractDialogCoords.x + margins[3] < magnetDistance )
+ realX = - margins[3];
+ else if ( partName.search( 'l' ) != -1 && abstractDialogCoords.x2 - abstractDialogCoords.x < minWidth + magnetDistance )
+ realX = abstractDialogCoords.x2 - minWidth;
+ else
+ realX = abstractDialogCoords.x;
+
+ if ( abstractDialogCoords.y + margins[0] < magnetDistance )
+ realY = - margins[0];
+ else if ( partName.search( 't' ) != -1 && abstractDialogCoords.y2 - abstractDialogCoords.y < minHeight + magnetDistance )
+ realY = abstractDialogCoords.y2 - minHeight;
+ else
+ realY = abstractDialogCoords.y;
+
+ if ( abstractDialogCoords.x2 - margins[1] > viewPaneSize.width - magnetDistance )
+ realX2 = viewPaneSize.width + margins[1] ;
+ else if ( partName.search( 'r' ) != -1 && abstractDialogCoords.x2 - abstractDialogCoords.x < minWidth + magnetDistance )
+ realX2 = abstractDialogCoords.x + minWidth;
+ else
+ realX2 = abstractDialogCoords.x2;
+
+ if ( abstractDialogCoords.y2 - margins[2] > viewPaneSize.height - magnetDistance )
+ realY2= viewPaneSize.height + margins[2] ;
+ else if ( partName.search( 'b' ) != -1 && abstractDialogCoords.y2 - abstractDialogCoords.y < minHeight + magnetDistance )
+ realY2 = abstractDialogCoords.y + minHeight;
+ else
+ realY2 = abstractDialogCoords.y2 ;
+
+ dialog.move( realX, realY );
+ dialog.resize( realX2 - realX, realY2 - realY );
+
+ evt.data.preventDefault();
+ }
+
+ function mouseUpHandler( evt )
+ {
+ CKEDITOR.document.removeListener( 'mouseup', mouseUpHandler );
+ CKEDITOR.document.removeListener( 'mousemove', mouseMoveHandler );
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ var coverDoc = coverElement.getChild( 0 ).getFrameDocument();
+ coverDoc.removeListener( 'mouseup', mouseUpHandler );
+ coverDoc.removeListener( 'mousemove', mouseMoveHandler );
+ }
+ }
+
+// TODO : Simplify the resize logic, having just a single resize grip .
+// var widthTest = /[lr]/,
+// heightTest = /[tb]/;
+// for ( var i = 0 ; i < parts.length ; i++ )
+// {
+// var element = dialog.parts[ parts[i] + '_resize' ];
+// if ( resizable == CKEDITOR.DIALOG_RESIZE_NONE ||
+// resizable == CKEDITOR.DIALOG_RESIZE_HEIGHT && widthTest.test( parts[i] ) ||
+// resizable == CKEDITOR.DIALOG_RESIZE_WIDTH && heightTest.test( parts[i] ) )
+// {
+// element.hide();
+// continue;
+// }
+// element.on( 'mousedown', mouseDownHandler, dialog, { part : parts[i] } );
+// }
+ }
+
+ var resizeCover;
+ var coverElement;
+
+ var addCover = function( editor )
+ {
+ var win = CKEDITOR.document.getWindow();
+
+ if ( !coverElement )
+ {
+ var backgroundColorStyle = editor.config.dialog_backgroundCoverColor || 'white';
+
+ var html = [
+ '
'
+ ];
+
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ // Support for custom document.domain in IE.
+ var isCustomDomain = CKEDITOR.env.isCustomDomain(),
+ iframeHtml = '';
+
+ html.push(
+ '' +
+ '' );
+ }
+
+ html.push( '
' );
+
+ coverElement = CKEDITOR.dom.element.createFromHtml( html.join( '' ) );
+ }
+
+ var element = coverElement;
+
+ var resizeFunc = function()
+ {
+ var size = win.getViewPaneSize();
+ element.setStyles(
+ {
+ width : size.width + 'px',
+ height : size.height + 'px'
+ } );
+ };
+
+ var scrollFunc = function()
+ {
+ var pos = win.getScrollPosition(),
+ cursor = CKEDITOR.dialog._.currentTop;
+ element.setStyles(
+ {
+ left : pos.x + 'px',
+ top : pos.y + 'px'
+ });
+
+ do
+ {
+ var dialogPos = cursor.getPosition();
+ cursor.move( dialogPos.x, dialogPos.y );
+ } while ( ( cursor = cursor._.parentDialog ) );
+ };
+
+ resizeCover = resizeFunc;
+ win.on( 'resize', resizeFunc );
+ resizeFunc();
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ // IE BUG: win.$.onscroll assignment doesn't work.. it must be window.onscroll.
+ // So we need to invent a really funny way to make it work.
+ var myScrollHandler = function()
+ {
+ scrollFunc();
+ arguments.callee.prevScrollHandler.apply( this, arguments );
+ };
+ win.$.setTimeout( function()
+ {
+ myScrollHandler.prevScrollHandler = window.onscroll || function(){};
+ window.onscroll = myScrollHandler;
+ }, 0 );
+ scrollFunc();
+ }
+
+ var opacity = editor.config.dialog_backgroundCoverOpacity;
+ element.setOpacity( typeof opacity != 'undefined' ? opacity : 0.5 );
+
+ element.appendTo( CKEDITOR.document.getBody() );
+ };
+
+ var removeCover = function()
+ {
+ if ( !coverElement )
+ return;
+
+ var win = CKEDITOR.document.getWindow();
+ coverElement.remove();
+ win.removeListener( 'resize', resizeCover );
+
+ if ( CKEDITOR.env.ie6Compat )
+ {
+ win.$.setTimeout( function()
+ {
+ var prevScrollHandler = window.onscroll && window.onscroll.prevScrollHandler;
+ window.onscroll = prevScrollHandler || null;
+ }, 0 );
+ }
+ resizeCover = null;
+ };
+
+ var accessKeyProcessors = {};
+
+ var accessKeyDownHandler = function( evt )
+ {
+ var ctrl = evt.data.$.ctrlKey || evt.data.$.metaKey,
+ alt = evt.data.$.altKey,
+ shift = evt.data.$.shiftKey,
+ key = String.fromCharCode( evt.data.$.keyCode ),
+ keyProcessor = accessKeyProcessors[( ctrl ? 'CTRL+' : '' ) + ( alt ? 'ALT+' : '') + ( shift ? 'SHIFT+' : '' ) + key];
+
+ if ( !keyProcessor || !keyProcessor.length )
+ return;
+
+ keyProcessor = keyProcessor[keyProcessor.length - 1];
+ keyProcessor.keydown && keyProcessor.keydown.call( keyProcessor.uiElement, keyProcessor.dialog, keyProcessor.key );
+ evt.data.preventDefault();
+ };
+
+ var accessKeyUpHandler = function( evt )
+ {
+ var ctrl = evt.data.$.ctrlKey || evt.data.$.metaKey,
+ alt = evt.data.$.altKey,
+ shift = evt.data.$.shiftKey,
+ key = String.fromCharCode( evt.data.$.keyCode ),
+ keyProcessor = accessKeyProcessors[( ctrl ? 'CTRL+' : '' ) + ( alt ? 'ALT+' : '') + ( shift ? 'SHIFT+' : '' ) + key];
+
+ if ( !keyProcessor || !keyProcessor.length )
+ return;
+
+ keyProcessor = keyProcessor[keyProcessor.length - 1];
+ if ( keyProcessor.keyup )
+ {
+ keyProcessor.keyup.call( keyProcessor.uiElement, keyProcessor.dialog, keyProcessor.key );
+ evt.data.preventDefault();
+ }
+ };
+
+ var registerAccessKey = function( uiElement, dialog, key, downFunc, upFunc )
+ {
+ var procList = accessKeyProcessors[key] || ( accessKeyProcessors[key] = [] );
+ procList.push( {
+ uiElement : uiElement,
+ dialog : dialog,
+ key : key,
+ keyup : upFunc || uiElement.accessKeyUp,
+ keydown : downFunc || uiElement.accessKeyDown
+ } );
+ };
+
+ var unregisterAccessKey = function( obj )
+ {
+ for ( var i in accessKeyProcessors )
+ {
+ var list = accessKeyProcessors[i];
+ for ( var j = list.length - 1 ; j >= 0 ; j-- )
+ {
+ if ( list[j].dialog == obj || list[j].uiElement == obj )
+ list.splice( j, 1 );
+ }
+ if ( list.length === 0 )
+ delete accessKeyProcessors[i];
+ }
+ };
+
+ var tabAccessKeyUp = function( dialog, key )
+ {
+ if ( dialog._.accessKeyMap[key] )
+ dialog.selectPage( dialog._.accessKeyMap[key] );
+ };
+
+ var tabAccessKeyDown = function( dialog, key )
+ {
+ };
+
+ // ESC, ENTER
+ var preventKeyBubblingKeys = { 27 :1, 13 :1 };
+ var preventKeyBubbling = function( e )
+ {
+ if ( e.data.getKeystroke() in preventKeyBubblingKeys )
+ e.data.stopPropagation();
+ };
+
+ (function()
+ {
+ CKEDITOR.ui.dialog =
+ {
+ /**
+ * The base class of all dialog UI elements.
+ * @constructor
+ * @param {CKEDITOR.dialog} dialog Parent dialog object.
+ * @param {CKEDITOR.dialog.uiElementDefinition} elementDefinition Element
+ * definition. Accepted fields:
+ *
+ * - id (Required) The id of the UI element. See {@link
+ * CKEDITOR.dialog#getContentElement}
+ * - type (Required) The type of the UI element. The
+ * value to this field specifies which UI element class will be used to
+ * generate the final widget.
+ * - title (Optional) The popup tooltip for the UI
+ * element.
+ * - hidden (Optional) A flag that tells if the element
+ * should be initially visible.
+ * - className (Optional) Additional CSS class names
+ * to add to the UI element. Separated by space.
+ * - style (Optional) Additional CSS inline styles
+ * to add to the UI element. A semicolon (;) is required after the last
+ * style declaration.
+ * - accessKey (Optional) The alphanumeric access key
+ * for this element. Access keys are automatically prefixed by CTRL.
+ * - on* (Optional) Any UI element definition field that
+ * starts with on followed immediately by a capital letter and
+ * probably more letters is an event handler. Event handlers may be further
+ * divided into registered event handlers and DOM event handlers. Please
+ * refer to {@link CKEDITOR.ui.dialog.uiElement#registerEvents} and
+ * {@link CKEDITOR.ui.dialog.uiElement#eventProcessors} for more
+ * information.
+ *
+ * @param {Array} htmlList
+ * List of HTML code to be added to the dialog's content area.
+ * @param {Function|String} nodeNameArg
+ * A function returning a string, or a simple string for the node name for
+ * the root DOM node. Default is 'div'.
+ * @param {Function|Object} stylesArg
+ * A function returning an object, or a simple object for CSS styles applied
+ * to the DOM node. Default is empty object.
+ * @param {Function|Object} attributesArg
+ * A fucntion returning an object, or a simple object for attributes applied
+ * to the DOM node. Default is empty object.
+ * @param {Function|String} contentsArg
+ * A function returning a string, or a simple string for the HTML code inside
+ * the root DOM node. Default is empty string.
+ * @example
+ */
+ uiElement : function( dialog, elementDefinition, htmlList, nodeNameArg, stylesArg, attributesArg, contentsArg )
+ {
+ if ( arguments.length < 4 )
+ return;
+
+ var nodeName = ( nodeNameArg.call ? nodeNameArg( elementDefinition ) : nodeNameArg ) || 'div',
+ html = [ '<', nodeName, ' ' ],
+ styles = ( stylesArg && stylesArg.call ? stylesArg( elementDefinition ) : stylesArg ) || {},
+ attributes = ( attributesArg && attributesArg.call ? attributesArg( elementDefinition ) : attributesArg ) || {},
+ innerHTML = ( contentsArg && contentsArg.call ? contentsArg.call( this, dialog, elementDefinition ) : contentsArg ) || '',
+ domId = this.domId = attributes.id || CKEDITOR.tools.getNextNumber() + '_uiElement',
+ id = this.id = elementDefinition.id,
+ i;
+
+ // Set the id, a unique id is required for getElement() to work.
+ attributes.id = domId;
+
+ // Set the type and definition CSS class names.
+ var classes = {};
+ if ( elementDefinition.type )
+ classes[ 'cke_dialog_ui_' + elementDefinition.type ] = 1;
+ if ( elementDefinition.className )
+ classes[ elementDefinition.className ] = 1;
+ var attributeClasses = ( attributes['class'] && attributes['class'].split ) ? attributes['class'].split( ' ' ) : [];
+ for ( i = 0 ; i < attributeClasses.length ; i++ )
+ {
+ if ( attributeClasses[i] )
+ classes[ attributeClasses[i] ] = 1;
+ }
+ var finalClasses = [];
+ for ( i in classes )
+ finalClasses.push( i );
+ attributes['class'] = finalClasses.join( ' ' );
+
+ // Set the popup tooltop.
+ if ( elementDefinition.title )
+ attributes.title = elementDefinition.title;
+
+ // Write the inline CSS styles.
+ var styleStr = ( elementDefinition.style || '' ).split( ';' );
+ for ( i in styles )
+ styleStr.push( i + ':' + styles[i] );
+ if ( elementDefinition.hidden )
+ styleStr.push( 'display:none' );
+ for ( i = styleStr.length - 1 ; i >= 0 ; i-- )
+ {
+ if ( styleStr[i] === '' )
+ styleStr.splice( i, 1 );
+ }
+ if ( styleStr.length > 0 )
+ attributes.style = ( attributes.style ? ( attributes.style + '; ' ) : '' ) + styleStr.join( '; ' );
+
+ // Write the attributes.
+ for ( i in attributes )
+ html.push( i + '="' + CKEDITOR.tools.htmlEncode( attributes[i] ) + '" ');
+
+ // Write the content HTML.
+ html.push( '>', innerHTML, '' );
+
+ // Add contents to the parent HTML array.
+ htmlList.push( html.join( '' ) );
+
+ ( this._ || ( this._ = {} ) ).dialog = dialog;
+
+ // Override isChanged if it is defined in element definition.
+ if ( typeof( elementDefinition.isChanged ) == 'boolean' )
+ this.isChanged = function(){ return elementDefinition.isChanged; };
+ if ( typeof( elementDefinition.isChanged ) == 'function' )
+ this.isChanged = elementDefinition.isChanged;
+
+ // Add events.
+ CKEDITOR.event.implementOn( this );
+
+ this.registerEvents( elementDefinition );
+ if ( this.accessKeyUp && this.accessKeyDown && elementDefinition.accessKey )
+ registerAccessKey( this, dialog, 'CTRL+' + elementDefinition.accessKey );
+
+ var me = this;
+ dialog.on( 'load', function()
+ {
+ if ( me.getInputElement() )
+ {
+ me.getInputElement().on( 'focus', function()
+ {
+ dialog._.tabBarMode = false;
+ dialog._.hasFocus = true;
+ me.fire( 'focus' );
+ }, me );
+ }
+ } );
+
+ // Register the object as a tab focus if it can be included.
+ if ( this.keyboardFocusable )
+ {
+ this.tabIndex = elementDefinition.tabIndex || 0;
+
+ this.focusIndex = dialog._.focusList.push( this ) - 1;
+ this.on( 'focus', function()
+ {
+ dialog._.currentFocusIndex = me.focusIndex;
+ } );
+ }
+
+ // Completes this object with everything we have in the
+ // definition.
+ CKEDITOR.tools.extend( this, elementDefinition );
+ },
+
+ /**
+ * Horizontal layout box for dialog UI elements, auto-expends to available width of container.
+ * @constructor
+ * @extends CKEDITOR.ui.dialog.uiElement
+ * @param {CKEDITOR.dialog} dialog
+ * Parent dialog object.
+ * @param {Array} childObjList
+ * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this
+ * container.
+ * @param {Array} childHtmlList
+ * Array of HTML code that correspond to the HTML output of all the
+ * objects in childObjList.
+ * @param {Array} htmlList
+ * Array of HTML code that this element will output to.
+ * @param {CKEDITOR.dialog.uiElementDefinition} elementDefinition
+ * The element definition. Accepted fields:
+ *
+ * - widths (Optional) The widths of child cells.
+ * - height (Optional) The height of the layout.
+ * - padding (Optional) The padding width inside child
+ * cells.
+ * - align (Optional) The alignment of the whole layout
+ *
+ *
+ * @example
+ */
+ hbox : function( dialog, childObjList, childHtmlList, htmlList, elementDefinition )
+ {
+ if ( arguments.length < 4 )
+ return;
+
+ this._ || ( this._ = {} );
+
+ var children = this._.children = childObjList,
+ widths = elementDefinition && elementDefinition.widths || null,
+ height = elementDefinition && elementDefinition.height || null,
+ styles = {},
+ i;
+ /** @ignore */
+ var innerHTML = function()
+ {
+ var html = [ '
' ];
+ for ( i = 0 ; i < childHtmlList.length ; i++ )
+ {
+ var className = 'cke_dialog_ui_hbox_child',
+ styles = [];
+ if ( i === 0 )
+ className = 'cke_dialog_ui_hbox_first';
+ if ( i == childHtmlList.length - 1 )
+ className = 'cke_dialog_ui_hbox_last';
+ html.push( '| 0 )
+ html.push( 'style="' + styles.join('; ') + '" ' );
+ html.push( '>', childHtmlList[i], ' | ' );
+ }
+ html.push( '
' );
+ return html.join( '' );
+ };
+
+ var attribs = { role : 'presentation' };
+ elementDefinition && elementDefinition.align && ( attribs.align = elementDefinition.align );
+
+ CKEDITOR.ui.dialog.uiElement.call(
+ this,
+ dialog,
+ elementDefinition || { type : 'hbox' },
+ htmlList,
+ 'table',
+ styles,
+ attribs,
+ innerHTML );
+ },
+
+ /**
+ * Vertical layout box for dialog UI elements.
+ * @constructor
+ * @extends CKEDITOR.ui.dialog.hbox
+ * @param {CKEDITOR.dialog} dialog
+ * Parent dialog object.
+ * @param {Array} childObjList
+ * Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this
+ * container.
+ * @param {Array} childHtmlList
+ * Array of HTML code that correspond to the HTML output of all the
+ * objects in childObjList.
+ * @param {Array} htmlList
+ * Array of HTML code that this element will output to.
+ * @param {CKEDITOR.dialog.uiElementDefinition} elementDefinition
+ * The element definition. Accepted fields:
+ *
+ * - width (Optional) The width of the layout.
+ * - heights (Optional) The heights of individual cells.
+ *
+ * - align (Optional) The alignment of the layout.
+ * - padding (Optional) The padding width inside child
+ * cells.
+ * - expand (Optional) Whether the layout should expand
+ * vertically to fill its container.
+ *
+ * @example
+ */
+ vbox : function( dialog, childObjList, childHtmlList, htmlList, elementDefinition )
+ {
+ if (arguments.length < 3 )
+ return;
+
+ this._ || ( this._ = {} );
+
+ var children = this._.children = childObjList,
+ width = elementDefinition && elementDefinition.width || null,
+ heights = elementDefinition && elementDefinition.heights || null;
+ /** @ignore */
+ var innerHTML = function()
+ {
+ var html = [ '
' );
+ for ( var i = 0 ; i < childHtmlList.length ; i++ )
+ {
+ var styles = [];
+ html.push( '| 0 )
+ html.push( 'style="', styles.join( '; ' ), '" ' );
+ html.push( ' class="cke_dialog_ui_vbox_child">', childHtmlList[i], ' |
' );
+ }
+ html.push( '
' );
+ return html.join( '' );
+ };
+ CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition || { type : 'vbox' }, htmlList, 'div', null, { role : 'presentation' }, innerHTML );
+ }
+ };
+ })();
+
+ CKEDITOR.ui.dialog.uiElement.prototype =
+ {
+ /**
+ * Gets the root DOM element of this dialog UI object.
+ * @returns {CKEDITOR.dom.element} Root DOM element of UI object.
+ * @example
+ * uiElement.getElement().hide();
+ */
+ getElement : function()
+ {
+ return CKEDITOR.document.getById( this.domId );
+ },
+
+ /**
+ * Gets the DOM element that the user inputs values.
+ * This function is used by setValue(), getValue() and focus(). It should
+ * be overrided in child classes where the input element isn't the root
+ * element.
+ * @returns {CKEDITOR.dom.element} The element where the user input values.
+ * @example
+ * var rawValue = textInput.getInputElement().$.value;
+ */
+ getInputElement : function()
+ {
+ return this.getElement();
+ },
+
+ /**
+ * Gets the parent dialog object containing this UI element.
+ * @returns {CKEDITOR.dialog} Parent dialog object.
+ * @example
+ * var dialog = uiElement.getDialog();
+ */
+ getDialog : function()
+ {
+ return this._.dialog;
+ },
+
+ /**
+ * Sets the value of this dialog UI object.
+ * @param {Object} value The new value.
+ * @returns {CKEDITOR.dialog.uiElement} The current UI element.
+ * @example
+ * uiElement.setValue( 'Dingo' );
+ */
+ setValue : function( value )
+ {
+ this.getInputElement().setValue( value );
+ this.fire( 'change', { value : value } );
+ return this;
+ },
+
+ /**
+ * Gets the current value of this dialog UI object.
+ * @returns {Object} The current value.
+ * @example
+ * var myValue = uiElement.getValue();
+ */
+ getValue : function()
+ {
+ return this.getInputElement().getValue();
+ },
+
+ /**
+ * Tells whether the UI object's value has changed.
+ * @returns {Boolean} true if changed, false if not changed.
+ * @example
+ * if ( uiElement.isChanged() )
+ * confirm( 'Value changed! Continue?' );
+ */
+ isChanged : function()
+ {
+ // Override in input classes.
+ return false;
+ },
+
+ /**
+ * Selects the parent tab of this element. Usually called by focus() or overridden focus() methods.
+ * @returns {CKEDITOR.dialog.uiElement} The current UI element.
+ * @example
+ * focus : function()
+ * {
+ * this.selectParentTab();
+ * // do something else.
+ * }
+ */
+ selectParentTab : function()
+ {
+ var element = this.getInputElement(),
+ cursor = element,
+ tabId;
+ while ( ( cursor = cursor.getParent() ) && cursor.$.className.search( 'cke_dialog_page_contents' ) == -1 )
+ { /*jsl:pass*/ }
+
+ // Some widgets don't have parent tabs (e.g. OK and Cancel buttons).
+ if ( !cursor )
+ return this;
+
+ tabId = cursor.getAttribute( 'name' );
+ // Avoid duplicate select.
+ if ( this._.dialog._.currentTabId != tabId )
+ this._.dialog.selectPage( tabId );
+ return this;
+ },
+
+ /**
+ * Puts the focus to the UI object. Switches tabs if the UI object isn't in the active tab page.
+ * @returns {CKEDITOR.dialog.uiElement} The current UI element.
+ * @example
+ * uiElement.focus();
+ */
+ focus : function()
+ {
+ this.selectParentTab().getInputElement().focus();
+ return this;
+ },
+
+ /**
+ * Registers the on* event handlers defined in the element definition.
+ * The default behavior of this function is:
+ *
+ * -
+ * If the on* event is defined in the class's eventProcesors list,
+ * then the registration is delegated to the corresponding function
+ * in the eventProcessors list.
+ *
+ * -
+ * If the on* event is not defined in the eventProcessors list, then
+ * register the event handler under the corresponding DOM event of
+ * the UI element's input DOM element (as defined by the return value
+ * of {@link CKEDITOR.ui.dialog.uiElement#getInputElement}).
+ *
+ *
+ * This function is only called at UI element instantiation, but can
+ * be overridded in child classes if they require more flexibility.
+ * @param {CKEDITOR.dialog.uiElementDefinition} definition The UI element
+ * definition.
+ * @returns {CKEDITOR.dialog.uiElement} The current UI element.
+ * @example
+ */
+ registerEvents : function( definition )
+ {
+ var regex = /^on([A-Z]\w+)/,
+ match;
+
+ var registerDomEvent = function( uiElement, dialog, eventName, func )
+ {
+ dialog.on( 'load', function()
+ {
+ uiElement.getInputElement().on( eventName, func, uiElement );
+ });
+ };
+
+ for ( var i in definition )
+ {
+ if ( !( match = i.match( regex ) ) )
+ continue;
+ if ( this.eventProcessors[i] )
+ this.eventProcessors[i].call( this, this._.dialog, definition[i] );
+ else
+ registerDomEvent( this, this._.dialog, match[1].toLowerCase(), definition[i] );
+ }
+
+ return this;
+ },
+
+ /**
+ * The event processor list used by
+ * {@link CKEDITOR.ui.dialog.uiElement#getInputElement} at UI element
+ * instantiation. The default list defines three on* events:
+ *
+ * - onLoad - Called when the element's parent dialog opens for the
+ * first time
+ * - onShow - Called whenever the element's parent dialog opens.
+ * - onHide - Called whenever the element's parent dialog closes.
+ *
+ * @field
+ * @type Object
+ * @example
+ * // This connects the 'click' event in CKEDITOR.ui.dialog.button to onClick
+ * // handlers in the UI element's definitions.
+ * CKEDITOR.ui.dialog.button.eventProcessors = CKEDITOR.tools.extend( {},
+ * CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors,
+ * { onClick : function( dialog, func ) { this.on( 'click', func ); } },
+ * true );
+ */
+ eventProcessors :
+ {
+ onLoad : function( dialog, func )
+ {
+ dialog.on( 'load', func, this );
+ },
+
+ onShow : function( dialog, func )
+ {
+ dialog.on( 'show', func, this );
+ },
+
+ onHide : function( dialog, func )
+ {
+ dialog.on( 'hide', func, this );
+ }
+ },
+
+ /**
+ * The default handler for a UI element's access key down event, which
+ * tries to put focus to the UI element.
+ * Can be overridded in child classes for more sophisticaed behavior.
+ * @param {CKEDITOR.dialog} dialog The parent dialog object.
+ * @param {String} key The key combination pressed. Since access keys
+ * are defined to always include the CTRL key, its value should always
+ * include a 'CTRL+' prefix.
+ * @example
+ */
+ accessKeyDown : function( dialog, key )
+ {
+ this.focus();
+ },
+
+ /**
+ * The default handler for a UI element's access key up event, which
+ * does nothing.
+ * Can be overridded in child classes for more sophisticated behavior.
+ * @param {CKEDITOR.dialog} dialog The parent dialog object.
+ * @param {String} key The key combination pressed. Since access keys
+ * are defined to always include the CTRL key, its value should always
+ * include a 'CTRL+' prefix.
+ * @example
+ */
+ accessKeyUp : function( dialog, key )
+ {
+ },
+
+ /**
+ * Disables a UI element.
+ * @example
+ */
+ disable : function()
+ {
+ var element = this.getInputElement();
+ element.setAttribute( 'disabled', 'true' );
+ element.addClass( 'cke_disabled' );
+ },
+
+ /**
+ * Enables a UI element.
+ * @example
+ */
+ enable : function()
+ {
+ var element = this.getInputElement();
+ element.removeAttribute( 'disabled' );
+ element.removeClass( 'cke_disabled' );
+ },
+
+ /**
+ * Determines whether an UI element is enabled or not.
+ * @returns {Boolean} Whether the UI element is enabled.
+ * @example
+ */
+ isEnabled : function()
+ {
+ return !this.getInputElement().getAttribute( 'disabled' );
+ },
+
+ /**
+ * Determines whether an UI element is visible or not.
+ * @returns {Boolean} Whether the UI element is visible.
+ * @example
+ */
+ isVisible : function()
+ {
+ return this.getInputElement().isVisible();
+ },
+
+ /**
+ * Determines whether an UI element is focus-able or not.
+ * Focus-able is defined as being both visible and enabled.
+ * @returns {Boolean} Whether the UI element can be focused.
+ * @example
+ */
+ isFocusable : function()
+ {
+ if ( !this.isEnabled() || !this.isVisible() )
+ return false;
+ return true;
+ }
+ };
+
+ CKEDITOR.ui.dialog.hbox.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
+ /**
+ * @lends CKEDITOR.ui.dialog.hbox.prototype
+ */
+ {
+ /**
+ * Gets a child UI element inside this container.
+ * @param {Array|Number} indices An array or a single number to indicate the child's
+ * position in the container's descendant tree. Omit to get all the children in an array.
+ * @returns {Array|CKEDITOR.ui.dialog.uiElement} Array of all UI elements in the container
+ * if no argument given, or the specified UI element if indices is given.
+ * @example
+ * var checkbox = hbox.getChild( [0,1] );
+ * checkbox.setValue( true );
+ */
+ getChild : function( indices )
+ {
+ // If no arguments, return a clone of the children array.
+ if ( arguments.length < 1 )
+ return this._.children.concat();
+
+ // If indices isn't array, make it one.
+ if ( !indices.splice )
+ indices = [ indices ];
+
+ // Retrieve the child element according to tree position.
+ if ( indices.length < 2 )
+ return this._.children[ indices[0] ];
+ else
+ return ( this._.children[ indices[0] ] && this._.children[ indices[0] ].getChild ) ?
+ this._.children[ indices[0] ].getChild( indices.slice( 1, indices.length ) ) :
+ null;
+ }
+ }, true );
+
+ CKEDITOR.ui.dialog.vbox.prototype = new CKEDITOR.ui.dialog.hbox();
+
+
+
+ (function()
+ {
+ var commonBuilder = {
+ build : function( dialog, elementDefinition, output )
+ {
+ var children = elementDefinition.children,
+ child,
+ childHtmlList = [],
+ childObjList = [];
+ for ( var i = 0 ; ( i < children.length && ( child = children[i] ) ) ; i++ )
+ {
+ var childHtml = [];
+ childHtmlList.push( childHtml );
+ childObjList.push( CKEDITOR.dialog._.uiElementBuilders[ child.type ].build( dialog, child, childHtml ) );
+ }
+ return new CKEDITOR.ui.dialog[elementDefinition.type]( dialog, childObjList, childHtmlList, output, elementDefinition );
+ }
+ };
+
+ CKEDITOR.dialog.addUIElement( 'hbox', commonBuilder );
+ CKEDITOR.dialog.addUIElement( 'vbox', commonBuilder );
+ })();
+
+ /**
+ * Generic dialog command. It opens a specific dialog when executed.
+ * @constructor
+ * @augments CKEDITOR.commandDefinition
+ * @param {string} dialogName The name of the dialog to open when executing
+ * this command.
+ * @example
+ * // Register the "link" command, which opens the "link" dialog.
+ * editor.addCommand( 'link',
new CKEDITOR.dialogCommand( 'link' ) );
+ */
+ CKEDITOR.dialogCommand = function( dialogName )
+ {
+ this.dialogName = dialogName;
+ };
+
+ CKEDITOR.dialogCommand.prototype =
+ {
+ /** @ignore */
+ exec : function( editor )
+ {
+ editor.openDialog( this.dialogName );
+ },
+
+ // Dialog commands just open a dialog ui, thus require no undo logic,
+ // undo support should dedicate to specific dialog implementation.
+ canUndo: false,
+
+ editorFocus : CKEDITOR.env.ie
+ };
+
+ (function()
+ {
+ var notEmptyRegex = /^([a]|[^a])+$/,
+ integerRegex = /^\d*$/,
+ numberRegex = /^\d*(?:\.\d+)?$/;
+
+ CKEDITOR.VALIDATE_OR = 1;
+ CKEDITOR.VALIDATE_AND = 2;
+
+ CKEDITOR.dialog.validate =
+ {
+ functions : function()
+ {
+ return function()
+ {
+ /**
+ * It's important for validate functions to be able to accept the value
+ * as argument in addition to this.getValue(), so that it is possible to
+ * combine validate functions together to make more sophisticated
+ * validators.
+ */
+ var value = this && this.getValue ? this.getValue() : arguments[0];
+
+ var msg = undefined,
+ relation = CKEDITOR.VALIDATE_AND,
+ functions = [], i;
+
+ for ( i = 0 ; i < arguments.length ; i++ )
+ {
+ if ( typeof( arguments[i] ) == 'function' )
+ functions.push( arguments[i] );
+ else
+ break;
+ }
+
+ if ( i < arguments.length && typeof( arguments[i] ) == 'string' )
+ {
+ msg = arguments[i];
+ i++;
+ }
+
+ if ( i < arguments.length && typeof( arguments[i]) == 'number' )
+ relation = arguments[i];
+
+ var passed = ( relation == CKEDITOR.VALIDATE_AND ? true : false );
+ for ( i = 0 ; i < functions.length ; i++ )
+ {
+ if ( relation == CKEDITOR.VALIDATE_AND )
+ passed = passed && functions[i]( value );
+ else
+ passed = passed || functions[i]( value );
+ }
+
+ if ( !passed )
+ {
+ if ( msg !== undefined )
+ alert( msg );
+ if ( this && ( this.select || this.focus ) )
+ ( this.select || this.focus )();
+ return false;
+ }
+
+ return true;
+ };
+ },
+
+ regex : function( regex, msg )
+ {
+ /*
+ * Can be greatly shortened by deriving from functions validator if code size
+ * turns out to be more important than performance.
+ */
+ return function()
+ {
+ var value = this && this.getValue ? this.getValue() : arguments[0];
+ if ( !regex.test( value ) )
+ {
+ if ( msg !== undefined )
+ alert( msg );
+ if ( this && ( this.select || this.focus ) )
+ {
+ if ( this.select )
+ this.select();
+ else
+ this.focus();
+ }
+ return false;
+ }
+ return true;
+ };
+ },
+
+ notEmpty : function( msg )
+ {
+ return this.regex( notEmptyRegex, msg );
+ },
+
+ integer : function( msg )
+ {
+ return this.regex( integerRegex, msg );
+ },
+
+ 'number' : function( msg )
+ {
+ return this.regex( numberRegex, msg );
+ },
+
+ equals : function( value, msg )
+ {
+ return this.functions( function( val ){ return val == value; }, msg );
+ },
+
+ notEqual : function( value, msg )
+ {
+ return this.functions( function( val ){ return val != value; }, msg );
+ }
+ };
+ })();
+})();
+
+// Extend the CKEDITOR.editor class with dialog specific functions.
+CKEDITOR.tools.extend( CKEDITOR.editor.prototype,
+ /** @lends CKEDITOR.editor.prototype */
+ {
+ /**
+ * Loads and opens a registered dialog.
+ * @param {String} dialogName The registered name of the dialog.
+ * @param {Function} callback The function to be invoked after dialog instance created.
+ * @see CKEDITOR.dialog.add
+ * @example
+ * CKEDITOR.instances.editor1.openDialog( 'smiley' );
+ * @returns {CKEDITOR.dialog} The dialog object corresponding to the dialog displayed. null if the dialog name is not registered.
+ */
+ openDialog : function( dialogName, callback )
+ {
+ var dialogDefinitions = CKEDITOR.dialog._.dialogDefinitions[ dialogName ],
+ dialogSkin = this.skin.dialog;
+
+ // If the dialogDefinition is already loaded, open it immediately.
+ if ( typeof dialogDefinitions == 'function' && dialogSkin._isLoaded )
+ {
+ var storedDialogs = this._.storedDialogs ||
+ ( this._.storedDialogs = {} );
+
+ var dialog = storedDialogs[ dialogName ] ||
+ ( storedDialogs[ dialogName ] = new CKEDITOR.dialog( this, dialogName ) );
+
+ callback && callback.call( dialog, dialog );
+ dialog.show();
+
+ return dialog;
+ }
+ else if ( dialogDefinitions == 'failed' )
+ throw new Error( '[CKEDITOR.dialog.openDialog] Dialog "' + dialogName + '" failed when loading definition.' );
+
+ // Not loaded? Load the .js file first.
+ var body = CKEDITOR.document.getBody(),
+ cursor = body.$.style.cursor,
+ me = this;
+
+ body.setStyle( 'cursor', 'wait' );
+
+ function onDialogFileLoaded( success )
+ {
+ var dialogDefinition = CKEDITOR.dialog._.dialogDefinitions[ dialogName ],
+ skin = me.skin.dialog;
+
+ // Check if both skin part and definition is loaded.
+ if ( !skin._isLoaded || loadDefinition && typeof success == 'undefined' )
+ return;
+
+ // In case of plugin error, mark it as loading failed.
+ if ( typeof dialogDefinition != 'function' )
+ CKEDITOR.dialog._.dialogDefinitions[ dialogName ] = 'failed';
+
+ me.openDialog( dialogName, callback );
+ body.setStyle( 'cursor', cursor );
+ }
+
+ if ( typeof dialogDefinitions == 'string' )
+ {
+ var loadDefinition = 1;
+ CKEDITOR.scriptLoader.load( CKEDITOR.getUrl( dialogDefinitions ), onDialogFileLoaded );
+ }
+
+ CKEDITOR.skins.load( this, 'dialog', onDialogFileLoaded );
+
+ return null;
+ }
+ });
+
+CKEDITOR.plugins.add( 'dialog',
+ {
+ requires : [ 'dialogui' ]
+ });
+
+// Dialog related configurations.
+
+/**
+ * The color of the dialog background cover. It should be a valid CSS color
+ * string.
+ * @name CKEDITOR.config.dialog_backgroundCoverColor
+ * @type String
+ * @default 'white'
+ * @example
+ * config.dialog_backgroundCoverColor = 'rgb(255, 254, 253)';
+ */
+
+/**
+ * The opacity of the dialog background cover. It should be a number within the
+ * range [0.0, 1.0].
+ * @name CKEDITOR.config.dialog_backgroundCoverOpacity
+ * @type Number
+ * @default 0.5
+ * @example
+ * config.dialog_backgroundCoverOpacity = 0.7;
+ */
+
+/**
+ * If the dialog has more than one tab, put focus into the first tab as soon as dialog is opened.
+ * @name CKEDITOR.config.dialog_startupFocusTab
+ * @type Boolean
+ * @default false
+ * @example
+ * config.dialog_startupFocusTab = true;
+ */
+
+/**
+ * The distance of magnetic borders used in moving and resizing dialogs,
+ * measured in pixels.
+ * @name CKEDITOR.config.dialog_magnetDistance
+ * @type Number
+ * @default 20
+ * @example
+ * config.dialog_magnetDistance = 30;
+ */
+
+/**
+ * Fired when a dialog definition is about to be used to create a dialog into
+ * an editor instance. This event makes it possible to customize the definition
+ * before creating it.
+ *
Note that this event is called only the first time a specific dialog is
+ * opened. Successive openings will use the cached dialog, and this event will
+ * not get fired.
+ * @name CKEDITOR#dialogDefinition
+ * @event
+ * @param {CKEDITOR.dialog.dialogDefinition} data The dialog defination that
+ * is being loaded.
+ * @param {CKEDITOR.editor} editor The editor instance that will use the
+ * dialog.
+ */
diff --git a/include/ckeditor/_source/plugins/dialogui/plugin.js b/include/ckeditor/_source/plugins/dialogui/plugin.js
new file mode 100644
index 0000000..8d20793
--- /dev/null
+++ b/include/ckeditor/_source/plugins/dialogui/plugin.js
@@ -0,0 +1,1408 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/** @fileoverview The "dialogui" plugin. */
+
+CKEDITOR.plugins.add( 'dialogui' );
+
+(function()
+{
+ var initPrivateObject = function( elementDefinition )
+ {
+ this._ || ( this._ = {} );
+ this._['default'] = this._.initValue = elementDefinition['default'] || '';
+ this._.required = elementDefinition[ 'required' ] || false;
+ var args = [ this._ ];
+ for ( var i = 1 ; i < arguments.length ; i++ )
+ args.push( arguments[i] );
+ args.push( true );
+ CKEDITOR.tools.extend.apply( CKEDITOR.tools, args );
+ return this._;
+ },
+ textBuilder =
+ {
+ build : function( dialog, elementDefinition, output )
+ {
+ return new CKEDITOR.ui.dialog.textInput( dialog, elementDefinition, output );
+ }
+ },
+ commonBuilder =
+ {
+ build : function( dialog, elementDefinition, output )
+ {
+ return new CKEDITOR.ui.dialog[elementDefinition.type]( dialog, elementDefinition, output );
+ }
+ },
+ containerBuilder =
+ {
+ build : function( dialog, elementDefinition, output )
+ {
+ var children = elementDefinition.children,
+ child,
+ childHtmlList = [],
+ childObjList = [];
+ for ( var i = 0 ; ( i < children.length && ( child = children[i] ) ) ; i++ )
+ {
+ var childHtml = [];
+ childHtmlList.push( childHtml );
+ childObjList.push( CKEDITOR.dialog._.uiElementBuilders[ child.type ].build( dialog, child, childHtml ) );
+ }
+ return new CKEDITOR.ui.dialog[ elementDefinition.type ]( dialog, childObjList, childHtmlList, output, elementDefinition );
+ }
+ },
+ commonPrototype =
+ {
+ isChanged : function()
+ {
+ return this.getValue() != this.getInitValue();
+ },
+
+ reset : function()
+ {
+ this.setValue( this.getInitValue() );
+ },
+
+ setInitValue : function()
+ {
+ this._.initValue = this.getValue();
+ },
+
+ resetInitValue : function()
+ {
+ this._.initValue = this._['default'];
+ },
+
+ getInitValue : function()
+ {
+ return this._.initValue;
+ }
+ },
+ commonEventProcessors = CKEDITOR.tools.extend( {}, CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors,
+ {
+ onChange : function( dialog, func )
+ {
+ if ( !this._.domOnChangeRegistered )
+ {
+ dialog.on( 'load', function()
+ {
+ this.getInputElement().on( 'change', function(){ this.fire( 'change', { value : this.getValue() } ); }, this );
+ }, this );
+ this._.domOnChangeRegistered = true;
+ }
+
+ this.on( 'change', func );
+ }
+ }, true ),
+ eventRegex = /^on([A-Z]\w+)/,
+ cleanInnerDefinition = function( def )
+ {
+ // An inner UI element should not have the parent's type, title or events.
+ for ( var i in def )
+ {
+ if ( eventRegex.test( i ) || i == 'title' || i == 'type' )
+ delete def[i];
+ }
+ return def;
+ };
+
+ CKEDITOR.tools.extend( CKEDITOR.ui.dialog,
+ /** @lends CKEDITOR.ui.dialog */
+ {
+ /**
+ * Base class for all dialog elements with a textual label on the left.
+ * @constructor
+ * @example
+ * @extends CKEDITOR.ui.dialog.uiElement
+ * @param {CKEDITOR.dialog} dialog
+ * Parent dialog object.
+ * @param {CKEDITOR.dialog.uiElementDefinition} elementDefinition
+ * The element definition. Accepted fields:
+ *
+ * - label (Required) The label string.
+ * - labelLayout (Optional) Put 'horizontal' here if the
+ * label element is to be layed out horizontally. Otherwise a vertical
+ * layout will be used.
+ * - widths (Optional) This applies only for horizontal
+ * layouts - an 2-element array of lengths to specify the widths of the
+ * label and the content element.
+ *
+ * @param {Array} htmlList
+ * List of HTML code to output to.
+ * @param {Function} contentHtml
+ * A function returning the HTML code string to be added inside the content
+ * cell.
+ */
+ labeledElement : function( dialog, elementDefinition, htmlList, contentHtml )
+ {
+ if ( arguments.length < 4 )
+ return;
+
+ var _ = initPrivateObject.call( this, elementDefinition );
+ _.labelId = CKEDITOR.tools.getNextNumber() + '_label';
+ var children = this._.children = [];
+ /** @ignore */
+ var innerHTML = function()
+ {
+ var html = [];
+ if ( elementDefinition.labelLayout != 'horizontal' )
+ html.push( '
',
+ '
',
+ contentHtml.call( this, dialog, elementDefinition ),
+ '
' );
+ else
+ {
+ var hboxDefinition = {
+ type : 'hbox',
+ widths : elementDefinition.widths,
+ padding : 0,
+ children :
+ [
+ {
+ type : 'html',
+ html : '