code stringlengths 1 2.08M | language stringclasses 1 value |
|---|---|
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
// Regex to scan for at the end of blocks, which are actually placeholders.
// Safari transforms the to \xa0. (#4172)
var tailNbspRegex = /^[\t\r\n ]*(?: |\xa0)$/;
var protectedSourceMarker = '{cke_protected}';
// Return the last non-space child node of the block (#4344).
function lastNoneSpaceChild( block )
{
var lastIndex = block.children.length,
last = block.children[ lastIndex - 1 ];
while ( last && last.type == CKEDITOR.NODE_TEXT && !CKEDITOR.tools.trim( last.value ) )
last = block.children[ --lastIndex ];
return last;
}
function trimFillers( block, fromSource )
{
// If the current node is a block, and if we're converting from source or
// we're not in IE then search for and remove any tailing BR node.
//
// Also, any at the end of blocks are fillers, remove them as well.
// (#2886)
var children = block.children, lastChild = lastNoneSpaceChild( block );
if ( lastChild )
{
if ( ( fromSource || !CKEDITOR.env.ie ) && lastChild.type == CKEDITOR.NODE_ELEMENT && lastChild.name == 'br' )
children.pop();
if ( lastChild.type == CKEDITOR.NODE_TEXT && tailNbspRegex.test( lastChild.value ) )
children.pop();
}
}
function blockNeedsExtension( block, fromSource, extendEmptyBlock )
{
if( !fromSource && ( !extendEmptyBlock ||
typeof extendEmptyBlock == 'function' && ( extendEmptyBlock( block ) === false ) ) )
return false;
// 1. For IE version >=8, empty blocks are displayed correctly themself in wysiwiyg;
// 2. For the rest, at least table cell and list item need no filler space.
// (#6248)
if ( fromSource && CKEDITOR.env.ie &&
( document.documentMode > 7
|| block.name in CKEDITOR.dtd.tr
|| block.name in CKEDITOR.dtd.$listItem ) )
return false;
var lastChild = lastNoneSpaceChild( block );
return !lastChild || lastChild &&
( lastChild.type == CKEDITOR.NODE_ELEMENT && lastChild.name == 'br'
// Some of the controls in form needs extension too,
// to move cursor at the end of the form. (#4791)
|| block.name == 'form' && lastChild.name == 'input' );
}
function getBlockExtension( isOutput, emptyBlockFiller )
{
return function( node )
{
trimFillers( node, !isOutput );
if ( blockNeedsExtension( node, !isOutput, emptyBlockFiller ) )
{
if ( isOutput || CKEDITOR.env.ie )
node.add( new CKEDITOR.htmlParser.text( '\xa0' ) );
else
node.add( new CKEDITOR.htmlParser.element( 'br', {} ) );
}
};
}
var dtd = CKEDITOR.dtd;
// Define orders of table elements.
var tableOrder = [ 'caption', 'colgroup', 'col', 'thead', 'tfoot', 'tbody' ];
// Find out the list of block-like tags that can contain <br>.
var blockLikeTags = CKEDITOR.tools.extend( {}, dtd.$block, dtd.$listItem, dtd.$tableContent );
for ( var i in blockLikeTags )
{
if ( ! ( 'br' in dtd[i] ) )
delete blockLikeTags[i];
}
// We just avoid filler in <pre> right now.
// TODO: Support filler for <pre>, line break is also occupy line height.
delete blockLikeTags.pre;
var defaultDataFilterRules =
{
elements : {},
attributeNames :
[
// Event attributes (onXYZ) must not be directly set. They can become
// active in the editing area (IE|WebKit).
[ ( /^on/ ), 'data-cke-pa-on' ]
]
};
var defaultDataBlockFilterRules = { elements : {} };
for ( i in blockLikeTags )
defaultDataBlockFilterRules.elements[ i ] = getBlockExtension();
var defaultHtmlFilterRules =
{
elementNames :
[
// Remove the "cke:" namespace prefix.
[ ( /^cke:/ ), '' ],
// Ignore <?xml:namespace> tags.
[ ( /^\?xml:namespace$/ ), '' ]
],
attributeNames :
[
// Attributes saved for changes and protected attributes.
[ ( /^data-cke-(saved|pa)-/ ), '' ],
// All "data-cke-" attributes are to be ignored.
[ ( /^data-cke-.*/ ), '' ],
[ 'hidefocus', '' ]
],
elements :
{
$ : function( element )
{
var attribs = element.attributes;
if ( attribs )
{
// Elements marked as temporary are to be ignored.
if ( attribs[ 'data-cke-temp' ] )
return false;
// Remove duplicated attributes - #3789.
var attributeNames = [ 'name', 'href', 'src' ],
savedAttributeName;
for ( var i = 0 ; i < attributeNames.length ; i++ )
{
savedAttributeName = 'data-cke-saved-' + attributeNames[ i ];
savedAttributeName in attribs && ( delete attribs[ attributeNames[ i ] ] );
}
}
return element;
},
// The contents of table should be in correct order (#4809).
table : function( element )
{
var children = element.children;
children.sort( function ( node1, node2 )
{
return node1.type == CKEDITOR.NODE_ELEMENT && node2.type == node1.type ?
CKEDITOR.tools.indexOf( tableOrder, node1.name ) > CKEDITOR.tools.indexOf( tableOrder, node2.name ) ? 1 : -1 : 0;
} );
},
embed : function( element )
{
var parent = element.parent;
// If the <embed> is child of a <object>, copy the width
// and height attributes from it.
if ( parent && parent.name == 'object' )
{
var parentWidth = parent.attributes.width,
parentHeight = parent.attributes.height;
parentWidth && ( element.attributes.width = parentWidth );
parentHeight && ( element.attributes.height = parentHeight );
}
},
// Restore param elements into self-closing.
param : function( param )
{
param.children = [];
param.isEmpty = true;
return param;
},
// Remove empty link but not empty anchor.(#3829)
a : function( element )
{
if ( !( element.children.length ||
element.attributes.name ||
element.attributes[ 'data-cke-saved-name' ] ) )
{
return false;
}
},
// Remove dummy span in webkit.
span: function( element )
{
if ( element.attributes[ 'class' ] == 'Apple-style-span' )
delete element.name;
},
// Empty <pre> in IE is reported with filler node ( ).
pre : function( element ) { CKEDITOR.env.ie && trimFillers( element ); },
html : function( element )
{
delete element.attributes.contenteditable;
delete element.attributes[ 'class' ];
},
body : function( element )
{
delete element.attributes.spellcheck;
delete element.attributes.contenteditable;
},
style : function( element )
{
var child = element.children[ 0 ];
child && child.value && ( child.value = CKEDITOR.tools.trim( child.value ));
if ( !element.attributes.type )
element.attributes.type = 'text/css';
},
title : function( element )
{
var titleText = element.children[ 0 ];
titleText && ( titleText.value = element.attributes[ 'data-cke-title' ] || '' );
}
},
attributes :
{
'class' : function( value, element )
{
// Remove all class names starting with "cke_".
return CKEDITOR.tools.ltrim( value.replace( /(?:^|\s+)cke_[^\s]*/g, '' ) ) || false;
}
}
};
if ( CKEDITOR.env.ie )
{
// IE outputs style attribute in capital letters. We should convert
// them back to lower case, while not hurting the values (#5930)
defaultHtmlFilterRules.attributes.style = function( value, element )
{
return value.replace( /(^|;)([^\:]+)/g, function( match )
{
return match.toLowerCase();
});
};
}
function protectReadOnly( element )
{
var attrs = element.attributes;
// We should flag that the element was locked by our code so
// it'll be editable by the editor functions (#6046).
if ( attrs.contenteditable != "false" )
attrs[ 'data-cke-editable' ] = attrs.contenteditable ? 'true' : 1;
attrs.contenteditable = "false";
}
function unprotectReadyOnly( element )
{
var attrs = element.attributes;
switch( attrs[ 'data-cke-editable' ] )
{
case 'true': attrs.contenteditable = 'true'; break;
case '1': delete attrs.contenteditable; break;
}
}
// Disable form elements editing mode provided by some browers. (#5746)
for ( i in { input : 1, textarea : 1 } )
{
defaultDataFilterRules.elements[ i ] = protectReadOnly;
defaultHtmlFilterRules.elements[ i ] = unprotectReadyOnly;
}
var protectElementRegex = /<(a|area|img|input)\b([^>]*)>/gi,
protectAttributeRegex = /\b(on\w+|href|src|name)\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|(?:[^ "'>]+))/gi;
var protectElementsRegex = /(?:<style(?=[ >])[^>]*>[\s\S]*<\/style>)|(?:<(:?link|meta|base)[^>]*>)/gi,
encodedElementsRegex = /<cke:encoded>([^<]*)<\/cke:encoded>/gi;
var protectElementNamesRegex = /(<\/?)((?:object|embed|param|html|body|head|title)[^>]*>)/gi,
unprotectElementNamesRegex = /(<\/?)cke:((?:html|body|head|title)[^>]*>)/gi;
var protectSelfClosingRegex = /<cke:(param|embed)([^>]*?)\/?>(?!\s*<\/cke:\1)/gi;
function protectAttributes( html )
{
return html.replace( protectElementRegex, function( element, tag, attributes )
{
return '<' + tag + attributes.replace( protectAttributeRegex, function( fullAttr, attrName )
{
// Avoid corrupting the inline event attributes (#7243).
// We should not rewrite the existed protected attributes, e.g. clipboard content from editor. (#5218)
if ( !( /^on/ ).test( attrName ) && attributes.indexOf( 'data-cke-saved-' + attrName ) == -1 )
return ' data-cke-saved-' + fullAttr + ' data-cke-' + CKEDITOR.rnd + '-' + fullAttr;
return fullAttr;
}) + '>';
});
}
function protectElements( html )
{
return html.replace( protectElementsRegex, function( match )
{
return '<cke:encoded>' + encodeURIComponent( match ) + '</cke:encoded>';
});
}
function unprotectElements( html )
{
return html.replace( encodedElementsRegex, function( match, encoded )
{
return decodeURIComponent( encoded );
});
}
function protectElementsNames( html )
{
return html.replace( protectElementNamesRegex, '$1cke:$2');
}
function unprotectElementNames( html )
{
return html.replace( unprotectElementNamesRegex, '$1$2' );
}
function protectSelfClosingElements( html )
{
return html.replace( protectSelfClosingRegex, '<cke:$1$2></cke:$1>' );
}
function protectPreFormatted( html )
{
return html.replace( /(<pre\b[^>]*>)(\r\n|\n)/g, '$1$2$2' );
}
function protectRealComments( html )
{
return html.replace( /<!--(?!{cke_protected})[\s\S]+?-->/g, function( match )
{
return '<!--' + protectedSourceMarker +
'{C}' +
encodeURIComponent( match ).replace( /--/g, '%2D%2D' ) +
'-->';
});
}
function unprotectRealComments( html )
{
return html.replace( /<!--\{cke_protected\}\{C\}([\s\S]+?)-->/g, function( match, data )
{
return decodeURIComponent( data );
});
}
function unprotectSource( html, editor )
{
var store = editor._.dataStore;
return html.replace( /<!--\{cke_protected\}([\s\S]+?)-->/g, function( match, data )
{
return decodeURIComponent( data );
}).replace( /\{cke_protected_(\d+)\}/g, function( match, id )
{
return store && store[ id ] || '';
});
}
function protectSource( data, editor )
{
var protectedHtml = [],
protectRegexes = editor.config.protectedSource,
store = editor._.dataStore || ( editor._.dataStore = { id : 1 } ),
tempRegex = /<\!--\{cke_temp(comment)?\}(\d*?)-->/g;
var regexes =
[
// Script tags will also be forced to be protected, otherwise
// IE will execute them.
( /<script[\s\S]*?<\/script>/gi ),
// <noscript> tags (get lost in IE and messed up in FF).
/<noscript[\s\S]*?<\/noscript>/gi
]
.concat( protectRegexes );
// First of any other protection, we must protect all comments
// to avoid loosing them (of course, IE related).
// Note that we use a different tag for comments, as we need to
// transform them when applying filters.
data = data.replace( (/<!--[\s\S]*?-->/g), function( match )
{
return '<!--{cke_tempcomment}' + ( protectedHtml.push( match ) - 1 ) + '-->';
});
for ( var i = 0 ; i < regexes.length ; i++ )
{
data = data.replace( regexes[i], function( match )
{
match = match.replace( tempRegex, // There could be protected source inside another one. (#3869).
function( $, isComment, id )
{
return protectedHtml[ id ];
}
);
// Avoid protecting over protected, e.g. /\{.*?\}/
return ( /cke_temp(comment)?/ ).test( match ) ? match
: '<!--{cke_temp}' + ( protectedHtml.push( match ) - 1 ) + '-->';
});
}
data = data.replace( tempRegex, function( $, isComment, id )
{
return '<!--' + protectedSourceMarker +
( isComment ? '{C}' : '' ) +
encodeURIComponent( protectedHtml[ id ] ).replace( /--/g, '%2D%2D' ) +
'-->';
}
);
// Different protection pattern is used for those that
// live in attributes to avoid from being HTML encoded.
return data.replace( /(['"]).*?\1/g, function ( match )
{
return match.replace( /<!--\{cke_protected\}([\s\S]+?)-->/g, function( match, data )
{
store[ store.id ] = decodeURIComponent( data );
return '{cke_protected_'+ ( store.id++ ) + '}';
});
});
}
CKEDITOR.plugins.add( 'htmldataprocessor',
{
requires : [ 'htmlwriter' ],
init : function( editor )
{
var dataProcessor = editor.dataProcessor = new CKEDITOR.htmlDataProcessor( editor );
dataProcessor.writer.forceSimpleAmpersand = editor.config.forceSimpleAmpersand;
dataProcessor.dataFilter.addRules( defaultDataFilterRules );
dataProcessor.dataFilter.addRules( defaultDataBlockFilterRules );
dataProcessor.htmlFilter.addRules( defaultHtmlFilterRules );
var defaultHtmlBlockFilterRules = { elements : {} };
for ( i in blockLikeTags )
defaultHtmlBlockFilterRules.elements[ i ] = getBlockExtension( true, editor.config.fillEmptyBlocks );
dataProcessor.htmlFilter.addRules( defaultHtmlBlockFilterRules );
},
onLoad : function()
{
! ( 'fillEmptyBlocks' in CKEDITOR.config ) && ( CKEDITOR.config.fillEmptyBlocks = 1 );
}
});
CKEDITOR.htmlDataProcessor = function( editor )
{
this.editor = editor;
this.writer = new CKEDITOR.htmlWriter();
this.dataFilter = new CKEDITOR.htmlParser.filter();
this.htmlFilter = new CKEDITOR.htmlParser.filter();
};
CKEDITOR.htmlDataProcessor.prototype =
{
toHtml : function( data, fixForBody )
{
// The source data is already HTML, but we need to clean
// it up and apply the filter.
data = protectSource( data, this.editor );
// Before anything, we must protect the URL attributes as the
// browser may changing them when setting the innerHTML later in
// the code.
data = protectAttributes( data );
// Protect elements than can't be set inside a DIV. E.g. IE removes
// style tags from innerHTML. (#3710)
data = protectElements( data );
// Certain elements has problem to go through DOM operation, protect
// them by prefixing 'cke' namespace. (#3591)
data = protectElementsNames( data );
// All none-IE browsers ignore self-closed custom elements,
// protecting them into open-close. (#3591)
data = protectSelfClosingElements( data );
// Compensate one leading line break after <pre> open as browsers
// eat it up. (#5789)
data = protectPreFormatted( data );
// Call the browser to help us fixing a possibly invalid HTML
// structure.
var div = new CKEDITOR.dom.element( 'div' );
// Add fake character to workaround IE comments bug. (#3801)
div.setHtml( 'a' + data );
data = div.getHtml().substr( 1 );
// Restore shortly protected attribute names.
data = data.replace( new RegExp( ' data-cke-' + CKEDITOR.rnd + '-', 'ig' ), ' ' );
// Unprotect "some" of the protected elements at this point.
data = unprotectElementNames( data );
data = unprotectElements( data );
// Restore the comments that have been protected, in this way they
// can be properly filtered.
data = unprotectRealComments( data );
// Now use our parser to make further fixes to the structure, as
// well as apply the filter.
var fragment = CKEDITOR.htmlParser.fragment.fromHtml( data, fixForBody ),
writer = new CKEDITOR.htmlParser.basicWriter();
fragment.writeHtml( writer, this.dataFilter );
data = writer.getHtml( true );
// Protect the real comments again.
data = protectRealComments( data );
return data;
},
toDataFormat : function( html, fixForBody )
{
var writer = this.writer,
fragment = CKEDITOR.htmlParser.fragment.fromHtml( html, fixForBody );
writer.reset();
fragment.writeHtml( writer, this.htmlFilter );
var data = writer.getHtml( true );
// Restore those non-HTML protected source. (#4475,#4880)
data = unprotectRealComments( data );
data = unprotectSource( data, this.editor );
return data;
}
};
})();
/**
* Whether to force using "&" instead of "&amp;" in elements attributes
* values, it's not recommended to change this setting for compliance with the
* W3C XHTML 1.0 standards (<a href="http://www.w3.org/TR/xhtml1/#C_12">C.12, XHTML 1.0</a>).
* @name CKEDITOR.config.forceSimpleAmpersand
* @name CKEDITOR.config.forceSimpleAmpersand
* @type Boolean
* @default false
* @example
* config.forceSimpleAmpersand = false;
*/
/**
* Whether a filler text (non-breaking space entity - ) will be inserted into empty block elements in HTML output,
* this is used to render block elements properly with line-height; When a function is instead specified,
* it'll be passed a {@link CKEDITOR.htmlParser.element} to decide whether adding the filler text
* by expecting a boolean return value.
* @name CKEDITOR.config.fillEmptyBlocks
* @since 3.5
* @type Boolean
* @default true
* @example
* config.fillEmptyBlocks = false; // Prevent filler nodes in all empty blocks.
*
* // Prevent filler node only in float cleaners.
* config.fillEmptyBlocks = function( element )
* {
* if ( element.attributes[ 'class' ].indexOf ( 'clear-both' ) != -1 )
* return false;
* }
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview Defines the {@link CKEDITOR.ajax} object, which holds ajax methods for
* data loading.
*/
(function()
{
CKEDITOR.plugins.add( 'ajax',
{
requires : [ 'xml' ]
});
/**
* Ajax methods for data loading.
* @namespace
* @example
*/
CKEDITOR.ajax = (function()
{
var createXMLHttpRequest = function()
{
// In IE, using the native XMLHttpRequest for local files may throw
// "Access is Denied" errors.
if ( !CKEDITOR.env.ie || location.protocol != 'file:' )
try { return new XMLHttpRequest(); } catch(e) {}
try { return new ActiveXObject( 'Msxml2.XMLHTTP' ); } catch (e) {}
try { return new ActiveXObject( 'Microsoft.XMLHTTP' ); } catch (e) {}
return null;
};
var checkStatus = function( xhr )
{
// HTTP Status Codes:
// 2xx : Success
// 304 : Not Modified
// 0 : Returned when running locally (file://)
// 1223 : IE may change 204 to 1223 (see http://dev.jquery.com/ticket/1450)
return ( xhr.readyState == 4 &&
( ( xhr.status >= 200 && xhr.status < 300 ) ||
xhr.status == 304 ||
xhr.status === 0 ||
xhr.status == 1223 ) );
};
var getResponseText = function( xhr )
{
if ( checkStatus( xhr ) )
return xhr.responseText;
return null;
};
var getResponseXml = function( xhr )
{
if ( checkStatus( xhr ) )
{
var xml = xhr.responseXML;
return new CKEDITOR.xml( xml && xml.firstChild ? xml : xhr.responseText );
}
return null;
};
var load = function( url, callback, getResponseFn )
{
var async = !!callback;
var xhr = createXMLHttpRequest();
if ( !xhr )
return null;
xhr.open( 'GET', url, async );
if ( async )
{
// TODO: perform leak checks on this closure.
/** @ignore */
xhr.onreadystatechange = function()
{
if ( xhr.readyState == 4 )
{
callback( getResponseFn( xhr ) );
xhr = null;
}
};
}
xhr.send(null);
return async ? '' : getResponseFn( xhr );
};
return /** @lends CKEDITOR.ajax */ {
/**
* Loads data from an URL as plain text.
* @param {String} url The URL from which load data.
* @param {Function} [callback] A callback function to be called on
* data load. If not provided, the data will be loaded
* synchronously.
* @returns {String} The loaded data. For asynchronous requests, an
* empty string. For invalid requests, null.
* @example
* // Load data synchronously.
* var data = CKEDITOR.ajax.load( 'somedata.txt' );
* alert( data );
* @example
* // Load data asynchronously.
* var data = CKEDITOR.ajax.load( 'somedata.txt', function( data )
* {
* alert( data );
* } );
*/
load : function( url, callback )
{
return load( url, callback, getResponseText );
},
/**
* Loads data from an URL as XML.
* @param {String} url The URL from which load data.
* @param {Function} [callback] A callback function to be called on
* data load. If not provided, the data will be loaded
* synchronously.
* @returns {CKEDITOR.xml} An XML object holding the loaded data. For asynchronous requests, an
* empty string. For invalid requests, null.
* @example
* // Load XML synchronously.
* var xml = CKEDITOR.ajax.loadXml( 'somedata.xml' );
* alert( xml.getInnerXml( '//' ) );
* @example
* // Load XML asynchronously.
* var data = CKEDITOR.ajax.loadXml( 'somedata.xml', function( xml )
* {
* alert( xml.getInnerXml( '//' ) );
* } );
*/
loadXml : function( url, callback )
{
return load( url, callback, getResponseXml );
}
};
})();
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Preview plugin.
*/
(function()
{
var pluginPath;
var previewCmd =
{
modes : { wysiwyg:1, source:1 },
canUndo : false,
readOnly : 1,
exec : function( editor )
{
var sHTML,
config = editor.config,
baseTag = config.baseHref ? '<base href="' + config.baseHref + '"/>' : '',
isCustomDomain = CKEDITOR.env.isCustomDomain();
if ( config.fullPage )
{
sHTML = editor.getData()
.replace( /<head>/, '$&' + baseTag )
.replace( /[^>]*(?=<\/title>)/, '$& — ' + editor.lang.preview );
}
else
{
var bodyHtml = '<body ',
body = editor.document && editor.document.getBody();
if ( body )
{
if ( body.getAttribute( 'id' ) )
bodyHtml += 'id="' + body.getAttribute( 'id' ) + '" ';
if ( body.getAttribute( 'class' ) )
bodyHtml += 'class="' + body.getAttribute( 'class' ) + '" ';
}
bodyHtml += '>';
sHTML =
editor.config.docType +
'<html dir="' + editor.config.contentsLangDirection + '">' +
'<head>' +
baseTag +
'<title>' + editor.lang.preview + '</title>' +
CKEDITOR.tools.buildStyleHtml( editor.config.contentsCss ) +
'</head>' + bodyHtml +
editor.getData() +
'</body></html>';
}
var iWidth = 640, // 800 * 0.8,
iHeight = 420, // 600 * 0.7,
iLeft = 80; // (800 - 0.8 * 800) /2 = 800 * 0.1.
try
{
var screen = window.screen;
iWidth = Math.round( screen.width * 0.8 );
iHeight = Math.round( screen.height * 0.7 );
iLeft = Math.round( screen.width * 0.1 );
}
catch ( e ){}
var sOpenUrl = '';
if ( isCustomDomain )
{
window._cke_htmlToLoad = sHTML;
sOpenUrl = 'javascript:void( (function(){' +
'document.open();' +
'document.domain="' + document.domain + '";' +
'document.write( window.opener._cke_htmlToLoad );' +
'document.close();' +
'window.opener._cke_htmlToLoad = null;' +
'})() )';
}
// With Firefox only, we need to open a special preview page, so
// anchors will work properly on it. (#9047)
if ( CKEDITOR.env.gecko )
{
window._cke_htmlToLoad = sHTML;
sOpenUrl = pluginPath + 'preview.html';
}
var oWindow = window.open( sOpenUrl, null, 'toolbar=yes,location=no,status=yes,menubar=yes,scrollbars=yes,resizable=yes,width=' +
iWidth + ',height=' + iHeight + ',left=' + iLeft );
if ( !isCustomDomain && !CKEDITOR.env.gecko )
{
var doc = oWindow.document;
doc.open();
doc.write( sHTML );
doc.close();
// Chrome will need this to show the embedded. (#8016)
CKEDITOR.env.webkit && setTimeout( function() { doc.body.innerHTML += ''; }, 0 );
}
}
};
var pluginName = 'preview';
// Register a plugin named "preview".
CKEDITOR.plugins.add( pluginName,
{
init : function( editor )
{
pluginPath = this.path;
editor.addCommand( pluginName, previewCmd );
editor.ui.addButton( 'Preview',
{
label : editor.lang.preview,
command : pluginName
});
}
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var meta =
{
editorFocus : false,
modes : { wysiwyg:1, source:1 }
};
var blurCommand =
{
exec : function( editor )
{
editor.container.focusNext( true, editor.tabIndex );
}
};
var blurBackCommand =
{
exec : function( editor )
{
editor.container.focusPrevious( true, editor.tabIndex );
}
};
function selectNextCellCommand( backward )
{
return {
editorFocus : false,
canUndo : false,
modes : { wysiwyg : 1 },
exec : function( editor )
{
if ( editor.focusManager.hasFocus )
{
var sel = editor.getSelection(),
ancestor = sel.getCommonAncestor(),
cell;
if ( ( cell = ( ancestor.getAscendant( 'td', true ) || ancestor.getAscendant( 'th', true ) ) ) )
{
var resultRange = new CKEDITOR.dom.range( editor.document ),
next = CKEDITOR.tools.tryThese( function()
{
var row = cell.getParent(),
next = row.$.cells[ cell.$.cellIndex + ( backward ? - 1 : 1 ) ];
// Invalid any empty value.
next.parentNode.parentNode;
return next;
},
function()
{
var row = cell.getParent(),
table = row.getAscendant( 'table' ),
nextRow = table.$.rows[ row.$.rowIndex + ( backward ? - 1 : 1 ) ];
return nextRow.cells[ backward? nextRow.cells.length -1 : 0 ];
});
// Clone one more row at the end of table and select the first newly established cell.
if ( ! ( next || backward ) )
{
var table = cell.getAscendant( 'table' ).$,
cells = cell.getParent().$.cells;
var newRow = new CKEDITOR.dom.element( table.insertRow( -1 ), editor.document );
for ( var i = 0, count = cells.length ; i < count; i++ )
{
var newCell = newRow.append( new CKEDITOR.dom.element(
cells[ i ], editor.document ).clone( false, false ) );
!CKEDITOR.env.ie && newCell.appendBogus();
}
resultRange.moveToElementEditStart( newRow );
}
else if ( next )
{
next = new CKEDITOR.dom.element( next );
resultRange.moveToElementEditStart( next );
// Avoid selecting empty block makes the cursor blind.
if ( !( resultRange.checkStartOfBlock() && resultRange.checkEndOfBlock() ) )
resultRange.selectNodeContents( next );
}
else
return true;
resultRange.select( true );
return true;
}
}
return false;
}
};
}
CKEDITOR.plugins.add( 'tab',
{
requires : [ 'keystrokes' ],
init : function( editor )
{
var tabTools = editor.config.enableTabKeyTools !== false,
tabSpaces = editor.config.tabSpaces || 0,
tabText = '';
while ( tabSpaces-- )
tabText += '\xa0';
if ( tabText )
{
editor.on( 'key', function( ev )
{
if ( ev.data.keyCode == 9 ) // TAB
{
editor.insertHtml( tabText );
ev.cancel();
}
});
}
if ( tabTools )
{
editor.on( 'key', function( ev )
{
if ( ev.data.keyCode == 9 && editor.execCommand( 'selectNextCell' ) || // TAB
ev.data.keyCode == ( CKEDITOR.SHIFT + 9 ) && editor.execCommand( 'selectPreviousCell' ) ) // SHIFT+TAB
ev.cancel();
});
}
if ( CKEDITOR.env.webkit || CKEDITOR.env.gecko )
{
editor.on( 'key', function( ev )
{
var keyCode = ev.data.keyCode;
if ( keyCode == 9 && !tabText ) // TAB
{
ev.cancel();
editor.execCommand( 'blur' );
}
if ( keyCode == ( CKEDITOR.SHIFT + 9 ) ) // SHIFT+TAB
{
editor.execCommand( 'blurBack' );
ev.cancel();
}
});
}
editor.addCommand( 'blur', CKEDITOR.tools.extend( blurCommand, meta ) );
editor.addCommand( 'blurBack', CKEDITOR.tools.extend( blurBackCommand, meta ) );
editor.addCommand( 'selectNextCell', selectNextCellCommand() );
editor.addCommand( 'selectPreviousCell', selectNextCellCommand( true ) );
}
});
})();
/**
* Moves the UI focus to the element following this element in the tabindex
* order.
* @example
* var element = CKEDITOR.document.getById( 'example' );
* element.focusNext();
*/
CKEDITOR.dom.element.prototype.focusNext = function( ignoreChildren, indexToUse )
{
var $ = this.$,
curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
passedCurrent, enteredCurrent,
elected, electedTabIndex,
element, elementTabIndex;
if ( curTabIndex <= 0 )
{
// If this element has tabindex <= 0 then we must simply look for any
// element following it containing tabindex=0.
element = this.getNextSourceNode( ignoreChildren, CKEDITOR.NODE_ELEMENT );
while ( element )
{
if ( element.isVisible() && element.getTabIndex() === 0 )
{
elected = element;
break;
}
element = element.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT );
}
}
else
{
// If this element has tabindex > 0 then we must look for:
// 1. An element following this element with the same tabindex.
// 2. The first element in source other with the lowest tabindex
// that is higher than this element tabindex.
// 3. The first element with tabindex=0.
element = this.getDocument().getBody().getFirst();
while ( ( element = element.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT ) ) )
{
if ( !passedCurrent )
{
if ( !enteredCurrent && element.equals( this ) )
{
enteredCurrent = true;
// Ignore this element, if required.
if ( ignoreChildren )
{
if ( !( element = element.getNextSourceNode( true, CKEDITOR.NODE_ELEMENT ) ) )
break;
passedCurrent = 1;
}
}
else if ( enteredCurrent && !this.contains( element ) )
passedCurrent = 1;
}
if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
continue;
if ( passedCurrent && elementTabIndex == curTabIndex )
{
elected = element;
break;
}
if ( elementTabIndex > curTabIndex && ( !elected || !electedTabIndex || elementTabIndex < electedTabIndex ) )
{
elected = element;
electedTabIndex = elementTabIndex;
}
else if ( !elected && elementTabIndex === 0 )
{
elected = element;
electedTabIndex = elementTabIndex;
}
}
}
if ( elected )
elected.focus();
};
/**
* Moves the UI focus to the element before this element in the tabindex order.
* @example
* var element = CKEDITOR.document.getById( 'example' );
* element.focusPrevious();
*/
CKEDITOR.dom.element.prototype.focusPrevious = function( ignoreChildren, indexToUse )
{
var $ = this.$,
curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
passedCurrent, enteredCurrent,
elected,
electedTabIndex = 0,
elementTabIndex;
var element = this.getDocument().getBody().getLast();
while ( ( element = element.getPreviousSourceNode( false, CKEDITOR.NODE_ELEMENT ) ) )
{
if ( !passedCurrent )
{
if ( !enteredCurrent && element.equals( this ) )
{
enteredCurrent = true;
// Ignore this element, if required.
if ( ignoreChildren )
{
if ( !( element = element.getPreviousSourceNode( true, CKEDITOR.NODE_ELEMENT ) ) )
break;
passedCurrent = 1;
}
}
else if ( enteredCurrent && !this.contains( element ) )
passedCurrent = 1;
}
if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
continue;
if ( curTabIndex <= 0 )
{
// If this element has tabindex <= 0 then we must look for:
// 1. An element before this one containing tabindex=0.
// 2. The last element with the highest tabindex.
if ( passedCurrent && elementTabIndex === 0 )
{
elected = element;
break;
}
if ( elementTabIndex > electedTabIndex )
{
elected = element;
electedTabIndex = elementTabIndex;
}
}
else
{
// If this element has tabindex > 0 we must look for:
// 1. An element preceeding this one, with the same tabindex.
// 2. The last element in source other with the highest tabindex
// that is lower than this element tabindex.
if ( passedCurrent && elementTabIndex == curTabIndex )
{
elected = element;
break;
}
if ( elementTabIndex < curTabIndex && ( !elected || elementTabIndex > electedTabIndex ) )
{
elected = element;
electedTabIndex = elementTabIndex;
}
}
}
if ( elected )
elected.focus();
};
/**
* Intructs the editor to add a number of spaces (&nbsp;) to the text when
* hitting the TAB key. If set to zero, the TAB key will be used to move the
* cursor focus to the next element in the page, out of the editor focus.
* @name CKEDITOR.config.tabSpaces
* @type Number
* @default 0
* @example
* config.tabSpaces = 4;
*/
/**
* Allow context-sensitive tab key behaviors, including the following scenarios:
* <h5>When selection is anchored inside <b>table cells</b>:</h5>
* <ul>
* <li>If TAB is pressed, select the contents of the "next" cell. If in the last cell in the table, add a new row to it and focus its first cell.</li>
* <li>If SHIFT+TAB is pressed, select the contents of the "previous" cell. Do nothing when it's in the first cell.</li>
* </ul>
* @name CKEDITOR.config.enableTabKeyTools
* @type Boolean
* @default true
* @example
* config.enableTabKeyTools = false;
*/
// If the TAB key is not supposed to be enabled for navigation, the following
// settings could be used alternatively:
// config.keystrokes.push(
// [ CKEDITOR.ALT + 38 /*Arrow Up*/, 'selectPreviousCell' ],
// [ CKEDITOR.ALT + 40 /*Arrow Down*/, 'selectNextCell' ]
// );
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'menubutton',
{
requires : [ 'button', 'menu' ],
beforeInit : function( editor )
{
editor.ui.addHandler( CKEDITOR.UI_MENUBUTTON, CKEDITOR.ui.menuButton.handler );
}
});
/**
* Button UI element.
* @constant
* @example
*/
CKEDITOR.UI_MENUBUTTON = 'menubutton';
(function()
{
var clickFn = function( editor )
{
var _ = this._;
// Do nothing if this button is disabled.
if ( _.state === CKEDITOR.TRISTATE_DISABLED )
return;
_.previousState = _.state;
// Check if we already have a menu for it, otherwise just create it.
var menu = _.menu;
if ( !menu )
{
menu = _.menu = new CKEDITOR.menu( editor,
{
panel:
{
className : editor.skinClass + ' cke_contextmenu',
attributes : { 'aria-label' : editor.lang.common.options }
}
});
menu.onHide = CKEDITOR.tools.bind( function()
{
this.setState( this.modes && this.modes[ editor.mode ] ? _.previousState : CKEDITOR.TRISTATE_DISABLED );
},
this );
// Initialize the menu items at this point.
if ( this.onMenu )
menu.addListener( this.onMenu );
}
if ( _.on )
{
menu.hide();
return;
}
this.setState( CKEDITOR.TRISTATE_ON );
menu.show( CKEDITOR.document.getById( this._.id ), 4 );
};
CKEDITOR.ui.menuButton = CKEDITOR.tools.createClass(
{
base : CKEDITOR.ui.button,
$ : function( definition )
{
// We don't want the panel definition in this object.
var panelDefinition = definition.panel;
delete definition.panel;
this.base( definition );
this.hasArrow = true;
this.click = clickFn;
},
statics :
{
handler :
{
create : function( definition )
{
return new CKEDITOR.ui.menuButton( definition );
}
}
}
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
CKEDITOR.plugins.add( 'enterkey',
{
requires : [ 'keystrokes', 'indent' ],
init : function( editor )
{
editor.addCommand( 'enter', {
modes : { wysiwyg:1 },
editorFocus : false,
exec : function( editor ){ enter( editor ); }
});
editor.addCommand( 'shiftEnter', {
modes : { wysiwyg:1 },
editorFocus : false,
exec : function( editor ){ shiftEnter( editor ); }
});
var keystrokes = editor.keystrokeHandler.keystrokes;
keystrokes[ 13 ] = 'enter';
keystrokes[ CKEDITOR.SHIFT + 13 ] = 'shiftEnter';
}
});
CKEDITOR.plugins.enterkey =
{
enterBlock : function( editor, mode, range, forceMode )
{
// Get the range for the current selection.
range = range || getRange( editor );
// We may not have valid ranges to work on, like when inside a
// contenteditable=false element.
if ( !range )
return;
var doc = range.document;
var atBlockStart = range.checkStartOfBlock(),
atBlockEnd = range.checkEndOfBlock(),
path = new CKEDITOR.dom.elementPath( range.startContainer ),
block = path.block;
if ( atBlockStart && atBlockEnd )
{
// Exit the list when we're inside an empty list item block. (#5376)
if ( block && ( block.is( 'li' ) || block.getParent().is( 'li' ) ) )
{
editor.execCommand( 'outdent' );
return;
}
if ( block && block.getParent().is( 'blockquote' ) )
{
block.breakParent( block.getParent() );
// If we were at the start of <blockquote>, there will be an empty element before it now.
if ( !block.getPrevious().getFirst( CKEDITOR.dom.walker.invisible(1) ) )
block.getPrevious().remove();
// If we were at the end of <blockquote>, there will be an empty element after it now.
if ( !block.getNext().getFirst( CKEDITOR.dom.walker.invisible(1) ) )
block.getNext().remove();
range.moveToElementEditStart( block );
range.select();
return;
}
}
// Don't split <pre> if we're in the middle of it, act as shift enter key.
else if ( block && block.is( 'pre' ) )
{
if ( !atBlockEnd )
{
enterBr( editor, mode, range, forceMode );
return;
}
}
// Don't split caption blocks. (#7944)
else if ( block && CKEDITOR.dtd.$captionBlock[ block.getName() ] )
{
enterBr( editor, mode, range, forceMode );
return;
}
// Determine the block element to be used.
var blockTag = ( mode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
// Split the range.
var splitInfo = range.splitBlock( blockTag );
if ( !splitInfo )
return;
// Get the current blocks.
var previousBlock = splitInfo.previousBlock,
nextBlock = splitInfo.nextBlock;
var isStartOfBlock = splitInfo.wasStartOfBlock,
isEndOfBlock = splitInfo.wasEndOfBlock;
var node;
// If this is a block under a list item, split it as well. (#1647)
if ( nextBlock )
{
node = nextBlock.getParent();
if ( node.is( 'li' ) )
{
nextBlock.breakParent( node );
nextBlock.move( nextBlock.getNext(), 1 );
}
}
else if ( previousBlock && ( node = previousBlock.getParent() ) && node.is( 'li' ) )
{
previousBlock.breakParent( node );
node = previousBlock.getNext();
range.moveToElementEditStart( node );
previousBlock.move( previousBlock.getPrevious() );
}
// If we have both the previous and next blocks, it means that the
// boundaries were on separated blocks, or none of them where on the
// block limits (start/end).
if ( !isStartOfBlock && !isEndOfBlock )
{
// If the next block is an <li> with another list tree as the first
// child, we'll need to append a filler (<br>/NBSP) or the list item
// wouldn't be editable. (#1420)
if ( nextBlock.is( 'li' )
&& ( node = nextBlock.getFirst( CKEDITOR.dom.walker.invisible( true ) ) )
&& node.is && node.is( 'ul', 'ol' ) )
( CKEDITOR.env.ie ? doc.createText( '\xa0' ) : doc.createElement( 'br' ) ).insertBefore( node );
// Move the selection to the end block.
if ( nextBlock )
range.moveToElementEditStart( nextBlock );
}
else
{
var newBlock,
newBlockDir;
if ( previousBlock )
{
// Do not enter this block if it's a header tag, or we are in
// a Shift+Enter (#77). Create a new block element instead
// (later in the code).
if ( previousBlock.is( 'li' ) ||
! ( headerTagRegex.test( previousBlock.getName() ) || previousBlock.is( 'pre' ) ) )
{
// Otherwise, duplicate the previous block.
newBlock = previousBlock.clone();
}
}
else if ( nextBlock )
newBlock = nextBlock.clone();
if ( !newBlock )
{
// We have already created a new list item. (#6849)
if ( node && node.is( 'li' ) )
newBlock = node;
else
{
newBlock = doc.createElement( blockTag );
if ( previousBlock && ( newBlockDir = previousBlock.getDirection() ) )
newBlock.setAttribute( 'dir', newBlockDir );
}
}
// Force the enter block unless we're talking of a list item.
else if ( forceMode && !newBlock.is( 'li' ) )
newBlock.renameNode( blockTag );
// Recreate the inline elements tree, which was available
// before hitting enter, so the same styles will be available in
// the new block.
var elementPath = splitInfo.elementPath;
if ( elementPath )
{
for ( var i = 0, len = elementPath.elements.length ; i < len ; i++ )
{
var element = elementPath.elements[ i ];
if ( element.equals( elementPath.block ) || element.equals( elementPath.blockLimit ) )
break;
if ( CKEDITOR.dtd.$removeEmpty[ element.getName() ] )
{
element = element.clone();
newBlock.moveChildren( element );
newBlock.append( element );
}
}
}
if ( !CKEDITOR.env.ie )
newBlock.appendBogus();
if ( !newBlock.getParent() )
range.insertNode( newBlock );
// list item start number should not be duplicated (#7330), but we need
// to remove the attribute after it's onto the DOM tree because of old IEs (#7581).
newBlock.is( 'li' ) && newBlock.removeAttribute( 'value' );
// This is tricky, but to make the new block visible correctly
// we must select it.
// The previousBlock check has been included because it may be
// empty if we have fixed a block-less space (like ENTER into an
// empty table cell).
if ( CKEDITOR.env.ie && isStartOfBlock && ( !isEndOfBlock || !previousBlock.getChildCount() ) )
{
// Move the selection to the new block.
range.moveToElementEditStart( isEndOfBlock ? previousBlock : newBlock );
range.select();
}
// Move the selection to the new block.
range.moveToElementEditStart( isStartOfBlock && !isEndOfBlock ? nextBlock : newBlock );
}
if ( !CKEDITOR.env.ie )
{
if ( nextBlock )
{
// If we have split the block, adds a temporary span at the
// range position and scroll relatively to it.
var tmpNode = doc.createElement( 'span' );
// We need some content for Safari.
tmpNode.setHtml( ' ' );
range.insertNode( tmpNode );
tmpNode.scrollIntoView();
range.deleteContents();
}
else
{
// We may use the above scroll logic for the new block case
// too, but it gives some weird result with Opera.
newBlock.scrollIntoView();
}
}
range.select();
},
enterBr : function( editor, mode, range, forceMode )
{
// Get the range for the current selection.
range = range || getRange( editor );
// We may not have valid ranges to work on, like when inside a
// contenteditable=false element.
if ( !range )
return;
var doc = range.document;
// Determine the block element to be used.
var blockTag = ( mode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
var isEndOfBlock = range.checkEndOfBlock();
var elementPath = new CKEDITOR.dom.elementPath( editor.getSelection().getStartElement() );
var startBlock = elementPath.block,
startBlockTag = startBlock && elementPath.block.getName();
var isPre = false;
if ( !forceMode && startBlockTag == 'li' )
{
enterBlock( editor, mode, range, forceMode );
return;
}
// If we are at the end of a header block.
if ( !forceMode && isEndOfBlock && headerTagRegex.test( startBlockTag ) )
{
var newBlock,
newBlockDir;
if ( ( newBlockDir = startBlock.getDirection() ) )
{
newBlock = doc.createElement( 'div' );
newBlock.setAttribute( 'dir', newBlockDir );
newBlock.insertAfter( startBlock );
range.setStart( newBlock, 0 );
}
else
{
// Insert a <br> after the current paragraph.
doc.createElement( 'br' ).insertAfter( startBlock );
// A text node is required by Gecko only to make the cursor blink.
if ( CKEDITOR.env.gecko )
doc.createText( '' ).insertAfter( startBlock );
// IE has different behaviors regarding position.
range.setStartAt( startBlock.getNext(), CKEDITOR.env.ie ? CKEDITOR.POSITION_BEFORE_START : CKEDITOR.POSITION_AFTER_START );
}
}
else
{
var lineBreak;
isPre = ( startBlockTag == 'pre' );
// Gecko prefers <br> as line-break inside <pre> (#4711).
if ( isPre && !CKEDITOR.env.gecko )
lineBreak = doc.createText( CKEDITOR.env.ie ? '\r' : '\n' );
else
lineBreak = doc.createElement( 'br' );
range.deleteContents();
range.insertNode( lineBreak );
// IE has different behavior regarding position.
if ( CKEDITOR.env.ie )
range.setStartAt( lineBreak, CKEDITOR.POSITION_AFTER_END );
else
{
// A text node is required by Gecko only to make the cursor blink.
// We need some text inside of it, so the bogus <br> is properly
// created.
doc.createText( '\ufeff' ).insertAfter( lineBreak );
// If we are at the end of a block, we must be sure the bogus node is available in that block.
if ( isEndOfBlock )
lineBreak.getParent().appendBogus();
// Now we can remove the text node contents, so the caret doesn't
// stop on it.
lineBreak.getNext().$.nodeValue = '';
range.setStartAt( lineBreak.getNext(), CKEDITOR.POSITION_AFTER_START );
// Scroll into view, for non IE.
var dummy = null;
// BR is not positioned in Opera and Webkit.
if ( !CKEDITOR.env.gecko )
{
dummy = doc.createElement( 'span' );
// We need have some contents for Webkit to position it
// under parent node. ( #3681)
dummy.setHtml(' ');
}
else
dummy = doc.createElement( 'br' );
dummy.insertBefore( lineBreak.getNext() );
dummy.scrollIntoView();
dummy.remove();
}
}
// This collapse guarantees the cursor will be blinking.
range.collapse( true );
range.select( isPre );
}
};
var plugin = CKEDITOR.plugins.enterkey,
enterBr = plugin.enterBr,
enterBlock = plugin.enterBlock,
headerTagRegex = /^h[1-6]$/;
function shiftEnter( editor )
{
// Only effective within document.
if ( editor.mode != 'wysiwyg' )
return false;
// On SHIFT+ENTER:
// 1. We want to enforce the mode to be respected, instead
// of cloning the current block. (#77)
return enter( editor, editor.config.shiftEnterMode, 1 );
}
function enter( editor, mode, forceMode )
{
forceMode = editor.config.forceEnterMode || forceMode;
// Only effective within document.
if ( editor.mode != 'wysiwyg' )
return false;
if ( !mode )
mode = editor.config.enterMode;
// Use setTimout so the keys get cancelled immediatelly.
setTimeout( function()
{
editor.fire( 'saveSnapshot' ); // Save undo step.
if ( mode == CKEDITOR.ENTER_BR )
enterBr( editor, mode, null, forceMode );
else
enterBlock( editor, mode, null, forceMode );
editor.fire( 'saveSnapshot' );
}, 0 );
return true;
}
function getRange( editor )
{
// Get the selection ranges.
var ranges = editor.getSelection().getRanges( true );
// Delete the contents of all ranges except the first one.
for ( var i = ranges.length - 1 ; i > 0 ; i-- )
{
ranges[ i ].deleteContents();
}
// Return the first range.
return ranges[ 0 ];
}
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview The "elementspath" plugin. It shows all elements in the DOM
* parent tree relative to the current selection in the editing area.
*/
(function()
{
var commands =
{
toolbarFocus :
{
editorFocus : false,
readOnly : 1,
exec : function( editor )
{
var idBase = editor._.elementsPath.idBase;
var element = CKEDITOR.document.getById( idBase + '0' );
// Make the first button focus accessible for IE. (#3417)
// Adobe AIR instead need while of delay.
element && element.focus( CKEDITOR.env.ie || CKEDITOR.env.air );
}
}
};
var emptyHtml = '<span class="cke_empty"> </span>';
CKEDITOR.plugins.add( 'elementspath',
{
requires : [ 'selection' ],
init : function( editor )
{
var spaceId = 'cke_path_' + editor.name;
var spaceElement;
var getSpaceElement = function()
{
if ( !spaceElement )
spaceElement = CKEDITOR.document.getById( spaceId );
return spaceElement;
};
var idBase = 'cke_elementspath_' + CKEDITOR.tools.getNextNumber() + '_';
editor._.elementsPath = { idBase : idBase, filters : [] };
editor.on( 'themeSpace', function( event )
{
if ( event.data.space == 'bottom' )
{
event.data.html +=
'<span id="' + spaceId + '_label" class="cke_voice_label">' + editor.lang.elementsPath.eleLabel + '</span>' +
'<div id="' + spaceId + '" class="cke_path" role="group" aria-labelledby="' + spaceId + '_label">' + emptyHtml + '</div>';
}
});
function onClick( elementIndex )
{
editor.focus();
var element = editor._.elementsPath.list[ elementIndex ];
if ( element.is( 'body' ) )
{
var range = new CKEDITOR.dom.range( editor.document );
range.selectNodeContents( element );
range.select();
}
else
editor.getSelection().selectElement( element );
}
var onClickHanlder = CKEDITOR.tools.addFunction( onClick );
var onKeyDownHandler = CKEDITOR.tools.addFunction( function( elementIndex, ev )
{
var idBase = editor._.elementsPath.idBase,
element;
ev = new CKEDITOR.dom.event( ev );
var rtl = editor.lang.dir == 'rtl';
switch ( ev.getKeystroke() )
{
case rtl ? 39 : 37 : // LEFT-ARROW
case 9 : // TAB
element = CKEDITOR.document.getById( idBase + ( elementIndex + 1 ) );
if ( !element )
element = CKEDITOR.document.getById( idBase + '0' );
element.focus();
return false;
case rtl ? 37 : 39 : // RIGHT-ARROW
case CKEDITOR.SHIFT + 9 : // SHIFT + TAB
element = CKEDITOR.document.getById( idBase + ( elementIndex - 1 ) );
if ( !element )
element = CKEDITOR.document.getById( idBase + ( editor._.elementsPath.list.length - 1 ) );
element.focus();
return false;
case 27 : // ESC
editor.focus();
return false;
case 13 : // ENTER // Opera
case 32 : // SPACE
onClick( elementIndex );
return false;
}
return true;
});
editor.on( 'selectionChange', function( ev )
{
var env = CKEDITOR.env,
selection = ev.data.selection,
element = selection.getStartElement(),
html = [],
editor = ev.editor,
elementsList = editor._.elementsPath.list = [],
filters = editor._.elementsPath.filters;
while ( element )
{
var ignore = 0,
name;
if ( element.data( 'cke-display-name' ) )
name = element.data( 'cke-display-name' );
else if ( element.data( 'cke-real-element-type' ) )
name = element.data( 'cke-real-element-type' );
else
name = element.getName();
for ( var i = 0; i < filters.length; i++ )
{
var ret = filters[ i ]( element, name );
if ( ret === false )
{
ignore = 1;
break;
}
name = ret || name;
}
if ( !ignore )
{
var index = elementsList.push( element ) - 1;
// Use this variable to add conditional stuff to the
// HTML (because we are doing it in reverse order... unshift).
var extra = '';
// Some browsers don't cancel key events in the keydown but in the
// keypress.
// TODO: Check if really needed for Gecko+Mac.
if ( env.opera || ( env.gecko && env.mac ) )
extra += ' onkeypress="return false;"';
// With Firefox, we need to force the button to redraw, otherwise it
// will remain in the focus state.
if ( env.gecko )
extra += ' onblur="this.style.cssText = this.style.cssText;"';
var label = editor.lang.elementsPath.eleTitle.replace( /%1/, name );
html.unshift(
'<a' +
' id="', idBase, index, '"' +
' href="javascript:void(\'', name, '\')"' +
' tabindex="-1"' +
' title="', label, '"' +
( ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 ) ?
' onfocus="event.preventBubble();"' : '' ) +
' hidefocus="true" ' +
' onkeydown="return CKEDITOR.tools.callFunction(', onKeyDownHandler, ',', index, ', event );"' +
extra ,
' onclick="CKEDITOR.tools.callFunction('+ onClickHanlder, ',', index, '); return false;"',
' role="button" aria-labelledby="' + idBase + index + '_label">',
name,
'<span id="', idBase, index, '_label" class="cke_label">' + label + '</span>',
'</a>' );
}
if ( name == 'body' )
break;
element = element.getParent();
}
var space = getSpaceElement();
space.setHtml( html.join('') + emptyHtml );
editor.fire( 'elementsPathUpdate', { space : space } );
});
function empty()
{
spaceElement && spaceElement.setHtml( emptyHtml );
delete editor._.elementsPath.list;
}
editor.on( 'readOnly', empty );
editor.on( 'contentDomUnload', empty );
editor.addCommand( 'elementsPathFocus', commands.toolbarFocus );
}
});
})();
/**
* Fired when the contents of the elementsPath are changed
* @name CKEDITOR.editor#elementsPathUpdate
* @event
* @param {Object} eventData.space The elementsPath container
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'contextmenu',
{
requires : [ 'menu' ],
// Make sure the base class (CKEDITOR.menu) is loaded before it (#3318).
onLoad : function()
{
CKEDITOR.plugins.contextMenu = CKEDITOR.tools.createClass(
{
base : CKEDITOR.menu,
$ : function( editor )
{
this.base.call( this, editor,
{
panel:
{
className : editor.skinClass + ' cke_contextmenu',
attributes :
{
'aria-label' : editor.lang.contextmenu.options
}
}
});
},
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 && !( 'oncontextmenu' in document.body ))
{
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
&& ( CKEDITOR.env.mac ? evt.$.metaKey : evt.$.ctrlKey ) )
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 : ( CKEDITOR.env.mac ? domEvent.$.metaKey : domEvent.$.ctrlKey ) ) )
return;
// Cancel the browser context menu.
domEvent.preventDefault();
var offsetParent = domEvent.getTarget().getDocument().getDocumentElement(),
offsetX = domEvent.$.clientX,
offsetY = domEvent.$.clientY;
CKEDITOR.tools.setTimeout( function()
{
this.open( offsetParent, null, offsetX, offsetY );
// IE needs a short while to allow selection change before opening menu. (#7908)
}, CKEDITOR.env.ie? 200 : 0, this );
},
this );
if ( CKEDITOR.env.opera )
{
// 'contextmenu' event triggered by Windows menu key is unpreventable,
// cancel the key event itself. (#6534)
element.on( 'keypress' , function ( evt )
{
var domEvent = evt.data;
if ( domEvent.$.keyCode === 0 )
domEvent.preventDefault();
});
}
if ( CKEDITOR.env.webkit )
{
var holdCtrlKey,
onKeyDown = function( event )
{
holdCtrlKey = CKEDITOR.env.mac ? event.data.$.metaKey : event.data.$.ctrlKey ;
},
resetOnKeyUp = function()
{
holdCtrlKey = 0;
};
element.on( 'keydown', onKeyDown );
element.on( 'keyup', resetOnKeyUp );
element.on( 'contextmenu', resetOnKeyUp );
}
},
open : function( offsetParent, corner, offsetX, offsetY )
{
this.editor.focus();
offsetParent = offsetParent || CKEDITOR.document.getDocumentElement();
this.show( offsetParent, corner, offsetX, offsetY );
}
}
});
},
beforeInit : function( editor )
{
editor.contextMenu = new CKEDITOR.plugins.contextMenu( editor );
editor.addCommand( 'contextMenu',
{
exec : function()
{
editor.contextMenu.open( editor.document.getBody() );
}
});
}
});
/**
* Whether to show the browser native context menu when the <em>Ctrl</em> or
* <em>Meta</em> (Mac) key is pressed on opening the context menu with the
* right mouse button click or the <em>Menu</em> key.
* @name CKEDITOR.config.browserContextMenuOnCtrl
* @since 3.0.2
* @type Boolean
* @default <code>true</code>
* @example
* config.browserContextMenuOnCtrl = false;
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'link',
{
requires : [ 'fakeobjects', 'dialog' ],
init : function( editor )
{
// Add the link and unlink buttons.
editor.addCommand( 'link', new CKEDITOR.dialogCommand( 'link' ) );
editor.addCommand( 'anchor', new CKEDITOR.dialogCommand( 'anchor' ) );
editor.addCommand( 'unlink', new CKEDITOR.unlinkCommand() );
editor.addCommand( 'removeAnchor', new CKEDITOR.removeAnchorCommand() );
editor.ui.addButton( 'Link',
{
label : editor.lang.link.toolbar,
command : 'link'
} );
editor.ui.addButton( 'Unlink',
{
label : editor.lang.unlink,
command : 'unlink'
} );
editor.ui.addButton( 'Anchor',
{
label : editor.lang.anchor.toolbar,
command : 'anchor'
} );
CKEDITOR.dialog.add( 'link', this.path + 'dialogs/link.js' );
CKEDITOR.dialog.add( 'anchor', this.path + 'dialogs/anchor.js' );
// Add the CSS styles for anchor placeholders.
var side = ( editor.lang.dir == 'rtl' ? 'right' : 'left' );
var basicCss =
'background:url(' + CKEDITOR.getUrl( this.path + 'images/anchor.gif' ) + ') no-repeat ' + side + ' center;' +
'border:1px dotted #00f;';
editor.addCss(
'a.cke_anchor,a.cke_anchor_empty' +
// IE6 breaks with the following selectors.
( ( CKEDITOR.env.ie && CKEDITOR.env.version < 7 ) ? '' :
',a[name],a[data-cke-saved-name]' ) +
'{' +
basicCss +
'padding-' + side + ':18px;' +
// Show the arrow cursor for the anchor image (FF at least).
'cursor:auto;' +
'}' +
( CKEDITOR.env.ie ? (
'a.cke_anchor_empty' +
'{' +
// Make empty anchor selectable on IE.
'display:inline-block;' +
'}'
) : '' ) +
'img.cke_anchor' +
'{' +
basicCss +
'width:16px;' +
'min-height:15px;' +
// The default line-height on IE.
'height:1.15em;' +
// Opera works better with "middle" (even if not perfect)
'vertical-align:' + ( CKEDITOR.env.opera ? 'middle' : 'text-bottom' ) + ';' +
'}');
// Register selection change handler for the unlink button.
editor.on( 'selectionChange', function( evt )
{
if ( editor.readOnly )
return;
/*
* Despite our initial hope, document.queryCommandEnabled() does not work
* for this in Firefox. So we must detect the state by element paths.
*/
var command = editor.getCommand( 'unlink' ),
element = evt.data.path.lastElement && evt.data.path.lastElement.getAscendant( 'a', true );
if ( element && element.getName() == 'a' && element.getAttribute( 'href' ) && element.getChildCount() )
command.setState( CKEDITOR.TRISTATE_OFF );
else
command.setState( CKEDITOR.TRISTATE_DISABLED );
} );
editor.on( 'doubleclick', function( evt )
{
var element = CKEDITOR.plugins.link.getSelectedLink( editor ) || evt.data.element;
if ( !element.isReadOnly() )
{
if ( element.is( 'a' ) )
{
evt.data.dialog = ( element.getAttribute( 'name' ) && ( !element.getAttribute( 'href' ) || !element.getChildCount() ) ) ? 'anchor' : 'link';
editor.getSelection().selectElement( element );
}
else if ( CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, element ) )
evt.data.dialog = 'anchor';
}
});
// If the "menu" plugin is loaded, register the menu items.
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
anchor :
{
label : editor.lang.anchor.menu,
command : 'anchor',
group : 'anchor',
order : 1
},
removeAnchor :
{
label : editor.lang.anchor.remove,
command : 'removeAnchor',
group : 'anchor',
order : 5
},
link :
{
label : editor.lang.link.menu,
command : 'link',
group : 'link',
order : 1
},
unlink :
{
label : editor.lang.unlink,
command : 'unlink',
group : 'link',
order : 5
}
});
}
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( !element || element.isReadOnly() )
return null;
var anchor = CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, element );
if ( !anchor && !( anchor = CKEDITOR.plugins.link.getSelectedLink( editor ) ) )
return null;
var menu = {};
if ( anchor.getAttribute( 'href' ) && anchor.getChildCount() )
menu = { link : CKEDITOR.TRISTATE_OFF, unlink : CKEDITOR.TRISTATE_OFF };
if ( anchor && anchor.hasAttribute( 'name' ) )
menu.anchor = menu.removeAnchor = CKEDITOR.TRISTATE_OFF;
return menu;
});
}
},
afterInit : function( editor )
{
// Register a filter to displaying placeholders after mode change.
var dataProcessor = editor.dataProcessor,
dataFilter = dataProcessor && dataProcessor.dataFilter,
htmlFilter = dataProcessor && dataProcessor.htmlFilter,
pathFilters = editor._.elementsPath && editor._.elementsPath.filters;
if ( dataFilter )
{
dataFilter.addRules(
{
elements :
{
a : function( element )
{
var attributes = element.attributes;
if ( !attributes.name )
return null;
var isEmpty = !element.children.length;
if ( CKEDITOR.plugins.link.synAnchorSelector )
{
// IE needs a specific class name to be applied
// to the anchors, for appropriate styling.
var ieClass = isEmpty ? 'cke_anchor_empty' : 'cke_anchor';
var cls = attributes[ 'class' ];
if ( attributes.name && ( !cls || cls.indexOf( ieClass ) < 0 ) )
attributes[ 'class' ] = ( cls || '' ) + ' ' + ieClass;
if ( isEmpty && CKEDITOR.plugins.link.emptyAnchorFix )
{
attributes.contenteditable = 'false';
attributes[ 'data-cke-editable' ] = 1;
}
}
else if ( CKEDITOR.plugins.link.fakeAnchor && isEmpty )
return editor.createFakeParserElement( element, 'cke_anchor', 'anchor' );
return null;
}
}
});
}
if ( CKEDITOR.plugins.link.emptyAnchorFix && htmlFilter )
{
htmlFilter.addRules(
{
elements :
{
a : function( element )
{
delete element.attributes.contenteditable;
}
}
});
}
if ( pathFilters )
{
pathFilters.push( function( element, name )
{
if ( name == 'a' )
{
if ( CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, element ) ||
( element.getAttribute( 'name' ) && ( !element.getAttribute( 'href' ) || !element.getChildCount() ) ) )
{
return 'anchor';
}
}
});
}
}
} );
CKEDITOR.plugins.link =
{
/**
* Get the surrounding link element of current selection.
* @param editor
* @example CKEDITOR.plugins.link.getSelectedLink( editor );
* @since 3.2.1
* The following selection will all return the link element.
* <pre>
* <a href="#">li^nk</a>
* <a href="#">[link]</a>
* text[<a href="#">link]</a>
* <a href="#">li[nk</a>]
* [<b><a href="#">li]nk</a></b>]
* [<a href="#"><b>li]nk</b></a>
* </pre>
*/
getSelectedLink : function( editor )
{
try
{
var selection = editor.getSelection();
if ( selection.getType() == CKEDITOR.SELECTION_ELEMENT )
{
var selectedElement = selection.getSelectedElement();
if ( selectedElement.is( 'a' ) )
return selectedElement;
}
var range = selection.getRanges( true )[ 0 ];
range.shrink( CKEDITOR.SHRINK_TEXT );
var root = range.getCommonAncestor();
return root.getAscendant( 'a', true );
}
catch( e ) { return null; }
},
// Opera and WebKit don't make it possible to select empty anchors. Fake
// elements must be used for them.
fakeAnchor : CKEDITOR.env.opera || CKEDITOR.env.webkit,
// For browsers that don't support CSS3 a[name]:empty(), note IE9 is included because of #7783.
synAnchorSelector : CKEDITOR.env.ie,
// For browsers that have editing issue with empty anchor.
emptyAnchorFix : CKEDITOR.env.ie && CKEDITOR.env.version < 8,
tryRestoreFakeAnchor : function( editor, element )
{
if ( element && element.data( 'cke-real-element-type' ) && element.data( 'cke-real-element-type' ) == 'anchor' )
{
var link = editor.restoreRealElement( element );
if ( link.data( 'cke-saved-name' ) )
return link;
}
}
};
CKEDITOR.unlinkCommand = function(){};
CKEDITOR.unlinkCommand.prototype =
{
/** @ignore */
exec : function( editor )
{
/*
* execCommand( 'unlink', ... ) in Firefox leaves behind <span> tags at where
* the <a> was, so again we have to remove the link ourselves. (See #430)
*
* TODO: Use the style system when it's complete. Let's use execCommand()
* as a stopgap solution for now.
*/
var selection = editor.getSelection(),
bookmarks = selection.createBookmarks(),
ranges = selection.getRanges(),
rangeRoot,
element;
for ( var i = 0 ; i < ranges.length ; i++ )
{
rangeRoot = ranges[i].getCommonAncestor( true );
element = rangeRoot.getAscendant( 'a', true );
if ( !element )
continue;
ranges[i].selectNodeContents( element );
}
selection.selectRanges( ranges );
editor.document.$.execCommand( 'unlink', false, null );
selection.selectBookmarks( bookmarks );
},
startDisabled : true
};
CKEDITOR.removeAnchorCommand = function(){};
CKEDITOR.removeAnchorCommand.prototype =
{
/** @ignore */
exec : function( editor )
{
var sel = editor.getSelection(),
bms = sel.createBookmarks(),
anchor;
if ( sel && ( anchor = sel.getSelectedElement() ) && ( CKEDITOR.plugins.link.fakeAnchor && !anchor.getChildCount() ? CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, anchor ) : anchor.is( 'a' ) ) )
anchor.remove( 1 );
else
{
if ( ( anchor = CKEDITOR.plugins.link.getSelectedLink( editor ) ) )
{
if ( anchor.hasAttribute( 'href' ) )
{
anchor.removeAttributes( { name : 1, 'data-cke-saved-name' : 1 } );
anchor.removeClass( 'cke_anchor' );
}
else
anchor.remove( 1 );
}
}
sel.selectBookmarks( bms );
}
};
CKEDITOR.tools.extend( CKEDITOR.config,
{
linkShowAdvancedTab : true,
linkShowTargetTab : true
} );
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'anchor', function( editor )
{
// Function called in onShow to load selected element.
var loadElements = function( element )
{
this._.selectedElement = element;
var attributeValue = element.data( 'cke-saved-name' );
this.setValueOf( 'info','txtName', attributeValue || '' );
};
function createFakeAnchor( editor, anchor )
{
return editor.createFakeElement( anchor, 'cke_anchor', 'anchor' );
}
return {
title : editor.lang.anchor.title,
minWidth : 300,
minHeight : 60,
onOk : function()
{
var name = CKEDITOR.tools.trim( this.getValueOf( 'info', 'txtName' ) );
var attributes =
{
name : name,
'data-cke-saved-name' : name
};
if ( this._.selectedElement )
{
if ( this._.selectedElement.data( 'cke-realelement' ) )
{
var newFake = createFakeAnchor( editor, editor.document.createElement( 'a', { attributes: attributes } ) );
newFake.replace( this._.selectedElement );
}
else
this._.selectedElement.setAttributes( attributes );
}
else
{
var sel = editor.getSelection(),
range = sel && sel.getRanges()[ 0 ];
// Empty anchor
if ( range.collapsed )
{
if ( CKEDITOR.plugins.link.synAnchorSelector )
attributes[ 'class' ] = 'cke_anchor_empty';
if ( CKEDITOR.plugins.link.emptyAnchorFix )
{
attributes[ 'contenteditable' ] = 'false';
attributes[ 'data-cke-editable' ] = 1;
}
var anchor = editor.document.createElement( 'a', { attributes: attributes } );
// Transform the anchor into a fake element for browsers that need it.
if ( CKEDITOR.plugins.link.fakeAnchor )
anchor = createFakeAnchor( editor, anchor );
range.insertNode( anchor );
}
else
{
if ( CKEDITOR.env.ie && CKEDITOR.env.version < 9 )
attributes['class'] = 'cke_anchor';
// Apply style.
var style = new CKEDITOR.style( { element : 'a', attributes : attributes } );
style.type = CKEDITOR.STYLE_INLINE;
style.apply( editor.document );
}
}
},
onHide : function()
{
delete this._.selectedElement;
},
onShow : function()
{
var selection = editor.getSelection(),
fullySelected = selection.getSelectedElement(),
partialSelected;
// Detect the anchor under selection.
if ( fullySelected )
{
if ( CKEDITOR.plugins.link.fakeAnchor )
{
var realElement = CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, fullySelected );
realElement && loadElements.call( this, realElement );
this._.selectedElement = fullySelected;
}
else if ( fullySelected.is( 'a' ) && fullySelected.hasAttribute( 'name' ) )
loadElements.call( this, fullySelected );
}
else
{
partialSelected = CKEDITOR.plugins.link.getSelectedLink( editor );
if ( partialSelected )
{
loadElements.call( this, partialSelected );
selection.selectElement( partialSelected );
}
}
this.getContentElement( 'info', 'txtName' ).focus();
},
contents : [
{
id : 'info',
label : editor.lang.anchor.title,
accessKey : 'I',
elements :
[
{
type : 'text',
id : 'txtName',
label : editor.lang.anchor.name,
required: true,
validate : function()
{
if ( !this.getValue() )
{
alert( editor.lang.anchor.errorName );
return false;
}
return true;
}
}
]
}
]
};
} );
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'link', function( editor )
{
var plugin = CKEDITOR.plugins.link;
// Handles the event when the "Target" selection box is changed.
var targetChanged = function()
{
var dialog = this.getDialog(),
popupFeatures = dialog.getContentElement( 'target', 'popupFeatures' ),
targetName = dialog.getContentElement( 'target', 'linkTargetName' ),
value = this.getValue();
if ( !popupFeatures || !targetName )
return;
popupFeatures = popupFeatures.getElement();
popupFeatures.hide();
targetName.setValue( '' );
switch ( value )
{
case 'frame' :
targetName.setLabel( editor.lang.link.targetFrameName );
targetName.getElement().show();
break;
case 'popup' :
popupFeatures.show();
targetName.setLabel( editor.lang.link.targetPopupName );
targetName.getElement().show();
break;
default :
targetName.setValue( value );
targetName.getElement().hide();
break;
}
};
// Handles the event when the "Type" selection box is changed.
var linkTypeChanged = function()
{
var dialog = this.getDialog(),
partIds = [ 'urlOptions', 'anchorOptions', 'emailOptions' ],
typeValue = this.getValue(),
uploadTab = dialog.definition.getContents( 'upload' ),
uploadInitiallyHidden = uploadTab && uploadTab.hidden;
if ( typeValue == 'url' )
{
if ( editor.config.linkShowTargetTab )
dialog.showPage( 'target' );
if ( !uploadInitiallyHidden )
dialog.showPage( 'upload' );
}
else
{
dialog.hidePage( 'target' );
if ( !uploadInitiallyHidden )
dialog.hidePage( 'upload' );
}
for ( var i = 0 ; i < partIds.length ; i++ )
{
var element = dialog.getContentElement( 'info', partIds[i] );
if ( !element )
continue;
element = element.getElement().getParent().getParent();
if ( partIds[i] == typeValue + 'Options' )
element.show();
else
element.hide();
}
dialog.layout();
};
// Loads the parameters in a selected link to the link dialog fields.
var javascriptProtocolRegex = /^javascript:/,
emailRegex = /^mailto:([^?]+)(?:\?(.+))?$/,
emailSubjectRegex = /subject=([^;?:@&=$,\/]*)/,
emailBodyRegex = /body=([^;?:@&=$,\/]*)/,
anchorRegex = /^#(.*)$/,
urlRegex = /^((?:http|https|ftp|news):\/\/)?(.*)$/,
selectableTargets = /^(_(?:self|top|parent|blank))$/,
encodedEmailLinkRegex = /^javascript:void\(location\.href='mailto:'\+String\.fromCharCode\(([^)]+)\)(?:\+'(.*)')?\)$/,
functionCallProtectedEmailLinkRegex = /^javascript:([^(]+)\(([^)]+)\)$/;
var popupRegex =
/\s*window.open\(\s*this\.href\s*,\s*(?:'([^']*)'|null)\s*,\s*'([^']*)'\s*\)\s*;\s*return\s*false;*\s*/;
var popupFeaturesRegex = /(?:^|,)([^=]+)=(\d+|yes|no)/gi;
var parseLink = function( editor, element )
{
var href = ( element && ( element.data( 'cke-saved-href' ) || element.getAttribute( 'href' ) ) ) || '',
javascriptMatch,
emailMatch,
anchorMatch,
urlMatch,
retval = {};
if ( ( javascriptMatch = href.match( javascriptProtocolRegex ) ) )
{
if ( emailProtection == 'encode' )
{
href = href.replace( encodedEmailLinkRegex,
function ( match, protectedAddress, rest )
{
return 'mailto:' +
String.fromCharCode.apply( String, protectedAddress.split( ',' ) ) +
( rest && unescapeSingleQuote( rest ) );
});
}
// Protected email link as function call.
else if ( emailProtection )
{
href.replace( functionCallProtectedEmailLinkRegex, function( match, funcName, funcArgs )
{
if ( funcName == compiledProtectionFunction.name )
{
retval.type = 'email';
var email = retval.email = {};
var paramRegex = /[^,\s]+/g,
paramQuoteRegex = /(^')|('$)/g,
paramsMatch = funcArgs.match( paramRegex ),
paramsMatchLength = paramsMatch.length,
paramName,
paramVal;
for ( var i = 0; i < paramsMatchLength; i++ )
{
paramVal = decodeURIComponent( unescapeSingleQuote( paramsMatch[ i ].replace( paramQuoteRegex, '' ) ) );
paramName = compiledProtectionFunction.params[ i ].toLowerCase();
email[ paramName ] = paramVal;
}
email.address = [ email.name, email.domain ].join( '@' );
}
} );
}
}
if ( !retval.type )
{
if ( ( anchorMatch = href.match( anchorRegex ) ) )
{
retval.type = 'anchor';
retval.anchor = {};
retval.anchor.name = retval.anchor.id = anchorMatch[1];
}
// Protected email link as encoded string.
else if ( ( emailMatch = href.match( emailRegex ) ) )
{
var subjectMatch = href.match( emailSubjectRegex ),
bodyMatch = href.match( emailBodyRegex );
retval.type = 'email';
var email = ( retval.email = {} );
email.address = emailMatch[ 1 ];
subjectMatch && ( email.subject = decodeURIComponent( subjectMatch[ 1 ] ) );
bodyMatch && ( email.body = decodeURIComponent( bodyMatch[ 1 ] ) );
}
// urlRegex matches empty strings, so need to check for href as well.
else if ( href && ( urlMatch = href.match( urlRegex ) ) )
{
retval.type = 'url';
retval.url = {};
retval.url.protocol = urlMatch[1];
retval.url.url = urlMatch[2];
}
else
retval.type = 'url';
}
// Load target and popup settings.
if ( element )
{
var target = element.getAttribute( 'target' );
retval.target = {};
retval.adv = {};
// IE BUG: target attribute is an empty string instead of null in IE if it's not set.
if ( !target )
{
var onclick = element.data( 'cke-pa-onclick' ) || element.getAttribute( 'onclick' ),
onclickMatch = onclick && onclick.match( popupRegex );
if ( onclickMatch )
{
retval.target.type = 'popup';
retval.target.name = onclickMatch[1];
var featureMatch;
while ( ( featureMatch = popupFeaturesRegex.exec( onclickMatch[2] ) ) )
{
// Some values should remain numbers (#7300)
if ( ( featureMatch[2] == 'yes' || featureMatch[2] == '1' ) && !( featureMatch[1] in { height:1, width:1, top:1, left:1 } ) )
retval.target[ featureMatch[1] ] = true;
else if ( isFinite( featureMatch[2] ) )
retval.target[ featureMatch[1] ] = featureMatch[2];
}
}
}
else
{
var targetMatch = target.match( selectableTargets );
if ( targetMatch )
retval.target.type = retval.target.name = target;
else
{
retval.target.type = 'frame';
retval.target.name = target;
}
}
var me = this;
var advAttr = function( inputName, attrName )
{
var value = element.getAttribute( attrName );
if ( value !== null )
retval.adv[ inputName ] = value || '';
};
advAttr( 'advId', 'id' );
advAttr( 'advLangDir', 'dir' );
advAttr( 'advAccessKey', 'accessKey' );
retval.adv.advName =
element.data( 'cke-saved-name' )
|| element.getAttribute( 'name' )
|| '';
advAttr( 'advLangCode', 'lang' );
advAttr( 'advTabIndex', 'tabindex' );
advAttr( 'advTitle', 'title' );
advAttr( 'advContentType', 'type' );
CKEDITOR.plugins.link.synAnchorSelector ?
retval.adv.advCSSClasses = getLinkClass( element )
: advAttr( 'advCSSClasses', 'class' );
advAttr( 'advCharset', 'charset' );
advAttr( 'advStyles', 'style' );
advAttr( 'advRel', 'rel' );
}
// Find out whether we have any anchors in the editor.
var anchors = retval.anchors = [],
i, count, item;
// For some browsers we set contenteditable="false" on anchors, making document.anchors not to include them, so we must traverse the links manually (#7893).
if ( CKEDITOR.plugins.link.emptyAnchorFix )
{
var links = editor.document.getElementsByTag( 'a' );
for ( i = 0, count = links.count(); i < count; i++ )
{
item = links.getItem( i );
if ( item.data( 'cke-saved-name' ) || item.hasAttribute( 'name' ) )
anchors.push( { name : item.data( 'cke-saved-name' ) || item.getAttribute( 'name' ), id : item.getAttribute( 'id' ) } );
}
}
else
{
var anchorList = new CKEDITOR.dom.nodeList( editor.document.$.anchors );
for ( i = 0, count = anchorList.count(); i < count; i++ )
{
item = anchorList.getItem( i );
anchors[ i ] = { name : item.getAttribute( 'name' ), id : item.getAttribute( 'id' ) };
}
}
if ( CKEDITOR.plugins.link.fakeAnchor )
{
var imgs = editor.document.getElementsByTag( 'img' );
for ( i = 0, count = imgs.count(); i < count; i++ )
{
if ( ( item = CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, imgs.getItem( i ) ) ) )
anchors.push( { name : item.getAttribute( 'name' ), id : item.getAttribute( 'id' ) } );
}
}
// Record down the selected element in the dialog.
this._.selectedElement = element;
return retval;
};
var setupParams = function( page, data )
{
if ( data[page] )
this.setValue( data[page][this.id] || '' );
};
var setupPopupParams = function( data )
{
return setupParams.call( this, 'target', data );
};
var setupAdvParams = function( data )
{
return setupParams.call( this, 'adv', data );
};
var commitParams = function( page, data )
{
if ( !data[page] )
data[page] = {};
data[page][this.id] = this.getValue() || '';
};
var commitPopupParams = function( data )
{
return commitParams.call( this, 'target', data );
};
var commitAdvParams = function( data )
{
return commitParams.call( this, 'adv', data );
};
function unescapeSingleQuote( str )
{
return str.replace( /\\'/g, '\'' );
}
function escapeSingleQuote( str )
{
return str.replace( /'/g, '\\$&' );
}
var emailProtection = editor.config.emailProtection || '';
// Compile the protection function pattern.
if ( emailProtection && emailProtection != 'encode' )
{
var compiledProtectionFunction = {};
emailProtection.replace( /^([^(]+)\(([^)]+)\)$/, function( match, funcName, params )
{
compiledProtectionFunction.name = funcName;
compiledProtectionFunction.params = [];
params.replace( /[^,\s]+/g, function( param )
{
compiledProtectionFunction.params.push( param );
} );
} );
}
function protectEmailLinkAsFunction( email )
{
var retval,
name = compiledProtectionFunction.name,
params = compiledProtectionFunction.params,
paramName,
paramValue;
retval = [ name, '(' ];
for ( var i = 0; i < params.length; i++ )
{
paramName = params[ i ].toLowerCase();
paramValue = email[ paramName ];
i > 0 && retval.push( ',' );
retval.push( '\'',
paramValue ?
escapeSingleQuote( encodeURIComponent( email[ paramName ] ) )
: '',
'\'');
}
retval.push( ')' );
return retval.join( '' );
}
function protectEmailAddressAsEncodedString( address )
{
var charCode,
length = address.length,
encodedChars = [];
for ( var i = 0; i < length; i++ )
{
charCode = address.charCodeAt( i );
encodedChars.push( charCode );
}
return 'String.fromCharCode(' + encodedChars.join( ',' ) + ')';
}
function getLinkClass( ele )
{
var className = ele.getAttribute( 'class' );
return className ? className.replace( /\s*(?:cke_anchor_empty|cke_anchor)(?:\s*$)?/g, '' ) : '';
}
var commonLang = editor.lang.common,
linkLang = editor.lang.link;
return {
title : linkLang.title,
minWidth : 350,
minHeight : 230,
contents : [
{
id : 'info',
label : linkLang.info,
title : linkLang.info,
elements :
[
{
id : 'linkType',
type : 'select',
label : linkLang.type,
'default' : 'url',
items :
[
[ linkLang.toUrl, 'url' ],
[ linkLang.toAnchor, 'anchor' ],
[ linkLang.toEmail, 'email' ]
],
onChange : linkTypeChanged,
setup : function( data )
{
if ( data.type )
this.setValue( data.type );
},
commit : function( data )
{
data.type = this.getValue();
}
},
{
type : 'vbox',
id : 'urlOptions',
children :
[
{
type : 'hbox',
widths : [ '25%', '75%' ],
children :
[
{
id : 'protocol',
type : 'select',
label : commonLang.protocol,
'default' : 'http://',
items :
[
// Force 'ltr' for protocol names in BIDI. (#5433)
[ 'http://\u200E', 'http://' ],
[ 'https://\u200E', 'https://' ],
[ 'ftp://\u200E', 'ftp://' ],
[ 'news://\u200E', 'news://' ],
[ linkLang.other , '' ]
],
setup : function( data )
{
if ( data.url )
this.setValue( data.url.protocol || '' );
},
commit : function( data )
{
if ( !data.url )
data.url = {};
data.url.protocol = this.getValue();
}
},
{
type : 'text',
id : 'url',
label : commonLang.url,
required: true,
onLoad : function ()
{
this.allowOnChange = true;
},
onKeyUp : function()
{
this.allowOnChange = false;
var protocolCmb = this.getDialog().getContentElement( 'info', 'protocol' ),
url = this.getValue(),
urlOnChangeProtocol = /^(http|https|ftp|news):\/\/(?=.)/i,
urlOnChangeTestOther = /^((javascript:)|[#\/\.\?])/i;
var protocol = urlOnChangeProtocol.exec( url );
if ( protocol )
{
this.setValue( url.substr( protocol[ 0 ].length ) );
protocolCmb.setValue( protocol[ 0 ].toLowerCase() );
}
else if ( urlOnChangeTestOther.test( url ) )
protocolCmb.setValue( '' );
this.allowOnChange = true;
},
onChange : function()
{
if ( this.allowOnChange ) // Dont't call on dialog load.
this.onKeyUp();
},
validate : function()
{
var dialog = this.getDialog();
if ( dialog.getContentElement( 'info', 'linkType' ) &&
dialog.getValueOf( 'info', 'linkType' ) != 'url' )
return true;
if ( this.getDialog().fakeObj ) // Edit Anchor.
return true;
var func = CKEDITOR.dialog.validate.notEmpty( linkLang.noUrl );
return func.apply( this );
},
setup : function( data )
{
this.allowOnChange = false;
if ( data.url )
this.setValue( data.url.url );
this.allowOnChange = true;
},
commit : function( data )
{
// IE will not trigger the onChange event if the mouse has been used
// to carry all the operations #4724
this.onChange();
if ( !data.url )
data.url = {};
data.url.url = this.getValue();
this.allowOnChange = false;
}
}
],
setup : function( data )
{
if ( !this.getDialog().getContentElement( 'info', 'linkType' ) )
this.getElement().show();
}
},
{
type : 'button',
id : 'browse',
hidden : 'true',
filebrowser : 'info:url',
label : commonLang.browseServer
}
]
},
{
type : 'vbox',
id : 'anchorOptions',
width : 260,
align : 'center',
padding : 0,
children :
[
{
type : 'fieldset',
id : 'selectAnchorText',
label : linkLang.selectAnchor,
setup : function( data )
{
if ( data.anchors.length > 0 )
this.getElement().show();
else
this.getElement().hide();
},
children :
[
{
type : 'hbox',
id : 'selectAnchor',
children :
[
{
type : 'select',
id : 'anchorName',
'default' : '',
label : linkLang.anchorName,
style : 'width: 100%;',
items :
[
[ '' ]
],
setup : function( data )
{
this.clear();
this.add( '' );
for ( var i = 0 ; i < data.anchors.length ; i++ )
{
if ( data.anchors[i].name )
this.add( data.anchors[i].name );
}
if ( data.anchor )
this.setValue( data.anchor.name );
var linkType = this.getDialog().getContentElement( 'info', 'linkType' );
if ( linkType && linkType.getValue() == 'email' )
this.focus();
},
commit : function( data )
{
if ( !data.anchor )
data.anchor = {};
data.anchor.name = this.getValue();
}
},
{
type : 'select',
id : 'anchorId',
'default' : '',
label : linkLang.anchorId,
style : 'width: 100%;',
items :
[
[ '' ]
],
setup : function( data )
{
this.clear();
this.add( '' );
for ( var i = 0 ; i < data.anchors.length ; i++ )
{
if ( data.anchors[i].id )
this.add( data.anchors[i].id );
}
if ( data.anchor )
this.setValue( data.anchor.id );
},
commit : function( data )
{
if ( !data.anchor )
data.anchor = {};
data.anchor.id = this.getValue();
}
}
],
setup : function( data )
{
if ( data.anchors.length > 0 )
this.getElement().show();
else
this.getElement().hide();
}
}
]
},
{
type : 'html',
id : 'noAnchors',
style : 'text-align: center;',
html : '<div role="note" tabIndex="-1">' + CKEDITOR.tools.htmlEncode( linkLang.noAnchors ) + '</div>',
// Focus the first element defined in above html.
focus : true,
setup : function( data )
{
if ( data.anchors.length < 1 )
this.getElement().show();
else
this.getElement().hide();
}
}
],
setup : function( data )
{
if ( !this.getDialog().getContentElement( 'info', 'linkType' ) )
this.getElement().hide();
}
},
{
type : 'vbox',
id : 'emailOptions',
padding : 1,
children :
[
{
type : 'text',
id : 'emailAddress',
label : linkLang.emailAddress,
required : true,
validate : function()
{
var dialog = this.getDialog();
if ( !dialog.getContentElement( 'info', 'linkType' ) ||
dialog.getValueOf( 'info', 'linkType' ) != 'email' )
return true;
var func = CKEDITOR.dialog.validate.notEmpty( linkLang.noEmail );
return func.apply( this );
},
setup : function( data )
{
if ( data.email )
this.setValue( data.email.address );
var linkType = this.getDialog().getContentElement( 'info', 'linkType' );
if ( linkType && linkType.getValue() == 'email' )
this.select();
},
commit : function( data )
{
if ( !data.email )
data.email = {};
data.email.address = this.getValue();
}
},
{
type : 'text',
id : 'emailSubject',
label : linkLang.emailSubject,
setup : function( data )
{
if ( data.email )
this.setValue( data.email.subject );
},
commit : function( data )
{
if ( !data.email )
data.email = {};
data.email.subject = this.getValue();
}
},
{
type : 'textarea',
id : 'emailBody',
label : linkLang.emailBody,
rows : 3,
'default' : '',
setup : function( data )
{
if ( data.email )
this.setValue( data.email.body );
},
commit : function( data )
{
if ( !data.email )
data.email = {};
data.email.body = this.getValue();
}
}
],
setup : function( data )
{
if ( !this.getDialog().getContentElement( 'info', 'linkType' ) )
this.getElement().hide();
}
}
]
},
{
id : 'target',
label : linkLang.target,
title : linkLang.target,
elements :
[
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
type : 'select',
id : 'linkTargetType',
label : commonLang.target,
'default' : 'notSet',
style : 'width : 100%;',
'items' :
[
[ commonLang.notSet, 'notSet' ],
[ linkLang.targetFrame, 'frame' ],
[ linkLang.targetPopup, 'popup' ],
[ commonLang.targetNew, '_blank' ],
[ commonLang.targetTop, '_top' ],
[ commonLang.targetSelf, '_self' ],
[ commonLang.targetParent, '_parent' ]
],
onChange : targetChanged,
setup : function( data )
{
if ( data.target )
this.setValue( data.target.type || 'notSet' );
targetChanged.call( this );
},
commit : function( data )
{
if ( !data.target )
data.target = {};
data.target.type = this.getValue();
}
},
{
type : 'text',
id : 'linkTargetName',
label : linkLang.targetFrameName,
'default' : '',
setup : function( data )
{
if ( data.target )
this.setValue( data.target.name );
},
commit : function( data )
{
if ( !data.target )
data.target = {};
data.target.name = this.getValue().replace(/\W/gi, '');
}
}
]
},
{
type : 'vbox',
width : '100%',
align : 'center',
padding : 2,
id : 'popupFeatures',
children :
[
{
type : 'fieldset',
label : linkLang.popupFeatures,
children :
[
{
type : 'hbox',
children :
[
{
type : 'checkbox',
id : 'resizable',
label : linkLang.popupResizable,
setup : setupPopupParams,
commit : commitPopupParams
},
{
type : 'checkbox',
id : 'status',
label : linkLang.popupStatusBar,
setup : setupPopupParams,
commit : commitPopupParams
}
]
},
{
type : 'hbox',
children :
[
{
type : 'checkbox',
id : 'location',
label : linkLang.popupLocationBar,
setup : setupPopupParams,
commit : commitPopupParams
},
{
type : 'checkbox',
id : 'toolbar',
label : linkLang.popupToolbar,
setup : setupPopupParams,
commit : commitPopupParams
}
]
},
{
type : 'hbox',
children :
[
{
type : 'checkbox',
id : 'menubar',
label : linkLang.popupMenuBar,
setup : setupPopupParams,
commit : commitPopupParams
},
{
type : 'checkbox',
id : 'fullscreen',
label : linkLang.popupFullScreen,
setup : setupPopupParams,
commit : commitPopupParams
}
]
},
{
type : 'hbox',
children :
[
{
type : 'checkbox',
id : 'scrollbars',
label : linkLang.popupScrollBars,
setup : setupPopupParams,
commit : commitPopupParams
},
{
type : 'checkbox',
id : 'dependent',
label : linkLang.popupDependent,
setup : setupPopupParams,
commit : commitPopupParams
}
]
},
{
type : 'hbox',
children :
[
{
type : 'text',
widths : [ '50%', '50%' ],
labelLayout : 'horizontal',
label : commonLang.width,
id : 'width',
setup : setupPopupParams,
commit : commitPopupParams
},
{
type : 'text',
labelLayout : 'horizontal',
widths : [ '50%', '50%' ],
label : linkLang.popupLeft,
id : 'left',
setup : setupPopupParams,
commit : commitPopupParams
}
]
},
{
type : 'hbox',
children :
[
{
type : 'text',
labelLayout : 'horizontal',
widths : [ '50%', '50%' ],
label : commonLang.height,
id : 'height',
setup : setupPopupParams,
commit : commitPopupParams
},
{
type : 'text',
labelLayout : 'horizontal',
label : linkLang.popupTop,
widths : [ '50%', '50%' ],
id : 'top',
setup : setupPopupParams,
commit : commitPopupParams
}
]
}
]
}
]
}
]
},
{
id : 'upload',
label : linkLang.upload,
title : linkLang.upload,
hidden : true,
filebrowser : 'uploadButton',
elements :
[
{
type : 'file',
id : 'upload',
label : commonLang.upload,
style: 'height:40px',
size : 29
},
{
type : 'fileButton',
id : 'uploadButton',
label : commonLang.uploadSubmit,
filebrowser : 'info:url',
'for' : [ 'upload', 'upload' ]
}
]
},
{
id : 'advanced',
label : linkLang.advanced,
title : linkLang.advanced,
elements :
[
{
type : 'vbox',
padding : 1,
children :
[
{
type : 'hbox',
widths : [ '45%', '35%', '20%' ],
children :
[
{
type : 'text',
id : 'advId',
label : linkLang.id,
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'select',
id : 'advLangDir',
label : linkLang.langDir,
'default' : '',
style : 'width:110px',
items :
[
[ commonLang.notSet, '' ],
[ linkLang.langDirLTR, 'ltr' ],
[ linkLang.langDirRTL, 'rtl' ]
],
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'text',
id : 'advAccessKey',
width : '80px',
label : linkLang.acccessKey,
maxLength : 1,
setup : setupAdvParams,
commit : commitAdvParams
}
]
},
{
type : 'hbox',
widths : [ '45%', '35%', '20%' ],
children :
[
{
type : 'text',
label : linkLang.name,
id : 'advName',
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'text',
label : linkLang.langCode,
id : 'advLangCode',
width : '110px',
'default' : '',
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'text',
label : linkLang.tabIndex,
id : 'advTabIndex',
width : '80px',
maxLength : 5,
setup : setupAdvParams,
commit : commitAdvParams
}
]
}
]
},
{
type : 'vbox',
padding : 1,
children :
[
{
type : 'hbox',
widths : [ '45%', '55%' ],
children :
[
{
type : 'text',
label : linkLang.advisoryTitle,
'default' : '',
id : 'advTitle',
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'text',
label : linkLang.advisoryContentType,
'default' : '',
id : 'advContentType',
setup : setupAdvParams,
commit : commitAdvParams
}
]
},
{
type : 'hbox',
widths : [ '45%', '55%' ],
children :
[
{
type : 'text',
label : linkLang.cssClasses,
'default' : '',
id : 'advCSSClasses',
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'text',
label : linkLang.charset,
'default' : '',
id : 'advCharset',
setup : setupAdvParams,
commit : commitAdvParams
}
]
},
{
type : 'hbox',
widths : [ '45%', '55%' ],
children :
[
{
type : 'text',
label : linkLang.rel,
'default' : '',
id : 'advRel',
setup : setupAdvParams,
commit : commitAdvParams
},
{
type : 'text',
label : linkLang.styles,
'default' : '',
id : 'advStyles',
validate : CKEDITOR.dialog.validate.inlineStyle( editor.lang.common.invalidInlineStyle ),
setup : setupAdvParams,
commit : commitAdvParams
}
]
}
]
}
]
}
],
onShow : function()
{
var editor = this.getParentEditor(),
selection = editor.getSelection(),
element = null;
// Fill in all the relevant fields if there's already one link selected.
if ( ( element = plugin.getSelectedLink( editor ) ) && element.hasAttribute( 'href' ) )
selection.selectElement( element );
else
element = null;
this.setupContent( parseLink.apply( this, [ editor, element ] ) );
},
onOk : function()
{
var attributes = {},
removeAttributes = [],
data = {},
me = this,
editor = this.getParentEditor();
this.commitContent( data );
// Compose the URL.
switch ( data.type || 'url' )
{
case 'url':
var protocol = ( data.url && data.url.protocol != undefined ) ? data.url.protocol : 'http://',
url = ( data.url && CKEDITOR.tools.trim( data.url.url ) ) || '';
attributes[ 'data-cke-saved-href' ] = ( url.indexOf( '/' ) === 0 ) ? url : protocol + url;
break;
case 'anchor':
var name = ( data.anchor && data.anchor.name ),
id = ( data.anchor && data.anchor.id );
attributes[ 'data-cke-saved-href' ] = '#' + ( name || id || '' );
break;
case 'email':
var linkHref,
email = data.email,
address = email.address;
switch( emailProtection )
{
case '' :
case 'encode' :
{
var subject = encodeURIComponent( email.subject || '' ),
body = encodeURIComponent( email.body || '' );
// Build the e-mail parameters first.
var argList = [];
subject && argList.push( 'subject=' + subject );
body && argList.push( 'body=' + body );
argList = argList.length ? '?' + argList.join( '&' ) : '';
if ( emailProtection == 'encode' )
{
linkHref = [ 'javascript:void(location.href=\'mailto:\'+',
protectEmailAddressAsEncodedString( address ) ];
// parameters are optional.
argList && linkHref.push( '+\'', escapeSingleQuote( argList ), '\'' );
linkHref.push( ')' );
}
else
linkHref = [ 'mailto:', address, argList ];
break;
}
default :
{
// Separating name and domain.
var nameAndDomain = address.split( '@', 2 );
email.name = nameAndDomain[ 0 ];
email.domain = nameAndDomain[ 1 ];
linkHref = [ 'javascript:', protectEmailLinkAsFunction( email ) ];
}
}
attributes[ 'data-cke-saved-href' ] = linkHref.join( '' );
break;
}
// Popups and target.
if ( data.target )
{
if ( data.target.type == 'popup' )
{
var onclickList = [ 'window.open(this.href, \'',
data.target.name || '', '\', \'' ];
var featureList = [ 'resizable', 'status', 'location', 'toolbar', 'menubar', 'fullscreen',
'scrollbars', 'dependent' ];
var featureLength = featureList.length;
var addFeature = function( featureName )
{
if ( data.target[ featureName ] )
featureList.push( featureName + '=' + data.target[ featureName ] );
};
for ( var i = 0 ; i < featureLength ; i++ )
featureList[i] = featureList[i] + ( data.target[ featureList[i] ] ? '=yes' : '=no' ) ;
addFeature( 'width' );
addFeature( 'left' );
addFeature( 'height' );
addFeature( 'top' );
onclickList.push( featureList.join( ',' ), '\'); return false;' );
attributes[ 'data-cke-pa-onclick' ] = onclickList.join( '' );
// Add the "target" attribute. (#5074)
removeAttributes.push( 'target' );
}
else
{
if ( data.target.type != 'notSet' && data.target.name )
attributes.target = data.target.name;
else
removeAttributes.push( 'target' );
removeAttributes.push( 'data-cke-pa-onclick', 'onclick' );
}
}
// Advanced attributes.
if ( data.adv )
{
var advAttr = function( inputName, attrName )
{
var value = data.adv[ inputName ];
if ( value )
attributes[attrName] = value;
else
removeAttributes.push( attrName );
};
advAttr( 'advId', 'id' );
advAttr( 'advLangDir', 'dir' );
advAttr( 'advAccessKey', 'accessKey' );
if ( data.adv[ 'advName' ] )
attributes[ 'name' ] = attributes[ 'data-cke-saved-name' ] = data.adv[ 'advName' ];
else
removeAttributes = removeAttributes.concat( [ 'data-cke-saved-name', 'name' ] );
advAttr( 'advLangCode', 'lang' );
advAttr( 'advTabIndex', 'tabindex' );
advAttr( 'advTitle', 'title' );
advAttr( 'advContentType', 'type' );
advAttr( 'advCSSClasses', 'class' );
advAttr( 'advCharset', 'charset' );
advAttr( 'advStyles', 'style' );
advAttr( 'advRel', 'rel' );
}
var selection = editor.getSelection();
// Browser need the "href" fro copy/paste link to work. (#6641)
attributes.href = attributes[ 'data-cke-saved-href' ];
if ( !this._.selectedElement )
{
// Create element if current selection is collapsed.
var ranges = selection.getRanges( true );
if ( ranges.length == 1 && ranges[0].collapsed )
{
// Short mailto link text view (#5736).
var text = new CKEDITOR.dom.text( data.type == 'email' ?
data.email.address : attributes[ 'data-cke-saved-href' ], editor.document );
ranges[0].insertNode( text );
ranges[0].selectNodeContents( text );
selection.selectRanges( ranges );
}
// Apply style.
var style = new CKEDITOR.style( { element : 'a', attributes : attributes } );
style.type = CKEDITOR.STYLE_INLINE; // need to override... dunno why.
style.apply( editor.document );
}
else
{
// We're only editing an existing link, so just overwrite the attributes.
var element = this._.selectedElement,
href = element.data( 'cke-saved-href' ),
textView = element.getHtml();
element.setAttributes( attributes );
element.removeAttributes( removeAttributes );
if ( data.adv && data.adv.advName && CKEDITOR.plugins.link.synAnchorSelector )
element.addClass( element.getChildCount() ? 'cke_anchor' : 'cke_anchor_empty' );
// Update text view when user changes protocol (#4612).
if ( href == textView || data.type == 'email' && textView.indexOf( '@' ) != -1 )
{
// Short mailto link text view (#5736).
element.setHtml( data.type == 'email' ?
data.email.address : attributes[ 'data-cke-saved-href' ] );
}
selection.selectElement( element );
delete this._.selectedElement;
}
},
onLoad : function()
{
if ( !editor.config.linkShowAdvancedTab )
this.hidePage( 'advanced' ); //Hide Advanded tab.
if ( !editor.config.linkShowTargetTab )
this.hidePage( 'target' ); //Hide Target tab.
},
// Inital focus on 'url' field if link is of type URL.
onFocus : function()
{
var linkType = this.getContentElement( 'info', 'linkType' ),
urlField;
if ( linkType && linkType.getValue() == 'url' )
{
urlField = this.getContentElement( 'info', 'url' );
urlField.select();
}
}
};
});
/**
* The e-mail address anti-spam protection option. The protection will be
* applied when creating or modifying e-mail links through the editor interface.<br>
* Two methods of protection can be choosed:
* <ol> <li>The e-mail parts (name, domain and any other query string) are
* assembled into a function call pattern. Such function must be
* provided by the developer in the pages that will use the contents.
* <li>Only the e-mail address is obfuscated into a special string that
* has no meaning for humans or spam bots, but which is properly
* rendered and accepted by the browser.</li></ol>
* Both approaches require JavaScript to be enabled.
* @name CKEDITOR.config.emailProtection
* @since 3.1
* @type String
* @default '' (empty string = disabled)
* @example
* // href="mailto:tester@ckeditor.com?subject=subject&body=body"
* config.emailProtection = '';
* @example
* // href="<a href=\"javascript:void(location.href=\'mailto:\'+String.fromCharCode(116,101,115,116,101,114,64,99,107,101,100,105,116,111,114,46,99,111,109)+\'?subject=subject&body=body\')\">e-mail</a>"
* config.emailProtection = 'encode';
* @example
* // href="javascript:mt('tester','ckeditor.com','subject','body')"
* config.emailProtection = 'mt(NAME,DOMAIN,SUBJECT,BODY)';
*/
| JavaScript |
/*
Copyright (c) 2003-2012, 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, false, null );
}
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.
this.startDisabled = true;
};
cutCopyCmd.prototype =
{
exec : function( editor, data )
{
this.type == 'cut' && fixCut( editor );
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();
// 1. Opera just misses the "paste" event.
// 2. Firefox's "paste" event comes too late to have the plain
// text paste bin to work.
if ( CKEDITOR.env.opera || CKEDITOR.env.gecko )
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 );
}
};
function cancel( evt ) { evt.cancel(); }
// 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 or consequent paste too fast. (#5730)
if ( 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' : CKEDITOR.env.webkit ? 'body' : '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 );
pastebin.setStyles(
{
position : 'absolute',
// 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'
});
// It's definitely a better user experience if we make the paste-bin pretty unnoticed
// by pulling it off the screen.
pastebin.setStyle( this.config.contentsLangDirection == 'ltr' ? 'left' : 'right', '-1000px' );
var bms = sel.createBookmarks();
this.on( 'selectionChange', cancel, null, null, 0 );
// Turn off design mode temporarily before give focus to the paste bin.
if ( mode == 'text' )
pastebin.$.focus();
else
{
range.setStartAt( pastebin, CKEDITOR.POSITION_AFTER_START );
range.setEndAt( pastebin, CKEDITOR.POSITION_BEFORE_END );
range.select( true );
}
var editor = this;
// Wait a while and grab the pasted contents
window.setTimeout( function()
{
// Restore properly the document focus. (#5684, #8849)
editor.document.getBody().focus();
editor.removeListener( 'selectionChange', cancel );
// IE7: selection must go before removing paste bin. (#8691)
if ( CKEDITOR.env.ie7Compat )
{
sel.selectBookmarks( bms );
pastebin.remove();
}
// Webkit: selection must go after removing paste bin. (#8921)
else
{
pastebin.remove();
sel.selectBookmarks( bms );
}
// 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 );
callback( pastebin[ 'get' + ( mode == 'text' ? 'Value' : 'Html' ) ]() );
}, 0 );
}
// Cutting off control type element in IE standards breaks the selection entirely. (#4881)
function fixCut( editor )
{
if ( !CKEDITOR.env.ie || CKEDITOR.env.quirks )
return;
var sel = editor.getSelection();
var control;
if( ( sel.getType() == CKEDITOR.SELECTION_ELEMENT ) && ( control = sel.getSelectedElement() ) )
{
var range = sel.getRanges()[ 0 ];
var dummy = editor.document.createText( '' );
dummy.insertBefore( control );
range.setStartBefore( dummy );
range.setEndAfter( control );
sel.selectRanges( [ range ] );
// Clear up the fix if the paste wasn't succeeded.
setTimeout( function()
{
// Element still online?
if ( control.getParent() )
{
dummy.remove();
sel.selectElement( control );
}
}, 0 );
}
}
var depressBeforeEvent,
inReadOnly;
function stateFromNamedCommand( command, editor )
{
var retval;
if ( inReadOnly && command in { Paste : 1, Cut : 1 } )
return CKEDITOR.TRISTATE_DISABLED;
if ( command == 'Paste' )
{
// IE Bug: queryCommandEnabled('paste') fires also 'beforepaste(copy/cut)',
// guard to distinguish from the ordinary sources (either
// keyboard paste or execCommand) (#4874).
CKEDITOR.env.ie && ( depressBeforeEvent = 1 );
try
{
// Always return true for Webkit (which always returns false).
retval = editor.document.$.queryCommandEnabled( command ) || CKEDITOR.env.webkit;
}
catch( er ) {}
depressBeforeEvent = 0;
}
// Cut, Copy - check if the selection is not empty
else
{
var sel = editor.getSelection(),
ranges = sel && sel.getRanges();
retval = sel && !( ranges.length == 1 && ranges[ 0 ].collapsed );
}
return retval ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED;
}
function setToolbarStates()
{
if ( this.mode != 'wysiwyg' )
return;
var pasteState = stateFromNamedCommand( 'Paste', this );
this.getCommand( 'cut' ).setState( stateFromNamedCommand( 'Cut', this ) );
this.getCommand( 'copy' ).setState( stateFromNamedCommand( 'Copy', this ) );
this.getCommand( 'paste' ).setState( pasteState );
this.fire( 'pasteState', pasteState );
}
// 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' ] );
setTimeout( function () { editor.fire( 'afterPaste' ); }, 0 );
}, null, null, 1000 );
editor.on( 'pasteDialog', function( evt )
{
setTimeout( function()
{
// Open default paste dialog.
editor.openDialog( 'paste' );
}, 0 );
});
editor.on( 'pasteState', function( evt )
{
editor.getCommand( 'paste' ).setState( evt.data );
});
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 );
// 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();
// Intercept the paste before it actually takes place.
body.on( !CKEDITOR.env.ie ? 'paste' : 'beforepaste', function( evt )
{
if ( depressBeforeEvent )
return;
// Dismiss the (wrong) 'beforepaste' event fired on toolbar menu open.
var domEvent = evt.data && evt.data.$;
if ( CKEDITOR.env.ie && domEvent && !domEvent.ctrlKey )
return;
// Fire 'beforePaste' event so clipboard flavor get customized
// by other plugins.
var eventData = { mode : 'html' };
editor.fire( 'beforePaste', eventData );
getClipboardData.call( editor, evt, eventData.mode, function ( data )
{
// The very last guard to make sure the
// paste has successfully happened.
if ( !( data = CKEDITOR.tools.trim( data.replace( /<span[^>]+data-cke-bookmark[^<]*?<\/span>/ig,'' ) ) ) )
return;
var dataTransfer = {};
dataTransfer[ eventData.mode ] = data;
editor.fire( 'paste', dataTransfer );
} );
});
if ( CKEDITOR.env.ie )
{
// Dismiss the (wrong) 'beforepaste' event fired on context menu open. (#7953)
body.on( 'contextmenu', function()
{
depressBeforeEvent = 1;
// Important: The following timeout will be called only after menu closed.
setTimeout( function() { depressBeforeEvent = 0; }, 0 );
} );
// Handle IE's late coming "paste" event when pasting from
// browser toolbar/context menu.
body.on( 'paste', function( evt )
{
if ( !editor.document.getById( 'cke_pastebin' ) )
{
// Prevent native paste.
evt.data.preventDefault();
depressBeforeEvent = 0;
// Resort to the paste command.
pasteCmd.exec( editor );
}
} );
}
body.on( 'beforecut', function() { !depressBeforeEvent && fixCut( editor ); } );
body.on( 'mouseup', function(){ setTimeout( function(){ setToolbarStates.call( editor ); }, 0 ); }, editor );
body.on( 'keyup', setToolbarStates, editor );
});
// For improved performance, we're checking the readOnly state on selectionChange instead of hooking a key event for that.
editor.on( 'selectionChange', function( evt )
{
inReadOnly = evt.data.selection.getRanges()[ 0 ].checkReadOnly();
setToolbarStates.call( editor );
});
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
var readOnly = selection.getRanges()[ 0 ].checkReadOnly();
return {
cut : stateFromNamedCommand( 'Cut', editor ),
copy : stateFromNamedCommand( 'Copy', editor ),
paste : stateFromNamedCommand( 'Paste', editor )
};
});
}
}
});
})();
/**
* 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.
*/
/**
* Internal event to open the Paste dialog
* @name CKEDITOR.editor#pasteDialog
* @event
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'paste', function( editor )
{
var lang = editor.lang.clipboard;
var isCustomDomain = CKEDITOR.env.isCustomDomain();
function onPasteFrameLoad( win )
{
var doc = new CKEDITOR.dom.document( win.document ),
docElement = doc.$;
var script = doc.getById( 'cke_actscrpt' );
script && script.remove();
CKEDITOR.env.ie ?
docElement.body.contentEditable = "true" :
docElement.designMode = "on";
// IE before version 8 will leave cursor blinking inside the document after
// editor blurred unless we clean up the selection. (#4716)
if ( CKEDITOR.env.ie && CKEDITOR.env.version < 8 )
{
doc.getWindow().on( 'blur', function()
{
docElement.selection.empty();
} );
}
doc.on( "keydown", function( e )
{
var domEvent = e.data,
key = domEvent.getKeystroke(),
processed;
switch( key )
{
case 27 :
this.hide();
processed = 1;
break;
case 9 :
case CKEDITOR.SHIFT + 9 :
this.changeFocus( 1 );
processed = 1;
}
processed && domEvent.preventDefault();
}, this );
editor.fire( 'ariaWidget', new CKEDITOR.dom.element( win.frameElement ) );
}
return {
title : lang.title,
minWidth : CKEDITOR.env.ie && CKEDITOR.env.quirks ? 370 : 350,
minHeight : CKEDITOR.env.quirks ? 250 : 245,
onShow : function()
{
// FIREFOX BUG: Force the browser to render the dialog to make the to-be-
// inserted iframe editable. (#3366)
this.parts.dialog.$.offsetHeight;
this.setupContent();
},
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()
{
this.commitContent();
},
contents : [
{
id : 'general',
label : editor.lang.common.generalTab,
elements : [
{
type : 'html',
id : 'securityMsg',
html : '<div style="white-space:normal;width:340px;">' + lang.securityMsg + '</div>'
},
{
type : 'html',
id : 'pasteMsg',
html : '<div style="white-space:normal;width:340px;">'+lang.pasteMsg +'</div>'
},
{
type : 'html',
id : 'editing_area',
style : 'width: 100%; height: 100%;',
html : '',
focus : function()
{
var win = this.getInputElement().$.contentWindow;
// #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()
{
win.focus();
}, 500 );
},
setup : function()
{
var dialog = this.getDialog();
var htmlToLoad =
'<html dir="' + editor.config.contentsLangDirection + '"' +
' lang="' + ( editor.config.contentsLanguage || editor.langCode ) + '">' +
'<head><style>body { margin: 3px; height: 95%; } </style></head><body>' +
'<script id="cke_actscrpt" type="text/javascript">' +
'window.parent.CKEDITOR.tools.callFunction( ' + CKEDITOR.tools.addFunction( onPasteFrameLoad, dialog ) + ', this );' +
'</script></body>' +
'</html>';
var src =
CKEDITOR.env.air ?
'javascript:void(0)' :
isCustomDomain ?
'javascript:void((function(){' +
'document.open();' +
'document.domain=\'' + document.domain + '\';' +
'document.close();' +
'})())"'
:
'';
var iframe = CKEDITOR.dom.element.createFromHtml(
'<iframe' +
' class="cke_pasteframe"' +
' frameborder="0" ' +
' allowTransparency="true"' +
' src="' + src + '"' +
' role="region"' +
' aria-label="' + lang.pasteArea + '"' +
' aria-describedby="' + dialog.getContentElement( 'general', 'pasteMsg' ).domId + '"' +
' aria-multiple="true"' +
'></iframe>' );
iframe.on( 'load', function( e )
{
e.removeListener();
var doc = iframe.getFrameDocument();
doc.write( htmlToLoad );
if ( CKEDITOR.env.air )
onPasteFrameLoad.call( this, doc.getWindow().$ );
}, dialog );
iframe.setCustomData( 'dialog', dialog );
var container = this.getElement();
container.setHtml( '' );
container.append( iframe );
// IE need a redirect on focus to make
// the cursor blinking inside iframe. (#5461)
if ( CKEDITOR.env.ie )
{
var focusGrabber = CKEDITOR.dom.element.createFromHtml( '<span tabindex="-1" style="position:absolute;" role="presentation"></span>' );
focusGrabber.on( 'focus', function()
{
iframe.$.contentWindow.focus();
});
container.append( focusGrabber );
// Override focus handler on field.
this.focus = function()
{
focusGrabber.focus();
this.fire( 'focus' );
};
}
this.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' );
}
},
commit : function( data )
{
var container = this.getElement(),
editor = this.getDialog().getParentEditor(),
body = this.getInputElement().getFrameDocument().getBody(),
bogus = body.getBogus(),
html;
bogus && bogus.remove();
// Saving the contents so changes until paste is complete will not take place (#7500)
html = body.getHtml();
setTimeout( function(){
editor.fire( 'paste', { 'html' : html } );
}, 0 );
}
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview Defines the {@link CKEDITOR.xml} class, which represents a
* loaded XML document.
*/
(function()
{
CKEDITOR.plugins.add( 'xml', {});
/**
* Represents a loaded XML document.
* @constructor
* @param {object|string} xmlObjectOrData A native XML (DOM document) object or
* a string containing the XML definition to be loaded.
* @example
* var xml = <b>new CKEDITOR.xml( '<books><book title="My Book" /></books>' )</b>;
*/
CKEDITOR.xml = function( xmlObjectOrData )
{
var baseXml = null;
if ( typeof xmlObjectOrData == 'object' )
baseXml = xmlObjectOrData;
else
{
var data = ( xmlObjectOrData || '' ).replace( / /g, '\xA0' );
if ( window.DOMParser )
baseXml = (new DOMParser()).parseFromString( data, 'text/xml' );
else if ( window.ActiveXObject )
{
try { baseXml = new ActiveXObject( 'MSXML2.DOMDocument' ); }
catch(e)
{
try { baseXml = new ActiveXObject( 'Microsoft.XmlDom' ); } catch(e) {}
}
if ( baseXml )
{
baseXml.async = false;
baseXml.resolveExternals = false;
baseXml.validateOnParse = false;
baseXml.loadXML( data );
}
}
}
/**
* The native XML (DOM document) used by the class instance.
* @type object
* @example
*/
this.baseXml = baseXml;
};
CKEDITOR.xml.prototype =
{
/**
* Get a single node from the XML document, based on a XPath query.
* @param {String} xpath The XPath query to execute.
* @param {Object} [contextNode] The XML DOM node to be used as the context
* for the XPath query. The document root is used by default.
* @returns {Object} A XML node element or null if the query has no results.
* @example
* // Create the XML instance.
* var xml = new CKEDITOR.xml( '<list><item id="test1" /><item id="test2" /></list>' );
* // Get the first <item> node.
* var itemNode = <b>xml.selectSingleNode( 'list/item' )</b>;
* // Alert "item".
* alert( itemNode.nodeName );
*/
selectSingleNode : function( xpath, contextNode )
{
var baseXml = this.baseXml;
if ( contextNode || ( contextNode = baseXml ) )
{
if ( CKEDITOR.env.ie || contextNode.selectSingleNode ) // IE
return contextNode.selectSingleNode( xpath );
else if ( baseXml.evaluate ) // Others
{
var result = baseXml.evaluate( xpath, contextNode, null, 9, null);
return ( result && result.singleNodeValue ) || null;
}
}
return null;
},
/**
* Gets a list node from the XML document, based on a XPath query.
* @param {String} xpath The XPath query to execute.
* @param {Object} [contextNode] The XML DOM node to be used as the context
* for the XPath query. The document root is used by default.
* @returns {ArrayLike} An array containing all matched nodes. The array will
* be empty if the query has no results.
* @example
* // Create the XML instance.
* var xml = new CKEDITOR.xml( '<list><item id="test1" /><item id="test2" /></list>' );
* // Get the first <item> node.
* var itemNodes = xml.selectSingleNode( 'list/item' );
* // Alert "item" twice, one for each <item>.
* for ( var i = 0 ; i < itemNodes.length ; i++ )
* alert( itemNodes[i].nodeName );
*/
selectNodes : function( xpath, contextNode )
{
var baseXml = this.baseXml,
nodes = [];
if ( contextNode || ( contextNode = baseXml ) )
{
if ( CKEDITOR.env.ie || contextNode.selectNodes ) // IE
return contextNode.selectNodes( xpath );
else if ( baseXml.evaluate ) // Others
{
var result = baseXml.evaluate( xpath, contextNode, null, 5, null);
if ( result )
{
var node;
while ( ( node = result.iterateNext() ) )
nodes.push( node );
}
}
}
return nodes;
},
/**
* Gets the string representation of hte inner contents of a XML node,
* based on a XPath query.
* @param {String} xpath The XPath query to execute.
* @param {Object} [contextNode] The XML DOM node to be used as the context
* for the XPath query. The document root is used by default.
* @returns {String} The textual representation of the inner contents of
* the node or null if the query has no results.
* @example
* // Create the XML instance.
* var xml = new CKEDITOR.xml( '<list><item id="test1" /><item id="test2" /></list>' );
* // Alert "<item id="test1" /><item id="test2" />".
* alert( xml.getInnerXml( 'list' ) );
*/
getInnerXml : function( xpath, contextNode )
{
var node = this.selectSingleNode( xpath, contextNode ),
xml = [];
if ( node )
{
node = node.firstChild;
while ( node )
{
if ( node.xml ) // IE
xml.push( node.xml );
else if ( window.XMLSerializer ) // Others
xml.push( ( new XMLSerializer() ).serializeToString( node ) );
node = node.nextSibling;
}
}
return xml.length ? xml.join( '' ) : null;
}
};
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file AutoGrow plugin
*/
(function(){
// Actual content height, figured out by appending check the last element's document position.
function contentHeight( scrollable )
{
var overflowY = scrollable.getStyle( 'overflow-y' );
var doc = scrollable.getDocument();
// Create a temporary marker element.
var marker = CKEDITOR.dom.element.createFromHtml( '<span style="margin:0;padding:0;border:0;clear:both;width:1px;height:1px;display:block;">' + ( CKEDITOR.env.webkit ? ' ' : '' ) + '</span>', doc );
doc[ CKEDITOR.env.ie? 'getBody' : 'getDocumentElement']().append( marker );
var height = marker.getDocumentPosition( doc ).y + marker.$.offsetHeight;
marker.remove();
scrollable.setStyle( 'overflow-y', overflowY );
return height;
}
var resizeEditor = function( editor )
{
if ( !editor.window )
return;
var doc = editor.document,
iframe = new CKEDITOR.dom.element( doc.getWindow().$.frameElement ),
body = doc.getBody(),
htmlElement = doc.getDocumentElement(),
currentHeight = editor.window.getViewPaneSize().height,
// Quirks mode overflows body, standards overflows document element
scrollable = doc.$.compatMode == 'BackCompat' ? body : htmlElement,
newHeight = contentHeight( scrollable );
// Additional space specified by user.
newHeight += ( editor.config.autoGrow_bottomSpace || 0 );
var min = editor.config.autoGrow_minHeight != undefined ? editor.config.autoGrow_minHeight : 200,
max = editor.config.autoGrow_maxHeight || Infinity;
newHeight = Math.max( newHeight, min );
newHeight = Math.min( newHeight, max );
if ( newHeight != currentHeight )
{
newHeight = editor.fire( 'autoGrow', { currentHeight : currentHeight, newHeight : newHeight } ).newHeight;
editor.resize( editor.container.getStyle( 'width' ), newHeight, true );
}
if ( scrollable.$.scrollHeight > scrollable.$.clientHeight && newHeight < max )
scrollable.setStyle( 'overflow-y', 'hidden' );
else
scrollable.removeStyle( 'overflow-y' );
};
CKEDITOR.plugins.add( 'autogrow',
{
init : function( editor )
{
editor.addCommand( 'autogrow', { exec : resizeEditor, modes : { wysiwyg:1 }, readOnly: 1, canUndo: false, editorFocus: false } );
var eventsList = { contentDom:1, key:1, selectionChange:1, insertElement:1, mode:1 };
editor.config.autoGrow_onStartup && ( eventsList[ 'instanceReady' ] = 1 );
for ( var eventName in eventsList )
{
editor.on( eventName, function( evt )
{
var maximize = editor.getCommand( 'maximize' );
// Some time is required for insertHtml, and it gives other events better performance as well.
if ( evt.editor.mode == 'wysiwyg' &&
// Disable autogrow when the editor is maximized .(#6339)
( !maximize || maximize.state != CKEDITOR.TRISTATE_ON ) )
{
setTimeout( function()
{
resizeEditor( evt.editor );
// Second pass to make correction upon
// the first resize, e.g. scrollbar.
resizeEditor( evt.editor );
}, 100 );
}
});
}
}
});
})();
/**
* The minimum height that the editor can reach using the AutoGrow feature.
* @name CKEDITOR.config.autoGrow_minHeight
* @type Number
* @default <code>200</code>
* @since 3.4
* @example
* config.autoGrow_minHeight = 300;
*/
/**
* The maximum height that the editor can reach using the AutoGrow feature. Zero means unlimited.
* @name CKEDITOR.config.autoGrow_maxHeight
* @type Number
* @default <code>0</code>
* @since 3.4
* @example
* config.autoGrow_maxHeight = 400;
*/
/**
* Whether to have the auto grow happen on editor creation.
* @name CKEDITOR.config.autoGrow_onStartup
* @type Boolean
* @default false
* @since 3.6.2
* @example
* config.autoGrow_onStartup = true;
*/
/**
* Fired when the AutoGrow plugin is about to change the size of the editor.
* @name CKEDITOR.editor#autogrow
* @event
* @param {Number} data.currentHeight The current height of the editor (before resizing).
* @param {Number} data.newHeight The new height of the editor (after resizing). It can be changed
* to determine a different height value to be used instead.
*/
/**
* Extra height in pixel to leave between the bottom boundary of content with document size when auto resizing.
* @name CKEDITOR.config.autoGrow_bottomSpace
* @type Number
* @default 0
* @since 3.6.2
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var eventNameList = [ 'click', 'keydown', 'mousedown', 'keypress', 'mouseover', 'mouseout' ];
// Inline event callbacks assigned via innerHTML/outerHTML, such as
// onclick/onmouseover, are ignored in AIR.
// Use DOM2 event listeners to substitue inline handlers instead.
function convertInlineHandlers( container )
{
// TODO: document.querySelectorAll is not supported in AIR.
var children = container.getElementsByTag( '*' ),
count = children.count(),
child;
for ( var i = 0; i < count; i++ )
{
child = children.getItem( i );
(function( node )
{
for ( var j = 0; j < eventNameList.length; j++ )
{
(function( eventName )
{
var inlineEventHandler = node.getAttribute( 'on' + eventName );
if ( node.hasAttribute( 'on' + eventName ) )
{
node.removeAttribute( 'on' + eventName );
node.on( eventName, function( evt )
{
var callFunc = /(return\s*)?CKEDITOR\.tools\.callFunction\(([^)]+)\)/.exec( inlineEventHandler ),
hasReturn = callFunc && callFunc[ 1 ],
callFuncArgs = callFunc && callFunc[ 2 ].split( ',' ),
preventDefault = /return false;/.test( inlineEventHandler );
if ( callFuncArgs )
{
var nums = callFuncArgs.length,
argName;
for ( var i = 0; i < nums; i++ )
{
// Trim spaces around param.
callFuncArgs[ i ] = argName = CKEDITOR.tools.trim( callFuncArgs[ i ] );
// String form param.
var strPattern = argName.match( /^(["'])([^"']*?)\1$/ );
if ( strPattern )
{
callFuncArgs[ i ] = strPattern[ 2 ];
continue;
}
// Integer form param.
if ( argName.match( /\d+/ ) )
{
callFuncArgs[ i ] = parseInt( argName, 10 );
continue;
}
// Speical variables.
switch( argName )
{
case 'this' :
callFuncArgs[ i ] = node.$;
break;
case 'event' :
callFuncArgs[ i ] = evt.data.$;
break;
case 'null' :
callFuncArgs [ i ] = null;
break;
}
}
var retval = CKEDITOR.tools.callFunction.apply( window, callFuncArgs );
if ( hasReturn && retval === false )
preventDefault = 1;
}
if ( preventDefault )
evt.data.preventDefault();
});
}
})( eventNameList[ j ] );
}
})( child );
}
}
CKEDITOR.plugins.add( 'adobeair',
{
init : function( editor )
{
if ( !CKEDITOR.env.air )
return;
// Body doesn't get default margin on AIR.
editor.addCss( 'body { padding: 8px }' );
editor.on( 'uiReady', function()
{
convertInlineHandlers( editor.container );
if ( editor.sharedSpaces )
{
for ( var space in editor.sharedSpaces )
convertInlineHandlers( editor.sharedSpaces[ space ] );
}
editor.on( 'elementsPathUpdate', function( evt ) { convertInlineHandlers( evt.data.space ); } );
});
editor.on( 'contentDom', function()
{
// Hyperlinks are enabled in editable documents in Adobe
// AIR. Prevent their click behavior.
editor.document.on( 'click', function( ev )
{
ev.data.preventDefault( true );
});
});
}
});
CKEDITOR.ui.on( 'ready', function( evt )
{
var ui = evt.data;
// richcombo, panelbutton and menu
if ( ui._.panel )
{
var panel = ui._.panel._.panel,
holder;
( function()
{
// Adding dom event listeners off-line are not supported in AIR,
// waiting for panel iframe loaded.
if ( !panel.isLoaded )
{
setTimeout( arguments.callee, 30 );
return;
}
holder = panel._.holder;
convertInlineHandlers( holder );
})();
}
else if ( ui instanceof CKEDITOR.dialog )
convertInlineHandlers( ui._.element );
});
})();
CKEDITOR.dom.document.prototype.write = CKEDITOR.tools.override( CKEDITOR.dom.document.prototype.write,
function( original_write )
{
function appendElement( parent, tagName, fullTag, text )
{
var node = parent.append( tagName ),
attrs = CKEDITOR.htmlParser.fragment.fromHtml( fullTag ).children[ 0 ].attributes;
attrs && node.setAttributes( attrs );
text && node.append( parent.getDocument().createText( text ) );
}
return function( html, mode )
{
// document.write() or document.writeln() fail silently after
// the page load event in Adobe AIR.
// DOM manipulation could be used instead.
if ( this.getBody() )
{
// We're taking the below extra work only because innerHTML
// on <html> element doesn't work as expected.
var doc = this,
head = this.getHead();
// Create style nodes for inline css. ( <style> content doesn't applied when setting via innerHTML )
html = html.replace( /(<style[^>]*>)([\s\S]*?)<\/style>/gi,
function ( match, startTag, styleText )
{
appendElement( head, 'style', startTag, styleText );
return '';
});
html = html.replace( /<base\b[^>]*\/>/i,
function( match )
{
appendElement( head, 'base', match );
return '';
});
html = html.replace( /<title>([\s\S]*)<\/title>/i,
function( match, title )
{
doc.$.title = title;
return '';
});
// Move the rest of head stuff.
html = html.replace( /<head>([\s\S]*)<\/head>/i,
function( headHtml )
{
// Inject the <head> HTML inside a <div>.
// Do that before getDocumentHead because WebKit moves
// <link css> elements to the <head> at this point.
var div = new CKEDITOR.dom.element( 'div', doc );
div.setHtml( headHtml );
// Move the <div> nodes to <head>.
div.moveChildren( head );
return '';
});
html.replace( /(<body[^>]*>)([\s\S]*)(?=$|<\/body>)/i,
function( match, startTag, innerHTML )
{
doc.getBody().setHtml( innerHTML );
var attrs = CKEDITOR.htmlParser.fragment.fromHtml( startTag ).children[ 0 ].attributes;
attrs && doc.getBody().setAttributes( attrs );
});
}
else
original_write.apply( this, arguments );
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview The "div" plugin. It wraps the selected block level elements with a 'div' element with specified styles and attributes.
*
*/
(function()
{
CKEDITOR.plugins.add( 'div',
{
requires : [ 'editingblock', 'dialog', 'domiterator', 'styles' ],
init : function( editor )
{
var lang = editor.lang.div;
editor.addCommand( 'creatediv', new CKEDITOR.dialogCommand( 'creatediv' ) );
editor.addCommand( 'editdiv', new CKEDITOR.dialogCommand( 'editdiv' ) );
editor.addCommand( 'removediv',
{
exec : function( editor )
{
var selection = editor.getSelection(),
ranges = selection && selection.getRanges(),
range,
bookmarks = selection.createBookmarks(),
walker,
toRemove = [];
function findDiv( node )
{
var path = new CKEDITOR.dom.elementPath( node ),
blockLimit = path.blockLimit,
div = blockLimit.is( 'div' ) && blockLimit;
if ( div && !div.data( 'cke-div-added' ) )
{
toRemove.push( div );
div.data( 'cke-div-added' );
}
}
for ( var i = 0 ; i < ranges.length ; i++ )
{
range = ranges[ i ];
if ( range.collapsed )
findDiv( selection.getStartElement() );
else
{
walker = new CKEDITOR.dom.walker( range );
walker.evaluator = findDiv;
walker.lastForward();
}
}
for ( i = 0 ; i < toRemove.length ; i++ )
toRemove[ i ].remove( true );
selection.selectBookmarks( bookmarks );
}
} );
editor.ui.addButton( 'CreateDiv',
{
label : lang.toolbar,
command :'creatediv'
} );
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
editdiv :
{
label : lang.edit,
command : 'editdiv',
group : 'div',
order : 1
},
removediv:
{
label : lang.remove,
command : 'removediv',
group : 'div',
order : 5
}
} );
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( !element || element.isReadOnly() )
return null;
var elementPath = new CKEDITOR.dom.elementPath( element ),
blockLimit = elementPath.blockLimit;
if ( blockLimit && blockLimit.getAscendant( 'div', true ) )
{
return {
editdiv : CKEDITOR.TRISTATE_OFF,
removediv : CKEDITOR.TRISTATE_OFF
};
}
return null;
} );
}
}
CKEDITOR.dialog.add( 'creatediv', this.path + 'dialogs/div.js' );
CKEDITOR.dialog.add( 'editdiv', this.path + 'dialogs/div.js' );
}
} );
})();
| JavaScript |
/*
* Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
* For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
/**
* Add to collection with DUP examination.
* @param {Object} collection
* @param {Object} element
* @param {Object} database
*/
function addSafely( collection, element, database )
{
// 1. IE doesn't support customData on text nodes;
// 2. Text nodes never get chance to appear twice;
if ( !element.is || !element.getCustomData( 'block_processed' ) )
{
element.is && CKEDITOR.dom.element.setMarker( database, element, 'block_processed', true );
collection.push( element );
}
}
function getNonEmptyChildren( element )
{
var retval = [];
var children = element.getChildren();
for ( var i = 0 ; i < children.count() ; i++ )
{
var child = children.getItem( i );
if ( ! ( child.type === CKEDITOR.NODE_TEXT
&& ( /^[ \t\n\r]+$/ ).test( child.getText() ) ) )
retval.push( child );
}
return retval;
}
/**
* Dialog reused by both 'creatediv' and 'editdiv' commands.
* @param {Object} editor
* @param {String} command The command name which indicate what the current command is.
*/
function divDialog( editor, command )
{
// Definition of elements at which div operation should stopped.
var divLimitDefinition = ( function(){
// Customzie from specialize blockLimit elements
var definition = CKEDITOR.tools.extend( {}, CKEDITOR.dtd.$blockLimit );
// Exclude 'div' itself.
delete definition.div;
// Exclude 'td' and 'th' when 'wrapping table'
if ( editor.config.div_wrapTable )
{
delete definition.td;
delete definition.th;
}
return definition;
})();
// DTD of 'div' element
var dtd = CKEDITOR.dtd.div;
/**
* Get the first div limit element on the element's path.
* @param {Object} element
*/
function getDivLimitElement( element )
{
var pathElements = new CKEDITOR.dom.elementPath( element ).elements;
var divLimit;
for ( var i = 0; i < pathElements.length ; i++ )
{
if ( pathElements[ i ].getName() in divLimitDefinition )
{
divLimit = pathElements[ i ];
break;
}
}
return divLimit;
}
/**
* Init all fields' setup/commit function.
* @memberof divDialog
*/
function setupFields()
{
this.foreach( function( field )
{
// Exclude layout container elements
if ( /^(?!vbox|hbox)/.test( field.type ) )
{
if ( !field.setup )
{
// Read the dialog fields values from the specified
// element attributes.
field.setup = function( element )
{
field.setValue( element.getAttribute( field.id ) || '' );
};
}
if ( !field.commit )
{
// Set element attributes assigned by the dialog
// fields.
field.commit = function( element )
{
var fieldValue = this.getValue();
// ignore default element attribute values
if ( 'dir' == field.id && element.getComputedStyle( 'direction' ) == fieldValue )
return;
if ( fieldValue )
element.setAttribute( field.id, fieldValue );
else
element.removeAttribute( field.id );
};
}
}
} );
}
/**
* Wrapping 'div' element around appropriate blocks among the selected ranges.
* @param {Object} editor
*/
function createDiv( editor )
{
// new adding containers OR detected pre-existed containers.
var containers = [];
// node markers store.
var database = {};
// All block level elements which contained by the ranges.
var containedBlocks = [], block;
// Get all ranges from the selection.
var selection = editor.document.getSelection(),
ranges = selection.getRanges();
var bookmarks = selection.createBookmarks();
var i, iterator;
// Calcualte a default block tag if we need to create blocks.
var blockTag = editor.config.enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p';
// collect all included elements from dom-iterator
for ( i = 0 ; i < ranges.length ; i++ )
{
iterator = ranges[ i ].createIterator();
while ( ( block = iterator.getNextParagraph() ) )
{
// include contents of blockLimit elements.
if ( block.getName() in divLimitDefinition )
{
var j, childNodes = block.getChildren();
for ( j = 0 ; j < childNodes.count() ; j++ )
addSafely( containedBlocks, childNodes.getItem( j ) , database );
}
else
{
// Bypass dtd disallowed elements.
while ( !dtd[ block.getName() ] && block.getName() != 'body' )
block = block.getParent();
addSafely( containedBlocks, block, database );
}
}
}
CKEDITOR.dom.element.clearAllMarkers( database );
var blockGroups = groupByDivLimit( containedBlocks );
var ancestor, blockEl, divElement;
for ( i = 0 ; i < blockGroups.length ; i++ )
{
var currentNode = blockGroups[ i ][ 0 ];
// Calculate the common parent node of all contained elements.
ancestor = currentNode.getParent();
for ( j = 1 ; j < blockGroups[ i ].length; j++ )
ancestor = ancestor.getCommonAncestor( blockGroups[ i ][ j ] );
divElement = new CKEDITOR.dom.element( 'div', editor.document );
// Normalize the blocks in each group to a common parent.
for ( j = 0; j < blockGroups[ i ].length ; j++ )
{
currentNode = blockGroups[ i ][ j ];
while ( !currentNode.getParent().equals( ancestor ) )
currentNode = currentNode.getParent();
// This could introduce some duplicated elements in array.
blockGroups[ i ][ j ] = currentNode;
}
// Wrapped blocks counting
var fixedBlock = null;
for ( j = 0 ; j < blockGroups[ i ].length ; j++ )
{
currentNode = blockGroups[ i ][ j ];
// Avoid DUP elements introduced by grouping.
if ( !( currentNode.getCustomData && currentNode.getCustomData( 'block_processed' ) ) )
{
currentNode.is && CKEDITOR.dom.element.setMarker( database, currentNode, 'block_processed', true );
// Establish new container, wrapping all elements in this group.
if ( !j )
divElement.insertBefore( currentNode );
divElement.append( currentNode );
}
}
CKEDITOR.dom.element.clearAllMarkers( database );
containers.push( divElement );
}
selection.selectBookmarks( bookmarks );
return containers;
}
function getDiv( editor )
{
var path = new CKEDITOR.dom.elementPath( editor.getSelection().getStartElement() ),
blockLimit = path.blockLimit,
div = blockLimit && blockLimit.getAscendant( 'div', true );
return div;
}
/**
* Divide a set of nodes to different groups by their path's blocklimit element.
* Note: the specified nodes should be in source order naturally, which mean they are supposed to producea by following class:
* * CKEDITOR.dom.range.Iterator
* * CKEDITOR.dom.domWalker
* @return {Array []} the grouped nodes
*/
function groupByDivLimit( nodes )
{
var groups = [],
lastDivLimit = null,
path, block;
for ( var i = 0 ; i < nodes.length ; i++ )
{
block = nodes[i];
var limit = getDivLimitElement( block );
if ( !limit.equals( lastDivLimit ) )
{
lastDivLimit = limit ;
groups.push( [] ) ;
}
groups[ groups.length - 1 ].push( block ) ;
}
return groups;
}
// Synchronous field values to other impacted fields is required, e.g. div styles
// change should also alter inline-style text.
function commitInternally( targetFields )
{
var dialog = this.getDialog(),
element = dialog._element && dialog._element.clone()
|| new CKEDITOR.dom.element( 'div', editor.document );
// Commit this field and broadcast to target fields.
this.commit( element, true );
targetFields = [].concat( targetFields );
var length = targetFields.length, field;
for ( var i = 0; i < length; i++ )
{
field = dialog.getContentElement.apply( dialog, targetFields[ i ].split( ':' ) );
field && field.setup && field.setup( element, true );
}
}
// Registered 'CKEDITOR.style' instances.
var styles = {} ;
/**
* Hold a collection of created block container elements.
*/
var containers = [];
/**
* @type divDialog
*/
return {
title : editor.lang.div.title,
minWidth : 400,
minHeight : 165,
contents :
[
{
id :'info',
label :editor.lang.common.generalTab,
title :editor.lang.common.generalTab,
elements :
[
{
type :'hbox',
widths : [ '50%', '50%' ],
children :
[
{
id :'elementStyle',
type :'select',
style :'width: 100%;',
label :editor.lang.div.styleSelectLabel,
'default' : '',
// Options are loaded dynamically.
items :
[
[ editor.lang.common.notSet , '' ]
],
onChange : function()
{
commitInternally.call( this, [ 'info:class', 'advanced:dir', 'advanced:style' ] );
},
setup : function( element )
{
for ( var name in styles )
styles[ name ].checkElementRemovable( element, true ) && this.setValue( name );
},
commit: function( element )
{
var styleName;
if ( ( styleName = this.getValue() ) )
{
var style = styles[ styleName ];
var customData = element.getCustomData( 'elementStyle' ) || '';
style.applyToObject( element );
element.setCustomData( 'elementStyle', customData + style._.definition.attributes.style );
}
}
},
{
id :'class',
type :'text',
label :editor.lang.common.cssClass,
'default' : ''
}
]
}
]
},
{
id :'advanced',
label :editor.lang.common.advancedTab,
title :editor.lang.common.advancedTab,
elements :
[
{
type :'vbox',
padding :1,
children :
[
{
type :'hbox',
widths : [ '50%', '50%' ],
children :
[
{
type :'text',
id :'id',
label :editor.lang.common.id,
'default' : ''
},
{
type :'text',
id :'lang',
label :editor.lang.link.langCode,
'default' : ''
}
]
},
{
type :'hbox',
children :
[
{
type :'text',
id :'style',
style :'width: 100%;',
label :editor.lang.common.cssStyle,
'default' : '',
commit : function( element )
{
// Merge with 'elementStyle', which is of higher priority.
var merged = this.getValue() + ( element.getCustomData( 'elementStyle' ) || '' );
element.setAttribute( 'style', merged );
}
}
]
},
{
type :'hbox',
children :
[
{
type :'text',
id :'title',
style :'width: 100%;',
label :editor.lang.common.advisoryTitle,
'default' : ''
}
]
},
{
type :'select',
id :'dir',
style :'width: 100%;',
label :editor.lang.common.langDir,
'default' : '',
items :
[
[ editor.lang.common.notSet , '' ],
[
editor.lang.common.langDirLtr,
'ltr'
],
[
editor.lang.common.langDirRtl,
'rtl'
]
]
}
]
}
]
}
],
onLoad : function()
{
setupFields.call( this );
// Preparing for the 'elementStyle' field.
var dialog = this,
stylesField = this.getContentElement( 'info', 'elementStyle' );
// Reuse the 'stylescombo' plugin's styles definition.
editor.getStylesSet( function( stylesDefinitions )
{
var styleName;
if ( stylesDefinitions )
{
// Digg only those styles that apply to 'div'.
for ( var i = 0 ; i < stylesDefinitions.length ; i++ )
{
var styleDefinition = stylesDefinitions[ i ];
if ( styleDefinition.element && styleDefinition.element == 'div' )
{
styleName = styleDefinition.name;
styles[ styleName ] = new CKEDITOR.style( styleDefinition );
// Populate the styles field options with style name.
stylesField.items.push( [ styleName, styleName ] );
stylesField.add( styleName, styleName );
}
}
}
// We should disable the content element
// it if no options are available at all.
stylesField[ stylesField.items.length > 1 ? 'enable' : 'disable' ]();
// Now setup the field value manually.
setTimeout( function() { stylesField.setup( dialog._element ); }, 0 );
} );
},
onShow : function()
{
// Whether always create new container regardless of existed
// ones.
if ( command == 'editdiv' )
{
// Try to discover the containers that already existed in
// ranges
var div = getDiv( editor );
// update dialog field values
div && this.setupContent( this._element = div );
}
},
onOk : function()
{
if ( command == 'editdiv' )
containers = [ this._element ];
else
containers = createDiv( editor, true );
// Update elements attributes
var size = containers.length;
for ( var i = 0; i < size; i++ )
{
this.commitContent( containers[ i ] );
// Remove empty 'style' attribute.
!containers[ i ].getAttribute( 'style' ) && containers[ i ].removeAttribute( 'style' );
}
this.hide();
},
onHide : function()
{
// Remove style only when editing existing DIV. (#6315)
if ( command == 'editdiv' )
this._element.removeCustomData( 'elementStyle' );
delete this._element;
}
};
}
CKEDITOR.dialog.add( 'creatediv', function( editor )
{
return divDialog( editor, 'creatediv' );
} );
CKEDITOR.dialog.add( 'editdiv', function( editor )
{
return divDialog( editor, 'editdiv' );
} );
} )();
/*
* @name CKEDITOR.config.div_wrapTable
* Whether to wrap the whole table instead of indivisual cells when created 'div' in table cell.
* @type Boolean
* @default false
* @example config.div_wrapTable = true;
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
function setupAdvParams( element )
{
var attrName = this.att;
var value = element && element.hasAttribute( attrName ) && element.getAttribute( attrName ) || '';
if ( value !== undefined )
this.setValue( value );
}
function commitAdvParams()
{
// Dialogs may use different parameters in the commit list, so, by
// definition, we take the first CKEDITOR.dom.element available.
var element;
for ( var i = 0 ; i < arguments.length ; i++ )
{
if ( arguments[ i ] instanceof CKEDITOR.dom.element )
{
element = arguments[ i ];
break;
}
}
if ( element )
{
var attrName = this.att,
value = this.getValue();
if ( value )
element.setAttribute( attrName, value );
else
element.removeAttribute( attrName, value );
}
}
CKEDITOR.plugins.add( 'dialogadvtab',
{
/**
*
* @param tabConfig
* id, dir, classes, styles
*/
createAdvancedTab : function( editor, tabConfig )
{
if ( !tabConfig )
tabConfig = { id:1, dir:1, classes:1, styles:1 };
var lang = editor.lang.common;
var result =
{
id : 'advanced',
label : lang.advancedTab,
title : lang.advancedTab,
elements :
[
{
type : 'vbox',
padding : 1,
children : []
}
]
};
var contents = [];
if ( tabConfig.id || tabConfig.dir )
{
if ( tabConfig.id )
{
contents.push(
{
id : 'advId',
att : 'id',
type : 'text',
label : lang.id,
setup : setupAdvParams,
commit : commitAdvParams
});
}
if ( tabConfig.dir )
{
contents.push(
{
id : 'advLangDir',
att : 'dir',
type : 'select',
label : lang.langDir,
'default' : '',
style : 'width:100%',
items :
[
[ lang.notSet, '' ],
[ lang.langDirLTR, 'ltr' ],
[ lang.langDirRTL, 'rtl' ]
],
setup : setupAdvParams,
commit : commitAdvParams
});
}
result.elements[ 0 ].children.push(
{
type : 'hbox',
widths : [ '50%', '50%' ],
children : [].concat( contents )
});
}
if ( tabConfig.styles || tabConfig.classes )
{
contents = [];
if ( tabConfig.styles )
{
contents.push(
{
id : 'advStyles',
att : 'style',
type : 'text',
label : lang.styles,
'default' : '',
validate : CKEDITOR.dialog.validate.inlineStyle( lang.invalidInlineStyle ),
onChange : function(){},
getStyle : function( name, defaultValue )
{
var match = this.getValue().match( new RegExp( name + '\\s*:\\s*([^;]*)', 'i') );
return match ? match[ 1 ] : defaultValue;
},
updateStyle : function( name, value )
{
var styles = this.getValue();
// Remove the current value.
if ( styles )
{
styles = styles
.replace( new RegExp( '\\s*' + name + '\s*:[^;]*(?:$|;\s*)', 'i' ), '' )
.replace( /^[;\s]+/, '' )
.replace( /\s+$/, '' );
}
if ( value )
{
styles && !(/;\s*$/).test( styles ) && ( styles += '; ' );
styles += name + ': ' + value;
}
this.setValue( styles, 1 );
},
setup : setupAdvParams,
commit : commitAdvParams
});
}
if ( tabConfig.classes )
{
contents.push(
{
type : 'hbox',
widths : [ '45%', '55%' ],
children :
[
{
id : 'advCSSClasses',
att : 'class',
type : 'text',
label : lang.cssClasses,
'default' : '',
setup : setupAdvParams,
commit : commitAdvParams
}
]
});
}
result.elements[ 0 ].children.push(
{
type : 'hbox',
widths : [ '50%', '50%' ],
children : [].concat( contents )
});
}
return result;
}
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var guardElements = { table:1, ul:1, ol:1, blockquote:1, div:1 },
directSelectionGuardElements = {},
// All guard elements which can have a direction applied on them.
allGuardElements = {};
CKEDITOR.tools.extend( directSelectionGuardElements, guardElements, { tr:1, p:1, div:1, li:1 } );
CKEDITOR.tools.extend( allGuardElements, directSelectionGuardElements, { td:1 } );
function onSelectionChange( e )
{
setToolbarStates( e );
handleMixedDirContent( e );
}
function setToolbarStates( evt )
{
var editor = evt.editor,
path = evt.data.path;
if ( editor.readOnly )
return;
var useComputedState = editor.config.useComputedState,
selectedElement;
useComputedState = useComputedState === undefined || useComputedState;
// We can use computedState provided by the browser or traverse parents manually.
if ( !useComputedState )
selectedElement = getElementForDirection( path.lastElement );
selectedElement = selectedElement || path.block || path.blockLimit;
// If we're having BODY here, user probably done CTRL+A, let's try to get the enclosed node, if any.
if ( selectedElement.is( 'body' ) )
{
var enclosedNode = editor.getSelection().getRanges()[ 0 ].getEnclosedNode();
enclosedNode && enclosedNode.type == CKEDITOR.NODE_ELEMENT && ( selectedElement = enclosedNode );
}
if ( !selectedElement )
return;
var selectionDir = useComputedState ?
selectedElement.getComputedStyle( 'direction' ) :
selectedElement.getStyle( 'direction' ) || selectedElement.getAttribute( 'dir' );
editor.getCommand( 'bidirtl' ).setState( selectionDir == 'rtl' ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
editor.getCommand( 'bidiltr' ).setState( selectionDir == 'ltr' ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
}
function handleMixedDirContent( evt )
{
var editor = evt.editor,
directionNode = evt.data.path.block || evt.data.path.blockLimit;
editor.fire( 'contentDirChanged', directionNode ? directionNode.getComputedStyle( 'direction' ) : editor.lang.dir );
}
/**
* Returns element with possibility of applying the direction.
* @param node
*/
function getElementForDirection( node )
{
while ( node && !( node.getName() in allGuardElements || node.is( 'body' ) ) )
{
var parent = node.getParent();
if ( !parent )
break;
node = parent;
}
return node;
}
function switchDir( element, dir, editor, database )
{
if ( element.isReadOnly() )
return;
// Mark this element as processed by switchDir.
CKEDITOR.dom.element.setMarker( database, element, 'bidi_processed', 1 );
// Check whether one of the ancestors has already been styled.
var parent = element;
while ( ( parent = parent.getParent() ) && !parent.is( 'body' ) )
{
if ( parent.getCustomData( 'bidi_processed' ) )
{
// Ancestor style must dominate.
element.removeStyle( 'direction' );
element.removeAttribute( 'dir' );
return;
}
}
var useComputedState = ( 'useComputedState' in editor.config ) ? editor.config.useComputedState : 1;
var elementDir = useComputedState ? element.getComputedStyle( 'direction' )
: element.getStyle( 'direction' ) || element.hasAttribute( 'dir' );
// Stop if direction is same as present.
if ( elementDir == dir )
return;
// Clear direction on this element.
element.removeStyle( 'direction' );
// Do the second check when computed state is ON, to check
// if we need to apply explicit direction on this element.
if ( useComputedState )
{
element.removeAttribute( 'dir' );
if ( dir != element.getComputedStyle( 'direction' ) )
element.setAttribute( 'dir', dir );
}
else
// Set new direction for this element.
element.setAttribute( 'dir', dir );
editor.forceNextSelectionCheck();
return;
}
function getFullySelected( range, elements, enterMode )
{
var ancestor = range.getCommonAncestor( false, true );
range = range.clone();
range.enlarge( enterMode == CKEDITOR.ENTER_BR ?
CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS
: CKEDITOR.ENLARGE_BLOCK_CONTENTS );
if ( range.checkBoundaryOfElement( ancestor, CKEDITOR.START )
&& range.checkBoundaryOfElement( ancestor, CKEDITOR.END ) )
{
var parent;
while ( ancestor && ancestor.type == CKEDITOR.NODE_ELEMENT
&& ( parent = ancestor.getParent() )
&& parent.getChildCount() == 1
&& !( ancestor.getName() in elements ) )
ancestor = parent;
return ancestor.type == CKEDITOR.NODE_ELEMENT
&& ( ancestor.getName() in elements )
&& ancestor;
}
}
function bidiCommand( dir )
{
return function( editor )
{
var selection = editor.getSelection(),
enterMode = editor.config.enterMode,
ranges = selection.getRanges();
if ( ranges && ranges.length )
{
var database = {};
// Creates bookmarks for selection, as we may split some blocks.
var bookmarks = selection.createBookmarks();
var rangeIterator = ranges.createIterator(),
range,
i = 0;
while ( ( range = rangeIterator.getNextRange( 1 ) ) )
{
// Apply do directly selected elements from guardElements.
var selectedElement = range.getEnclosedNode();
// If this is not our element of interest, apply to fully selected elements from guardElements.
if ( !selectedElement || selectedElement
&& !( selectedElement.type == CKEDITOR.NODE_ELEMENT && selectedElement.getName() in directSelectionGuardElements )
)
selectedElement = getFullySelected( range, guardElements, enterMode );
selectedElement && switchDir( selectedElement, dir, editor, database );
var iterator,
block;
// Walker searching for guardElements.
var walker = new CKEDITOR.dom.walker( range );
var start = bookmarks[ i ].startNode,
end = bookmarks[ i++ ].endNode;
walker.evaluator = function( node )
{
return !! ( node.type == CKEDITOR.NODE_ELEMENT
&& node.getName() in guardElements
&& !( node.getName() == ( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' )
&& node.getParent().type == CKEDITOR.NODE_ELEMENT
&& node.getParent().getName() == 'blockquote' )
// Element must be fully included in the range as well. (#6485).
&& node.getPosition( start ) & CKEDITOR.POSITION_FOLLOWING
&& ( ( node.getPosition( end ) & CKEDITOR.POSITION_PRECEDING + CKEDITOR.POSITION_CONTAINS ) == CKEDITOR.POSITION_PRECEDING ) );
};
while ( ( block = walker.next() ) )
switchDir( block, dir, editor, database );
iterator = range.createIterator();
iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) )
switchDir( block, dir, editor, database );
}
CKEDITOR.dom.element.clearAllMarkers( database );
editor.forceNextSelectionCheck();
// Restore selection position.
selection.selectBookmarks( bookmarks );
editor.focus();
}
};
}
CKEDITOR.plugins.add( 'bidi',
{
requires : [ 'styles', 'button' ],
init : function( editor )
{
// All buttons use the same code to register. So, to avoid
// duplications, let's use this tool function.
var addButtonCommand = function( buttonName, buttonLabel, commandName, commandExec )
{
editor.addCommand( commandName, new CKEDITOR.command( editor, { exec : commandExec }) );
editor.ui.addButton( buttonName,
{
label : buttonLabel,
command : commandName
});
};
var lang = editor.lang.bidi;
addButtonCommand( 'BidiLtr', lang.ltr, 'bidiltr', bidiCommand( 'ltr' ) );
addButtonCommand( 'BidiRtl', lang.rtl, 'bidirtl', bidiCommand( 'rtl' ) );
editor.on( 'selectionChange', onSelectionChange );
editor.on( 'contentDom', function()
{
editor.document.on( 'dirChanged', function( evt )
{
editor.fire( 'dirChanged',
{
node : evt.data,
dir : evt.data.getDirection( 1 )
} );
});
});
}
});
// If the element direction changed, we need to switch the margins of
// the element and all its children, so it will get really reflected
// like a mirror. (#5910)
function isOffline( el )
{
var html = el.getDocument().getBody().getParent();
while ( el )
{
if ( el.equals( html ) )
return false;
el = el.getParent();
}
return true;
}
function dirChangeNotifier( org )
{
var isAttribute = org == elementProto.setAttribute,
isRemoveAttribute = org == elementProto.removeAttribute,
dirStyleRegexp = /\bdirection\s*:\s*(.*?)\s*(:?$|;)/;
return function( name, val )
{
if ( !this.getDocument().equals( CKEDITOR.document ) )
{
var orgDir;
if ( ( name == ( isAttribute || isRemoveAttribute ? 'dir' : 'direction' ) ||
name == 'style' && ( isRemoveAttribute || dirStyleRegexp.test( val ) ) ) && !isOffline( this ) )
{
orgDir = this.getDirection( 1 );
var retval = org.apply( this, arguments );
if ( orgDir != this.getDirection( 1 ) )
{
this.getDocument().fire( 'dirChanged', this );
return retval;
}
}
}
return org.apply( this, arguments );
};
}
var elementProto = CKEDITOR.dom.element.prototype,
methods = [ 'setStyle', 'removeStyle', 'setAttribute', 'removeAttribute' ];
for ( var i = 0; i < methods.length; i++ )
elementProto[ methods[ i ] ] = CKEDITOR.tools.override( elementProto[ methods [ i ] ], dirChangeNotifier );
})();
/**
* Fired when the language direction of an element is changed
* @name CKEDITOR.editor#dirChanged
* @event
* @param {CKEDITOR.editor} editor This editor instance.
* @param {Object} eventData.node The element that is being changed.
* @param {String} eventData.dir The new direction.
*/
/**
* Fired when the language direction in the specific cursor position is changed
* @name CKEDITOR.editor#contentDirChanged
* @event
* @param {String} eventData The direction in the current position.
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Increse and decrease indent commands.
*/
(function()
{
var listNodeNames = { ol : 1, ul : 1 },
isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true ),
isNotBookmark = CKEDITOR.dom.walker.bookmark( false, true );
function onSelectionChange( evt )
{
if ( evt.editor.readOnly )
return null;
var editor = evt.editor,
elementPath = evt.data.path,
list = elementPath && elementPath.contains( listNodeNames ),
firstBlock = elementPath.block || elementPath.blockLimit;
if ( list )
return this.setState( CKEDITOR.TRISTATE_OFF );
if ( !this.useIndentClasses && this.name == 'indent' )
return this.setState( CKEDITOR.TRISTATE_OFF );
if ( !firstBlock )
return this.setState( CKEDITOR.TRISTATE_DISABLED );
if ( this.useIndentClasses )
{
var indentClass = firstBlock.$.className.match( this.classNameRegex ),
indentStep = 0;
if ( indentClass )
{
indentClass = indentClass[1];
indentStep = this.indentClassMap[ indentClass ];
}
if ( ( this.name == 'outdent' && !indentStep ) ||
( this.name == 'indent' && indentStep == editor.config.indentClasses.length ) )
return this.setState( CKEDITOR.TRISTATE_DISABLED );
return this.setState( CKEDITOR.TRISTATE_OFF );
}
else
{
var indent = parseInt( firstBlock.getStyle( getIndentCssProperty( firstBlock ) ), 10 );
if ( isNaN( indent ) )
indent = 0;
if ( indent <= 0 )
return this.setState( CKEDITOR.TRISTATE_DISABLED );
return this.setState( CKEDITOR.TRISTATE_OFF );
}
}
function indentCommand( editor, name )
{
this.name = name;
this.useIndentClasses = editor.config.indentClasses && editor.config.indentClasses.length > 0;
if ( this.useIndentClasses )
{
this.classNameRegex = new RegExp( '(?:^|\\s+)(' + editor.config.indentClasses.join( '|' ) + ')(?=$|\\s)' );
this.indentClassMap = {};
for ( var i = 0 ; i < editor.config.indentClasses.length ; i++ )
this.indentClassMap[ editor.config.indentClasses[i] ] = i + 1;
}
this.startDisabled = name == 'outdent';
}
// Returns the CSS property to be used for identing a given element.
function getIndentCssProperty( element, dir )
{
return ( dir || element.getComputedStyle( 'direction' ) ) == 'ltr' ? 'margin-left' : 'margin-right';
}
function isListItem( node )
{
return node.type == CKEDITOR.NODE_ELEMENT && node.is( 'li' );
}
indentCommand.prototype = {
exec : function( editor )
{
var self = this, database = {};
function indentList( listNode )
{
// Our starting and ending points of the range might be inside some blocks under a list item...
// So before playing with the iterator, we need to expand the block to include the list items.
var startContainer = range.startContainer,
endContainer = range.endContainer;
while ( startContainer && !startContainer.getParent().equals( listNode ) )
startContainer = startContainer.getParent();
while ( endContainer && !endContainer.getParent().equals( listNode ) )
endContainer = endContainer.getParent();
if ( !startContainer || !endContainer )
return;
// Now we can iterate over the individual items on the same tree depth.
var block = startContainer,
itemsToMove = [],
stopFlag = false;
while ( !stopFlag )
{
if ( block.equals( endContainer ) )
stopFlag = true;
itemsToMove.push( block );
block = block.getNext();
}
if ( itemsToMove.length < 1 )
return;
// Do indent or outdent operations on the array model of the list, not the
// list's DOM tree itself. The array model demands that it knows as much as
// possible about the surrounding lists, we need to feed it the further
// ancestor node that is still a list.
var listParents = listNode.getParents( true );
for ( var i = 0 ; i < listParents.length ; i++ )
{
if ( listParents[i].getName && listNodeNames[ listParents[i].getName() ] )
{
listNode = listParents[i];
break;
}
}
var indentOffset = self.name == 'indent' ? 1 : -1,
startItem = itemsToMove[0],
lastItem = itemsToMove[ itemsToMove.length - 1 ];
// Convert the list DOM tree into a one dimensional array.
var listArray = CKEDITOR.plugins.list.listToArray( listNode, database );
// Apply indenting or outdenting on the array.
var baseIndent = listArray[ lastItem.getCustomData( 'listarray_index' ) ].indent;
for ( i = startItem.getCustomData( 'listarray_index' ); i <= lastItem.getCustomData( 'listarray_index' ); i++ )
{
listArray[ i ].indent += indentOffset;
// Make sure the newly created sublist get a brand-new element of the same type. (#5372)
if ( indentOffset > 0 )
{
var listRoot = listArray[ i ].parent;
listArray[ i ].parent = new CKEDITOR.dom.element( listRoot.getName(), listRoot.getDocument() );
}
}
for ( i = lastItem.getCustomData( 'listarray_index' ) + 1 ;
i < listArray.length && listArray[i].indent > baseIndent ; i++ )
listArray[i].indent += indentOffset;
// Convert the array back to a DOM forest (yes we might have a few subtrees now).
// And replace the old list with the new forest.
var newList = CKEDITOR.plugins.list.arrayToList( listArray, database, null, editor.config.enterMode, listNode.getDirection() );
// Avoid nested <li> after outdent even they're visually same,
// recording them for later refactoring.(#3982)
if ( self.name == 'outdent' )
{
var parentLiElement;
if ( ( parentLiElement = listNode.getParent() ) && parentLiElement.is( 'li' ) )
{
var children = newList.listNode.getChildren(),
pendingLis = [],
count = children.count(),
child;
for ( i = count - 1 ; i >= 0 ; i-- )
{
if ( ( child = children.getItem( i ) ) && child.is && child.is( 'li' ) )
pendingLis.push( child );
}
}
}
if ( newList )
newList.listNode.replace( listNode );
// Move the nested <li> to be appeared after the parent.
if ( pendingLis && pendingLis.length )
{
for ( i = 0; i < pendingLis.length ; i++ )
{
var li = pendingLis[ i ],
followingList = li;
// Nest preceding <ul>/<ol> inside current <li> if any.
while ( ( followingList = followingList.getNext() ) &&
followingList.is &&
followingList.getName() in listNodeNames )
{
// IE requires a filler NBSP for nested list inside empty list item,
// otherwise the list item will be inaccessiable. (#4476)
if ( CKEDITOR.env.ie && !li.getFirst( function( node ){ return isNotWhitespaces( node ) && isNotBookmark( node ); } ) )
li.append( range.document.createText( '\u00a0' ) );
li.append( followingList );
}
li.insertAfter( parentLiElement );
}
}
}
function indentBlock()
{
var iterator = range.createIterator(),
enterMode = editor.config.enterMode;
iterator.enforceRealBlocks = true;
iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
var block;
while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) )
indentElement( block );
}
function indentElement( element, dir )
{
if ( element.getCustomData( 'indent_processed' ) )
return false;
if ( self.useIndentClasses )
{
// Transform current class name to indent step index.
var indentClass = element.$.className.match( self.classNameRegex ),
indentStep = 0;
if ( indentClass )
{
indentClass = indentClass[1];
indentStep = self.indentClassMap[ indentClass ];
}
// Operate on indent step index, transform indent step index back to class
// name.
if ( self.name == 'outdent' )
indentStep--;
else
indentStep++;
if ( indentStep < 0 )
return false;
indentStep = Math.min( indentStep, editor.config.indentClasses.length );
indentStep = Math.max( indentStep, 0 );
element.$.className = CKEDITOR.tools.ltrim( element.$.className.replace( self.classNameRegex, '' ) );
if ( indentStep > 0 )
element.addClass( editor.config.indentClasses[ indentStep - 1 ] );
}
else
{
var indentCssProperty = getIndentCssProperty( element, dir ),
currentOffset = parseInt( element.getStyle( indentCssProperty ), 10 );
if ( isNaN( currentOffset ) )
currentOffset = 0;
var indentOffset = editor.config.indentOffset || 40;
currentOffset += ( self.name == 'indent' ? 1 : -1 ) * indentOffset;
if ( currentOffset < 0 )
return false;
currentOffset = Math.max( currentOffset, 0 );
currentOffset = Math.ceil( currentOffset / indentOffset ) * indentOffset;
element.setStyle( indentCssProperty, currentOffset ? currentOffset + ( editor.config.indentUnit || 'px' ) : '' );
if ( element.getAttribute( 'style' ) === '' )
element.removeAttribute( 'style' );
}
CKEDITOR.dom.element.setMarker( database, element, 'indent_processed', 1 );
return true;
}
var selection = editor.getSelection(),
bookmarks = selection.createBookmarks( 1 ),
ranges = selection && selection.getRanges( 1 ),
range;
var iterator = ranges.createIterator();
while ( ( range = iterator.getNextRange() ) )
{
var rangeRoot = range.getCommonAncestor(),
nearestListBlock = rangeRoot;
while ( nearestListBlock && !( nearestListBlock.type == CKEDITOR.NODE_ELEMENT &&
listNodeNames[ nearestListBlock.getName() ] ) )
nearestListBlock = nearestListBlock.getParent();
// Avoid having selection enclose the entire list. (#6138)
// [<ul><li>...</li></ul>] =><ul><li>[...]</li></ul>
if ( !nearestListBlock )
{
var selectedNode = range.getEnclosedNode();
if ( selectedNode
&& selectedNode.type == CKEDITOR.NODE_ELEMENT
&& selectedNode.getName() in listNodeNames)
{
range.setStartAt( selectedNode, CKEDITOR.POSITION_AFTER_START );
range.setEndAt( selectedNode, CKEDITOR.POSITION_BEFORE_END );
nearestListBlock = selectedNode;
}
}
// Avoid selection anchors under list root.
// <ul>[<li>...</li>]</ul> => <ul><li>[...]</li></ul>
if ( nearestListBlock && range.startContainer.type == CKEDITOR.NODE_ELEMENT
&& range.startContainer.getName() in listNodeNames )
{
var walker = new CKEDITOR.dom.walker( range );
walker.evaluator = isListItem;
range.startContainer = walker.next();
}
if ( nearestListBlock && range.endContainer.type == CKEDITOR.NODE_ELEMENT
&& range.endContainer.getName() in listNodeNames )
{
walker = new CKEDITOR.dom.walker( range );
walker.evaluator = isListItem;
range.endContainer = walker.previous();
}
if ( nearestListBlock )
{
var firstListItem = nearestListBlock.getFirst( isListItem ),
hasMultipleItems = !!firstListItem.getNext( isListItem ),
rangeStart = range.startContainer,
indentWholeList = firstListItem.equals( rangeStart ) || firstListItem.contains( rangeStart );
// Indent the entire list if cursor is inside the first list item. (#3893)
// Only do that for indenting or when using indent classes or when there is something to outdent. (#6141)
if ( !( indentWholeList &&
( self.name == 'indent' || self.useIndentClasses || parseInt( nearestListBlock.getStyle( getIndentCssProperty( nearestListBlock ) ), 10 ) ) &&
indentElement( nearestListBlock, !hasMultipleItems && firstListItem.getDirection() ) ) )
indentList( nearestListBlock );
}
else
indentBlock();
}
// Clean up the markers.
CKEDITOR.dom.element.clearAllMarkers( database );
editor.forceNextSelectionCheck();
selection.selectBookmarks( bookmarks );
}
};
CKEDITOR.plugins.add( 'indent',
{
init : function( editor )
{
// Register commands.
var indent = editor.addCommand( 'indent', new indentCommand( editor, 'indent' ) ),
outdent = editor.addCommand( 'outdent', new indentCommand( editor, 'outdent' ) );
// Register the toolbar buttons.
editor.ui.addButton( 'Indent',
{
label : editor.lang.indent,
command : 'indent'
});
editor.ui.addButton( 'Outdent',
{
label : editor.lang.outdent,
command : 'outdent'
});
// Register the state changing handlers.
editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, indent ) );
editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, outdent ) );
// [IE6/7] Raw lists are using margin instead of padding for visual indentation in wysiwyg mode. (#3893)
if ( CKEDITOR.env.ie6Compat || CKEDITOR.env.ie7Compat )
{
editor.addCss(
"ul,ol" +
"{" +
" margin-left: 0px;" +
" padding-left: 40px;" +
"}" );
}
// Register dirChanged listener.
editor.on( 'dirChanged', function( e )
{
var range = new CKEDITOR.dom.range( editor.document );
range.setStartBefore( e.data.node );
range.setEndAfter( e.data.node );
var walker = new CKEDITOR.dom.walker( range ),
node;
while ( ( node = walker.next() ) )
{
if ( node.type == CKEDITOR.NODE_ELEMENT )
{
// A child with the defined dir is to be ignored.
if ( !node.equals( e.data.node ) && node.getDirection() )
{
range.setStartAfter( node );
walker = new CKEDITOR.dom.walker( range );
continue;
}
// Switch alignment classes.
var classes = editor.config.indentClasses;
if ( classes )
{
var suffix = ( e.data.dir == 'ltr' ) ? [ '_rtl', '' ] : [ '', '_rtl' ];
for ( var i = 0; i < classes.length; i++ )
{
if ( node.hasClass( classes[ i ] + suffix[ 0 ] ) )
{
node.removeClass( classes[ i ] + suffix[ 0 ] );
node.addClass( classes[ i ] + suffix[ 1 ] );
}
}
}
// Switch the margins.
var marginLeft = node.getStyle( 'margin-right' ),
marginRight = node.getStyle( 'margin-left' );
marginLeft ? node.setStyle( 'margin-left', marginLeft ) : node.removeStyle( 'margin-left' );
marginRight ? node.setStyle( 'margin-right', marginRight ) : node.removeStyle( 'margin-right' );
}
}
});
},
requires : [ 'domiterator', 'list' ]
} );
})();
/**
* Size of each indentation step
* @name CKEDITOR.config.indentOffset
* @type Number
* @default 40
* @example
* config.indentOffset = 4;
*/
/**
* Unit for the indentation style
* @name CKEDITOR.config.indentUnit
* @type String
* @default 'px'
* @example
* config.indentUnit = 'em';
*/
/**
* List of classes to use for indenting the contents. If it's null, no classes will be used
* and instead the {@link #indentUnit} and {@link #indentOffset} properties will be used.
* @name CKEDITOR.config.indentClasses
* @type Array
* @default null
* @example
* // Use the classes 'Indent1', 'Indent2', 'Indent3'
* config.indentClasses = ['Indent1', 'Indent2', 'Indent3'];
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
function protectFormStyles( formElement )
{
if ( !formElement || formElement.type != CKEDITOR.NODE_ELEMENT || formElement.getName() != 'form' )
return [];
var hijackRecord = [],
hijackNames = [ 'style', 'className' ];
for ( var i = 0 ; i < hijackNames.length ; i++ )
{
var name = hijackNames[i];
var $node = formElement.$.elements.namedItem( name );
if ( $node )
{
var hijackNode = new CKEDITOR.dom.element( $node );
hijackRecord.push( [ hijackNode, hijackNode.nextSibling ] );
hijackNode.remove();
}
}
return hijackRecord;
}
function restoreFormStyles( formElement, hijackRecord )
{
if ( !formElement || formElement.type != CKEDITOR.NODE_ELEMENT || formElement.getName() != 'form' )
return;
if ( hijackRecord.length > 0 )
{
for ( var i = hijackRecord.length - 1 ; i >= 0 ; i-- )
{
var node = hijackRecord[i][0];
var sibling = hijackRecord[i][1];
if ( sibling )
node.insertBefore( sibling );
else
node.appendTo( formElement );
}
}
}
function saveStyles( element, isInsideEditor )
{
var data = protectFormStyles( element );
var retval = {};
var $element = element.$;
if ( !isInsideEditor )
{
retval[ 'class' ] = $element.className || '';
$element.className = '';
}
retval.inline = $element.style.cssText || '';
if ( !isInsideEditor ) // Reset any external styles that might interfere. (#2474)
$element.style.cssText = 'position: static; overflow: visible';
restoreFormStyles( data );
return retval;
}
function restoreStyles( element, savedStyles )
{
var data = protectFormStyles( element );
var $element = element.$;
if ( 'class' in savedStyles )
$element.className = savedStyles[ 'class' ];
if ( 'inline' in savedStyles )
$element.style.cssText = savedStyles.inline;
restoreFormStyles( data );
}
function refreshCursor( editor )
{
// Refresh all editor instances on the page (#5724).
var all = CKEDITOR.instances;
for ( var i in all )
{
var one = all[ i ];
if ( one.mode == 'wysiwyg' && !one.readOnly )
{
var body = one.document.getBody();
// Refresh 'contentEditable' otherwise
// DOM lifting breaks design mode. (#5560)
body.setAttribute( 'contentEditable', false );
body.setAttribute( 'contentEditable', true );
}
}
if ( editor.focusManager.hasFocus )
{
editor.toolbox.focus();
editor.focus();
}
}
/**
* Adding an iframe shim to this element, OR removing the existing one if already applied.
* Note: This will only affect IE version below 7.
*/
function createIframeShim( element )
{
if ( !CKEDITOR.env.ie || CKEDITOR.env.version > 6 )
return null;
var shim = CKEDITOR.dom.element.createFromHtml( '<iframe frameborder="0" tabindex="-1"' +
' src="javascript:' +
'void((function(){' +
'document.open();' +
( CKEDITOR.env.isCustomDomain() ? 'document.domain=\'' + this.getDocument().$.domain + '\';' : '' ) +
'document.close();' +
'})())"' +
' style="display:block;position:absolute;z-index:-1;' +
'progid:DXImageTransform.Microsoft.Alpha(opacity=0);' +
'"></iframe>' );
return element.append( shim, true );
}
CKEDITOR.plugins.add( 'maximize',
{
init : function( editor )
{
var lang = editor.lang;
var mainDocument = CKEDITOR.document,
mainWindow = mainDocument.getWindow();
// Saved selection and scroll position for the editing area.
var savedSelection,
savedScroll;
// Saved scroll position for the outer window.
var outerScroll;
var shim;
// Saved resize handler function.
function resizeHandler()
{
var viewPaneSize = mainWindow.getViewPaneSize();
shim && shim.setStyles( { width : viewPaneSize.width + 'px', height : viewPaneSize.height + 'px' } );
editor.resize( viewPaneSize.width, viewPaneSize.height, null, true );
}
// Retain state after mode switches.
var savedState = CKEDITOR.TRISTATE_OFF;
editor.addCommand( 'maximize',
{
// Disabled on iOS (#8307).
modes : { wysiwyg : !CKEDITOR.env.iOS, source : !CKEDITOR.env.iOS },
readOnly : 1,
editorFocus : false,
exec : function()
{
var container = editor.container.getChild( 1 );
var contents = editor.getThemeSpace( 'contents' );
// Save current selection and scroll position in editing area.
if ( editor.mode == 'wysiwyg' )
{
var selection = editor.getSelection();
savedSelection = selection && selection.getRanges();
savedScroll = mainWindow.getScrollPosition();
}
else
{
var $textarea = editor.textarea.$;
savedSelection = !CKEDITOR.env.ie && [ $textarea.selectionStart, $textarea.selectionEnd ];
savedScroll = [ $textarea.scrollLeft, $textarea.scrollTop ];
}
if ( this.state == CKEDITOR.TRISTATE_OFF ) // Go fullscreen if the state is off.
{
// Add event handler for resizing.
mainWindow.on( 'resize', resizeHandler );
// Save the scroll bar position.
outerScroll = mainWindow.getScrollPosition();
// Save and reset the styles for the entire node tree.
var currentNode = editor.container;
while ( ( currentNode = currentNode.getParent() ) )
{
currentNode.setCustomData( 'maximize_saved_styles', saveStyles( currentNode ) );
currentNode.setStyle( 'z-index', editor.config.baseFloatZIndex - 1 );
}
contents.setCustomData( 'maximize_saved_styles', saveStyles( contents, true ) );
container.setCustomData( 'maximize_saved_styles', saveStyles( container, true ) );
// Hide scroll bars.
var styles =
{
overflow : CKEDITOR.env.webkit ? '' : 'hidden', // #6896
width : 0,
height : 0
};
mainDocument.getDocumentElement().setStyles( styles );
!CKEDITOR.env.gecko && mainDocument.getDocumentElement().setStyle( 'position', 'fixed' );
!( CKEDITOR.env.gecko && CKEDITOR.env.quirks ) && mainDocument.getBody().setStyles( styles );
// Scroll to the top left (IE needs some time for it - #4923).
CKEDITOR.env.ie ?
setTimeout( function() { mainWindow.$.scrollTo( 0, 0 ); }, 0 ) :
mainWindow.$.scrollTo( 0, 0 );
// Resize and move to top left.
// Special treatment for FF Quirks (#7284)
container.setStyle( 'position', CKEDITOR.env.gecko && CKEDITOR.env.quirks ? 'fixed' : 'absolute' );
container.$.offsetLeft; // SAFARI BUG: See #2066.
container.setStyles(
{
'z-index' : editor.config.baseFloatZIndex - 1,
left : '0px',
top : '0px'
} );
shim = createIframeShim( container ); // IE6 select element penetration when maximized. (#4459)
// Add cke_maximized class before resize handle since that will change things sizes (#5580)
container.addClass( 'cke_maximized' );
resizeHandler();
// Still not top left? Fix it. (Bug #174)
var offset = container.getDocumentPosition();
container.setStyles(
{
left : ( -1 * offset.x ) + 'px',
top : ( -1 * offset.y ) + 'px'
} );
// Fixing positioning editor chrome in Firefox break design mode. (#5149)
CKEDITOR.env.gecko && refreshCursor( editor );
}
else if ( this.state == CKEDITOR.TRISTATE_ON ) // Restore from fullscreen if the state is on.
{
// Remove event handler for resizing.
mainWindow.removeListener( 'resize', resizeHandler );
// Restore CSS styles for the entire node tree.
var editorElements = [ contents, container ];
for ( var i = 0 ; i < editorElements.length ; i++ )
{
restoreStyles( editorElements[i], editorElements[i].getCustomData( 'maximize_saved_styles' ) );
editorElements[i].removeCustomData( 'maximize_saved_styles' );
}
currentNode = editor.container;
while ( ( currentNode = currentNode.getParent() ) )
{
restoreStyles( currentNode, currentNode.getCustomData( 'maximize_saved_styles' ) );
currentNode.removeCustomData( 'maximize_saved_styles' );
}
// Restore the window scroll position.
CKEDITOR.env.ie ?
setTimeout( function() { mainWindow.$.scrollTo( outerScroll.x, outerScroll.y ); }, 0 ) :
mainWindow.$.scrollTo( outerScroll.x, outerScroll.y );
// Remove cke_maximized class.
container.removeClass( 'cke_maximized' );
// Webkit requires a re-layout on editor chrome. (#6695)
if ( CKEDITOR.env.webkit )
{
container.setStyle( 'display', 'inline' );
setTimeout( function(){ container.setStyle( 'display', 'block' ); }, 0 );
}
if ( shim )
{
shim.remove();
shim = null;
}
// Emit a resize event, because this time the size is modified in
// restoreStyles.
editor.fire( 'resize' );
}
this.toggleState();
// Toggle button label.
var button = this.uiItems[ 0 ];
// Only try to change the button if it exists (#6166)
if( button )
{
var label = ( this.state == CKEDITOR.TRISTATE_OFF )
? lang.maximize : lang.minimize;
var buttonNode = editor.element.getDocument().getById( button._.id );
buttonNode.getChild( 1 ).setHtml( label );
buttonNode.setAttribute( 'title', label );
buttonNode.setAttribute( 'href', 'javascript:void("' + label + '");' );
}
// Restore selection and scroll position in editing area.
if ( editor.mode == 'wysiwyg' )
{
if ( savedSelection )
{
// Fixing positioning editor chrome in Firefox break design mode. (#5149)
CKEDITOR.env.gecko && refreshCursor( editor );
editor.getSelection().selectRanges(savedSelection);
var element = editor.getSelection().getStartElement();
element && element.scrollIntoView( true );
}
else
mainWindow.$.scrollTo( savedScroll.x, savedScroll.y );
}
else
{
if ( savedSelection )
{
$textarea.selectionStart = savedSelection[0];
$textarea.selectionEnd = savedSelection[1];
}
$textarea.scrollLeft = savedScroll[0];
$textarea.scrollTop = savedScroll[1];
}
savedSelection = savedScroll = null;
savedState = this.state;
},
canUndo : false
} );
editor.ui.addButton( 'Maximize',
{
label : lang.maximize,
command : 'maximize'
} );
// Restore the command state after mode change, unless it has been changed to disabled (#6467)
editor.on( 'mode', function()
{
var command = editor.getCommand( 'maximize' );
command.setState( command.state == CKEDITOR.TRISTATE_DISABLED ? CKEDITOR.TRISTATE_DISABLED : savedState );
}, null, null, 100 );
}
} );
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
CKEDITOR.on( 'dialogDefinition', function( ev )
{
var tab, name = ev.data.name,
definition = ev.data.definition;
if ( name == 'link' )
{
definition.removeContents( 'target' );
definition.removeContents( 'upload' );
definition.removeContents( 'advanced' );
tab = definition.getContents( 'info' );
tab.remove( 'emailSubject' );
tab.remove( 'emailBody' );
}
else if ( name == 'image' )
{
definition.removeContents( 'advanced' );
tab = definition.getContents( 'Link' );
tab.remove( 'cmbTarget' );
tab = definition.getContents( 'info' );
tab.remove( 'txtAlt' );
tab.remove( 'basic' );
}
});
var bbcodeMap = { 'b' : 'strong', 'u': 'u', 'i' : 'em', 'color' : 'span', 'size' : 'span', 'quote' : 'blockquote', 'code' : 'code', 'url' : 'a', 'email' : 'span', 'img' : 'span', '*' : 'li', 'list' : 'ol' },
convertMap = { 'strong' : 'b' , 'b' : 'b', 'u': 'u', 'em' : 'i', 'i': 'i', 'code' : 'code', 'li' : '*' },
tagnameMap = { 'strong' : 'b', 'em' : 'i', 'u' : 'u', 'li' : '*', 'ul' : 'list', 'ol' : 'list', 'code' : 'code', 'a' : 'link', 'img' : 'img', 'blockquote' : 'quote' },
stylesMap = { 'color' : 'color', 'size' : 'font-size' },
attributesMap = { 'url' : 'href', 'email' : 'mailhref', 'quote': 'cite', 'list' : 'listType' };
// List of block-like tags.
var dtd = CKEDITOR.dtd,
blockLikeTags = CKEDITOR.tools.extend( { table:1 }, dtd.$block, dtd.$listItem, dtd.$tableContent, dtd.$list );
var semicolonFixRegex = /\s*(?:;\s*|$)/;
function serializeStyleText( stylesObject )
{
var styleText = '';
for ( var style in stylesObject )
{
var styleVal = stylesObject[ style ],
text = ( style + ':' + styleVal ).replace( semicolonFixRegex, ';' );
styleText += text;
}
return styleText;
}
function parseStyleText( styleText )
{
var retval = {};
( styleText || '' )
.replace( /"/g, '"' )
.replace( /\s*([^ :;]+)\s*:\s*([^;]+)\s*(?=;|$)/g, function( match, name, value )
{
retval[ name.toLowerCase() ] = value;
} );
return retval;
}
function RGBToHex( cssStyle )
{
return cssStyle.replace( /(?:rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\))/gi, function( match, red, green, blue )
{
red = parseInt( red, 10 ).toString( 16 );
green = parseInt( green, 10 ).toString( 16 );
blue = parseInt( blue, 10 ).toString( 16 );
var color = [red, green, blue] ;
// Add padding zeros if the hex value is less than 0x10.
for ( var i = 0 ; i < color.length ; i++ )
color[i] = String( '0' + color[i] ).slice( -2 ) ;
return '#' + color.join( '' ) ;
});
}
// Maintain the map of smiley-to-description.
var smileyMap = {"smiley":":)","sad":":(","wink":";)","laugh":":D","cheeky":":P","blush":":*)","surprise":":-o","indecision":":|","angry":">:(","angel":"o:)","cool":"8-)","devil":">:-)","crying":";(","kiss":":-*" },
smileyReverseMap = {},
smileyRegExp = [];
// Build regexp for the list of smiley text.
for ( var i in smileyMap )
{
smileyReverseMap[ smileyMap[ i ] ] = i;
smileyRegExp.push( smileyMap[ i ].replace( /\(|\)|\:|\/|\*|\-|\|/g, function( match ) { return '\\' + match; } ) );
}
smileyRegExp = new RegExp( smileyRegExp.join( '|' ), 'g' );
var decodeHtml = ( function ()
{
var regex = [],
entities =
{
nbsp : '\u00A0', // IE | FF
shy : '\u00AD', // IE
gt : '\u003E', // IE | FF | -- | Opera
lt : '\u003C' // IE | FF | Safari | Opera
};
for ( var entity in entities )
regex.push( entity );
regex = new RegExp( '&(' + regex.join( '|' ) + ');', 'g' );
return function( html )
{
return html.replace( regex, function( match, entity )
{
return entities[ entity ];
});
};
})();
CKEDITOR.BBCodeParser = function()
{
this._ =
{
bbcPartsRegex : /(?:\[([^\/\]=]*?)(?:=([^\]]*?))?\])|(?:\[\/([a-z]{1,16})\])/ig
};
};
CKEDITOR.BBCodeParser.prototype =
{
parse : function( bbcode )
{
var parts,
part,
lastIndex = 0;
while ( ( parts = this._.bbcPartsRegex.exec( bbcode ) ) )
{
var tagIndex = parts.index;
if ( tagIndex > lastIndex )
{
var text = bbcode.substring( lastIndex, tagIndex );
this.onText( text, 1 );
}
lastIndex = this._.bbcPartsRegex.lastIndex;
/*
"parts" is an array with the following items:
0 : The entire match for opening/closing tags and line-break;
1 : line-break;
2 : open of tag excludes option;
3 : tag option;
4 : close of tag;
*/
part = ( parts[ 1 ] || parts[ 3 ] || '' ).toLowerCase();
// Unrecognized tags should be delivered as a simple text (#7860).
if ( part && !bbcodeMap[ part ] )
{
this.onText( parts[ 0 ] );
continue;
}
// Opening tag
if ( parts[ 1 ] )
{
var tagName = bbcodeMap[ part ],
attribs = {},
styles = {},
optionPart = parts[ 2 ];
if ( optionPart )
{
if ( part == 'list' )
{
if ( !isNaN( optionPart ) )
optionPart = 'decimal';
else if ( /^[a-z]+$/.test( optionPart ) )
optionPart = 'lower-alpha';
else if ( /^[A-Z]+$/.test( optionPart ) )
optionPart = 'upper-alpha';
}
if ( stylesMap[ part ] )
{
// Font size represents percentage.
if ( part == 'size' )
optionPart += '%';
styles[ stylesMap[ part ] ] = optionPart;
attribs.style = serializeStyleText( styles );
}
else if ( attributesMap[ part ] )
attribs[ attributesMap[ part ] ] = optionPart;
}
// Two special handling - image and email, protect them
// as "span" with an attribute marker.
if ( part == 'email' || part == 'img' )
attribs[ 'bbcode' ] = part;
this.onTagOpen( tagName, attribs, CKEDITOR.dtd.$empty[ tagName ] );
}
// Closing tag
else if ( parts[ 3 ] )
this.onTagClose( bbcodeMap[ part ] );
}
if ( bbcode.length > lastIndex )
this.onText( bbcode.substring( lastIndex, bbcode.length ), 1 );
}
};
/**
* Creates a {@link CKEDITOR.htmlParser.fragment} from an HTML string.
* @param {String} source The HTML to be parsed, filling the fragment.
* @param {Number} [fixForBody=false] Wrap body with specified element if needed.
* @returns CKEDITOR.htmlParser.fragment The fragment created.
* @example
* var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<b>Sample</b> Text' );
* alert( fragment.children[0].name ); "b"
* alert( fragment.children[1].value ); " Text"
*/
CKEDITOR.htmlParser.fragment.fromBBCode = function( source )
{
var parser = new CKEDITOR.BBCodeParser(),
fragment = new CKEDITOR.htmlParser.fragment(),
pendingInline = [],
pendingBrs = 0,
currentNode = fragment,
returnPoint;
function checkPending( newTagName )
{
if ( pendingInline.length > 0 )
{
for ( var i = 0 ; i < pendingInline.length ; i++ )
{
var pendingElement = pendingInline[ i ],
pendingName = pendingElement.name,
pendingDtd = CKEDITOR.dtd[ pendingName ],
currentDtd = currentNode.name && CKEDITOR.dtd[ currentNode.name ];
if ( ( !currentDtd || currentDtd[ pendingName ] ) && ( !newTagName || !pendingDtd || pendingDtd[ newTagName ] || !CKEDITOR.dtd[ newTagName ] ) )
{
// Get a clone for the pending element.
pendingElement = pendingElement.clone();
// Add it to the current node and make it the current,
// so the new element will be added inside of it.
pendingElement.parent = currentNode;
currentNode = pendingElement;
// Remove the pending element (back the index by one
// to properly process the next entry).
pendingInline.splice( i, 1 );
i--;
}
}
}
}
function checkPendingBrs( tagName, closing )
{
var len = currentNode.children.length,
previous = len > 0 && currentNode.children[ len - 1 ],
lineBreakParent = !previous && BBCodeWriter.getRule( tagnameMap[ currentNode.name ], 'breakAfterOpen' ),
lineBreakPrevious = previous && previous.type == CKEDITOR.NODE_ELEMENT && BBCodeWriter.getRule( tagnameMap[ previous.name ], 'breakAfterClose' ),
lineBreakCurrent = tagName && BBCodeWriter.getRule( tagnameMap[ tagName ], closing ? 'breakBeforeClose' : 'breakBeforeOpen' );
if ( pendingBrs && ( lineBreakParent || lineBreakPrevious || lineBreakCurrent ) )
pendingBrs--;
// 1. Either we're at the end of block, where it requires us to compensate the br filler
// removing logic (from htmldataprocessor).
// 2. Or we're at the end of pseudo block, where it requires us to compensate
// the bogus br effect.
if ( pendingBrs && tagName in blockLikeTags )
pendingBrs++;
while ( pendingBrs && pendingBrs-- )
currentNode.children.push( previous = new CKEDITOR.htmlParser.element( 'br' ) );
}
function addElement( node, target )
{
checkPendingBrs( node.name, 1 );
target = target || currentNode || fragment;
var len = target.children.length,
previous = len > 0 && target.children[ len - 1 ] || null;
node.previous = previous;
node.parent = target;
target.children.push( node );
if ( node.returnPoint )
{
currentNode = node.returnPoint;
delete node.returnPoint;
}
}
parser.onTagOpen = function( tagName, attributes, selfClosing )
{
var element = new CKEDITOR.htmlParser.element( tagName, attributes );
// This is a tag to be removed if empty, so do not add it immediately.
if ( CKEDITOR.dtd.$removeEmpty[ tagName ] )
{
pendingInline.push( element );
return;
}
var currentName = currentNode.name;
var currentDtd = currentName
&& ( CKEDITOR.dtd[ currentName ]
|| ( currentNode._.isBlockLike ? CKEDITOR.dtd.div : CKEDITOR.dtd.span ) );
// If the element cannot be child of the current element.
if ( currentDtd && !currentDtd[ tagName ] )
{
var reApply = false,
addPoint; // New position to start adding nodes.
// If the element name is the same as the current element name,
// then just close the current one and append the new one to the
// parent. This situation usually happens with <p>, <li>, <dt> and
// <dd>, specially in IE. Do not enter in this if block in this case.
if ( tagName == currentName )
addElement( currentNode, currentNode.parent );
else if ( tagName in CKEDITOR.dtd.$listItem )
{
parser.onTagOpen( 'ul', {} );
addPoint = currentNode;
reApply = true;
}
else
{
addElement( currentNode, currentNode.parent );
// 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 );
checkPendingBrs( tagName );
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;
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 );
}
};
parser.onText = function( text )
{
var currentDtd = CKEDITOR.dtd[ currentNode.name ];
if ( !currentDtd || currentDtd[ '#' ] )
{
checkPendingBrs();
checkPending();
text.replace(/([\r\n])|[^\r\n]*/g, function( piece, lineBreak )
{
if ( lineBreak !== undefined && lineBreak.length )
pendingBrs++;
else if ( piece.length )
{
var lastIndex = 0;
// Create smiley from text emotion.
piece.replace( smileyRegExp, function( match, index )
{
addElement( new CKEDITOR.htmlParser.text( piece.substring( lastIndex, index ) ), currentNode );
addElement( new CKEDITOR.htmlParser.element( 'smiley', { 'desc': smileyReverseMap[ match ] } ), currentNode );
lastIndex = index + match.length;
});
if ( lastIndex != piece.length )
addElement( new CKEDITOR.htmlParser.text( piece.substring( lastIndex, piece.length ) ), currentNode );
}
});
}
};
// Parse it.
parser.parse( CKEDITOR.tools.htmlEncode( source ) );
// Close all hanging nodes.
while ( currentNode.type )
{
var parent = currentNode.parent,
node = currentNode;
addElement( node, parent );
currentNode = parent;
}
return fragment;
};
CKEDITOR.htmlParser.BBCodeWriter = CKEDITOR.tools.createClass(
{
$ : function()
{
this._ =
{
output : [],
rules : []
};
// List and list item.
this.setRules( 'list',
{
breakBeforeOpen : 1,
breakAfterOpen : 1,
breakBeforeClose : 1,
breakAfterClose : 1
} );
this.setRules( '*',
{
breakBeforeOpen : 1,
breakAfterOpen : 0,
breakBeforeClose : 1,
breakAfterClose : 0
} );
this.setRules( 'quote',
{
breakBeforeOpen : 1,
breakAfterOpen : 0,
breakBeforeClose : 0,
breakAfterClose : 1
} );
},
proto :
{
/**
* Sets formatting rules for a given tag. The possible rules are:
* <ul>
* <li><b>breakBeforeOpen</b>: break line before the opener tag for this element.</li>
* <li><b>breakAfterOpen</b>: break line after the opener tag for this element.</li>
* <li><b>breakBeforeClose</b>: break line before the closer tag for this element.</li>
* <li><b>breakAfterClose</b>: break line after the closer tag for this element.</li>
* </ul>
*
* All rules default to "false". Each call to the function overrides
* already present rules, leaving the undefined untouched.
*
* @param {String} tagName The tag name to which set the rules.
* @param {Object} rules An object containing the element rules.
* @example
* // Break line before and after "img" tags.
* writer.setRules( 'list',
* {
* breakBeforeOpen : true
* breakAfterOpen : true
* });
*/
setRules : function( tagName, rules )
{
var currentRules = this._.rules[ tagName ];
if ( currentRules )
CKEDITOR.tools.extend( currentRules, rules, true );
else
this._.rules[ tagName ] = rules;
},
getRule : function( tagName, ruleName )
{
return this._.rules[ tagName ] && this._.rules[ tagName ][ ruleName ];
},
openTag : function( tag, attributes )
{
if ( tag in bbcodeMap )
{
if ( this.getRule( tag, 'breakBeforeOpen' ) )
this.lineBreak( 1 );
this.write( '[', tag );
var option = attributes.option;
option && this.write( '=', option );
this.write( ']' );
if ( this.getRule( tag, 'breakAfterOpen' ) )
this.lineBreak( 1 );
}
else if ( tag == 'br' )
this._.output.push( '\n' );
},
openTagClose : function() { },
attribute : function() { },
closeTag : function( tag )
{
if ( tag in bbcodeMap )
{
if ( this.getRule( tag, 'breakBeforeClose' ) )
this.lineBreak( 1 );
tag != '*' && this.write( '[/', tag, ']' );
if ( this.getRule( tag, 'breakAfterClose' ) )
this.lineBreak( 1 );
}
},
text : function( text )
{
this.write( text );
},
/**
* Writes a comment.
* @param {String} comment The comment text.
* @example
* // Writes "<!-- My comment -->".
* writer.comment( ' My comment ' );
*/
comment : function() {},
/*
* Output line-break for formatting.
*/
lineBreak : function()
{
// Avoid line break when:
// 1) Previous tag already put one.
// 2) We're at output start.
if ( !this._.hasLineBreak && this._.output.length )
{
this.write( '\n' );
this._.hasLineBreak = 1;
}
},
write : function()
{
this._.hasLineBreak = 0;
var data = Array.prototype.join.call( arguments, '' );
this._.output.push( data );
},
reset : function()
{
this._.output = [];
this._.hasLineBreak = 0;
},
getHtml : function( reset )
{
var bbcode = this._.output.join( '' );
if ( reset )
this.reset();
return decodeHtml ( bbcode );
}
}
});
var BBCodeWriter = new CKEDITOR.htmlParser.BBCodeWriter();
CKEDITOR.plugins.add( 'bbcode',
{
requires : [ 'htmldataprocessor', 'entities' ],
beforeInit : function( editor )
{
// Adapt some critical editor configuration for better support
// of BBCode environment.
var config = editor.config;
CKEDITOR.tools.extend( config,
{
enterMode : CKEDITOR.ENTER_BR,
basicEntities: false,
entities : false,
fillEmptyBlocks : false
}, true );
},
init : function( editor )
{
var config = editor.config;
function BBCodeToHtml( code )
{
var fragment = CKEDITOR.htmlParser.fragment.fromBBCode( code ),
writer = new CKEDITOR.htmlParser.basicWriter();
fragment.writeHtml( writer, dataFilter );
return writer.getHtml( true );
}
var dataFilter = new CKEDITOR.htmlParser.filter();
dataFilter.addRules(
{
elements :
{
'blockquote' : function( element )
{
var quoted = new CKEDITOR.htmlParser.element( 'div' );
quoted.children = element.children;
element.children = [ quoted ];
var citeText = element.attributes.cite;
if ( citeText )
{
var cite = new CKEDITOR.htmlParser.element( 'cite' );
cite.add( new CKEDITOR.htmlParser.text( citeText.replace( /^"|"$/g, '' ) ) );
delete element.attributes.cite;
element.children.unshift( cite );
}
},
'span' : function( element )
{
var bbcode;
if ( ( bbcode = element.attributes.bbcode ) )
{
if ( bbcode == 'img' )
{
element.name = 'img';
element.attributes.src = element.children[ 0 ].value;
element.children = [];
}
else if ( bbcode == 'email' )
{
element.name = 'a';
element.attributes.href = 'mailto:' + element.children[ 0 ].value;
}
delete element.attributes.bbcode;
}
},
'ol' : function ( element )
{
if ( element.attributes.listType )
{
if ( element.attributes.listType != 'decimal' )
element.attributes.style = 'list-style-type:' + element.attributes.listType;
}
else
element.name = 'ul';
delete element.attributes.listType;
},
a : function( element )
{
if ( !element.attributes.href )
element.attributes.href = element.children[ 0 ].value;
},
'smiley' : function( element )
{
element.name = 'img';
var description = element.attributes.desc,
image = config.smiley_images[ CKEDITOR.tools.indexOf( config.smiley_descriptions, description ) ],
src = CKEDITOR.tools.htmlEncode( config.smiley_path + image );
element.attributes =
{
src : src,
'data-cke-saved-src' : src,
title : description,
alt : description
};
}
}
} );
editor.dataProcessor.htmlFilter.addRules(
{
elements :
{
$ : function( element )
{
var attributes = element.attributes,
style = parseStyleText( attributes.style ),
value;
var tagName = element.name;
if ( tagName in convertMap )
tagName = convertMap[ tagName ];
else if ( tagName == 'span' )
{
if ( ( value = style.color ) )
{
tagName = 'color';
value = RGBToHex( value );
}
else if ( ( value = style[ 'font-size' ] ) )
{
var percentValue = value.match( /(\d+)%$/ );
if ( percentValue )
{
value = percentValue[ 1 ];
tagName = 'size';
}
}
}
else if ( tagName == 'ol' || tagName == 'ul' )
{
if ( ( value = style[ 'list-style-type'] ) )
{
switch ( value )
{
case 'lower-alpha':
value = 'a';
break;
case 'upper-alpha':
value = 'A';
break;
}
}
else if ( tagName == 'ol' )
value = 1;
tagName = 'list';
}
else if ( tagName == 'blockquote' )
{
try
{
var cite = element.children[ 0 ],
quoted = element.children[ 1 ],
citeText = cite.name == 'cite' && cite.children[ 0 ].value;
if ( citeText )
{
value = '"' + citeText + '"';
element.children = quoted.children;
}
}
catch( er )
{
}
tagName = 'quote';
}
else if ( tagName == 'a' )
{
if ( ( value = attributes.href ) )
{
if ( value.indexOf( 'mailto:' ) !== -1 )
{
tagName = 'email';
// [email] should have a single text child with email address.
element.children = [ new CKEDITOR.htmlParser.text( value.replace( 'mailto:', '' ) ) ];
value = '';
}
else
{
var singleton = element.children.length == 1 && element.children[ 0 ];
if ( singleton
&& singleton.type == CKEDITOR.NODE_TEXT
&& singleton.value == value )
value = '';
tagName = 'url';
}
}
}
else if ( tagName == 'img' )
{
element.isEmpty = 0;
// Translate smiley (image) to text emotion.
var src = attributes[ 'data-cke-saved-src' ];
if ( src && src.indexOf( editor.config.smiley_path ) != -1 )
return new CKEDITOR.htmlParser.text( smileyMap[ attributes.alt ] );
else
element.children = [ new CKEDITOR.htmlParser.text( src ) ];
}
element.name = tagName;
value && ( element.attributes.option = value );
return null;
},
// Remove any bogus br from the end of a pseudo block,
// e.g. <div>some text<br /><p>paragraph</p></div>
br : function( element )
{
var next = element.next;
if ( next && next.name in blockLikeTags )
return false;
}
}
}, 1 );
editor.dataProcessor.writer = BBCodeWriter;
editor.on( 'beforeSetMode', function( evt )
{
evt.removeListener();
var wysiwyg = editor._.modes[ 'wysiwyg' ];
wysiwyg.loadData = CKEDITOR.tools.override( wysiwyg.loadData, function( org )
{
return function( data )
{
return ( org.call( this, BBCodeToHtml( data ) ) );
};
} );
} );
},
afterInit : function( editor )
{
var filters;
if ( editor._.elementsPath )
{
// Eliminate irrelevant elements from displaying, e.g body and p.
if ( ( filters = editor._.elementsPath.filters ) )
filters.push( function( element )
{
var htmlName = element.getName(),
name = tagnameMap[ htmlName ] || false;
// Specialized anchor presents as email.
if ( name == 'link' && element.getAttribute( 'href' ).indexOf( 'mailto:' ) === 0 )
name = 'email';
// Styled span could be either size or color.
else if ( htmlName == 'span' )
{
if ( element.getStyle( 'font-size' ) )
name = 'size';
else if ( element.getStyle( 'color' ) )
name = 'color';
}
else if ( name == 'img' )
{
var src = element.data( 'cke-saved-src' );
if ( src && src.indexOf( editor.config.smiley_path ) === 0 )
name = 'smiley';
}
return name;
});
}
}
} );
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'button',
{
beforeInit : function( editor )
{
editor.ui.addHandler( CKEDITOR.UI_BUTTON, CKEDITOR.ui.button.handler );
}
});
/**
* Button UI element.
* @constant
* @example
*/
CKEDITOR.UI_BUTTON = 'button';
/**
* Represents a button UI element. This class should not be called directly. To
* create new buttons use {@link CKEDITOR.ui.prototype.addButton} instead.
* @constructor
* @param {Object} definition The button definition.
* @example
*/
CKEDITOR.ui.button = function( definition )
{
// Copy all definition properties to this object.
CKEDITOR.tools.extend( this, definition,
// Set defaults.
{
title : definition.label,
className : definition.className || ( definition.command && 'cke_button_' + definition.command ) || '',
click : definition.click || function( editor )
{
editor.execCommand( definition.command );
}
});
this._ = {};
};
/**
* Transforms a button definition in a {@link CKEDITOR.ui.button} instance.
* @type Object
* @example
*/
CKEDITOR.ui.button.handler =
{
create : function( definition )
{
return new CKEDITOR.ui.button( definition );
}
};
( function()
{
CKEDITOR.ui.button.prototype =
{
/**
* Renders the button.
* @param {CKEDITOR.editor} editor The editor instance which this button is
* to be used by.
* @param {Array} output The output array to which append the HTML relative
* to this button.
* @example
*/
render : function( editor, output )
{
var env = CKEDITOR.env,
id = this._.id = CKEDITOR.tools.getNextId(),
classes = '',
command = this.command, // Get the command name.
clickFn;
this._.editor = editor;
var instance =
{
id : id,
button : this,
editor : editor,
focus : function()
{
var element = CKEDITOR.document.getById( id );
element.focus();
},
execute : function()
{
// IE 6 needs some time before execution (#7922)
if ( CKEDITOR.env.ie && CKEDITOR.env.version < 7 )
CKEDITOR.tools.setTimeout( function(){ this.button.click( editor ); }, 0, this );
else
this.button.click( editor );
}
};
var keydownFn = CKEDITOR.tools.addFunction( function( ev )
{
if ( instance.onkey )
{
ev = new CKEDITOR.dom.event( ev );
return ( instance.onkey( instance, ev.getKeystroke() ) !== false );
}
});
var focusFn = CKEDITOR.tools.addFunction( function( ev )
{
var retVal;
if ( instance.onfocus )
retVal = ( instance.onfocus( instance, new CKEDITOR.dom.event( ev ) ) !== false );
// FF2: prevent focus event been bubbled up to editor container, which caused unexpected editor focus.
if ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 )
ev.preventBubble();
return retVal;
});
instance.clickFn = clickFn = CKEDITOR.tools.addFunction( instance.execute, instance );
// Indicate a mode sensitive button.
if ( this.modes )
{
var modeStates = {};
function updateState()
{
// "this" is a CKEDITOR.ui.button instance.
var mode = editor.mode;
if ( mode )
{
// Restore saved button state.
var state = this.modes[ mode ] ? modeStates[ mode ] != undefined ? modeStates[ mode ] :
CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED;
this.setState( editor.readOnly && !this.readOnly ? CKEDITOR.TRISTATE_DISABLED : state );
}
}
editor.on( 'beforeModeUnload', function()
{
if ( editor.mode && this._.state != CKEDITOR.TRISTATE_DISABLED )
modeStates[ editor.mode ] = this._.state;
}, this );
editor.on( 'mode', updateState, this);
// If this button is sensitive to readOnly state, update it accordingly.
!this.readOnly && editor.on( 'readOnly', updateState, this);
}
else if ( command )
{
// Get the command instance.
command = editor.getCommand( command );
if ( command )
{
command.on( 'state', function()
{
this.setState( command.state );
}, this);
classes += 'cke_' + (
command.state == CKEDITOR.TRISTATE_ON ? 'on' :
command.state == CKEDITOR.TRISTATE_DISABLED ? 'disabled' :
'off' );
}
}
if ( !command )
classes += 'cke_off';
if ( this.className )
classes += ' ' + this.className;
output.push(
'<span class="cke_button' + ( this.icon && this.icon.indexOf( '.png' ) == -1 ? ' cke_noalphafix' : '' ) + '">',
'<a id="', id, '"' +
' class="', classes, '"',
env.gecko && env.version >= 10900 && !env.hc ? '' : '" href="javascript:void(\''+ ( this.title || '' ).replace( "'", '' )+ '\')"',
' title="', this.title, '"' +
' tabindex="-1"' +
' hidefocus="true"' +
' role="button"' +
' aria-labelledby="' + id + '_label"' +
( this.hasArrow ? ' aria-haspopup="true"' : '' ) );
// Some browsers don't cancel key events in the keydown but in the
// keypress.
// TODO: Check if really needed for Gecko+Mac.
if ( env.opera || ( env.gecko && env.mac ) )
{
output.push(
' onkeypress="return false;"' );
}
// With Firefox, we need to force the button to redraw, otherwise it
// will remain in the focus state.
if ( env.gecko )
{
output.push(
' onblur="this.style.cssText = this.style.cssText;"' );
}
output.push(
' onkeydown="return CKEDITOR.tools.callFunction(', keydownFn, ', event);"' +
' onfocus="return CKEDITOR.tools.callFunction(', focusFn,', event);" ' +
( CKEDITOR.env.ie ? 'onclick="return false;" onmouseup' : 'onclick' ) + // #188
'="CKEDITOR.tools.callFunction(', clickFn, ', this); return false;">' +
'<span class="cke_icon"' );
if ( this.icon )
{
var offset = ( this.iconOffset || 0 ) * -16;
output.push( ' style="background-image:url(', CKEDITOR.getUrl( this.icon ), ');background-position:0 ' + offset + 'px;"' );
}
output.push(
'> </span>' +
'<span id="', id, '_label" class="cke_label">', this.label, '</span>' );
if ( this.hasArrow )
{
output.push(
'<span class="cke_buttonarrow">'
// BLACK DOWN-POINTING TRIANGLE
+ ( CKEDITOR.env.hc ? '▼' : ' ' )
+ '</span>' );
}
output.push(
'</a>',
'</span>' );
if ( this.onRender )
this.onRender();
return instance;
},
setState : function( state )
{
if ( this._.state == state )
return false;
this._.state = state;
var element = CKEDITOR.document.getById( this._.id );
if ( element )
{
element.setState( state );
state == CKEDITOR.TRISTATE_DISABLED ?
element.setAttribute( 'aria-disabled', true ) :
element.removeAttribute( 'aria-disabled' );
state == CKEDITOR.TRISTATE_ON ?
element.setAttribute( 'aria-pressed', true ) :
element.removeAttribute( 'aria-pressed' );
return true;
}
else
return false;
}
};
})();
/**
* Adds a button definition to the UI elements list.
* @param {String} name The button name.
* @param {Object} definition The button definition.
* @example
* editorInstance.ui.addButton( 'MyBold',
* {
* label : 'My Bold',
* command : 'bold'
* });
*/
CKEDITOR.ui.prototype.addButton = function( name, definition )
{
this.add( name, CKEDITOR.UI_BUTTON, definition );
};
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'devtools',
{
lang : [ 'en', 'bg', 'cs', 'cy', 'da', 'de', 'el', 'eo', 'et', 'fa', 'fi', 'fr', 'gu', 'he', 'hr', 'it', 'nb', 'nl', 'no', 'pl', 'pt-br', 'tr', 'ug', 'uk', 'vi', 'zh-cn' ],
init : function( editor )
{
editor._.showDialogDefinitionTooltips = 1;
},
onLoad : function()
{
CKEDITOR.document.appendStyleText( CKEDITOR.config.devtools_styles ||
'#cke_tooltip { padding: 5px; border: 2px solid #333; background: #ffffff }' +
'#cke_tooltip h2 { font-size: 1.1em; border-bottom: 1px solid; margin: 0; padding: 1px; }' +
'#cke_tooltip ul { padding: 0pt; list-style-type: none; }' );
}
});
(function()
{
function defaultCallback( editor, dialog, element, tabName )
{
var lang = editor.lang.devTools,
link = '<a href="http://docs.cksource.com/ckeditor_api/symbols/CKEDITOR.dialog.definition.' +
( element ? ( element.type == 'text' ? 'textInput' : element.type ) : 'content' ) +
'.html" target="_blank">' + ( element ? element.type : 'content' ) + '</a>',
str =
'<h2>' + lang.title + '</h2>' +
'<ul>' +
'<li><strong>' + lang.dialogName + '</strong> : ' + dialog.getName() + '</li>' +
'<li><strong>' + lang.tabName + '</strong> : ' + tabName + '</li>';
if ( element )
str += '<li><strong>' + lang.elementId + '</strong> : ' + element.id + '</li>';
str += '<li><strong>' + lang.elementType + '</strong> : ' + link + '</li>';
return str + '</ul>';
}
function showTooltip( callback, el, editor, dialog, obj, tabName )
{
var pos = el.getDocumentPosition(),
styles = { 'z-index' : CKEDITOR.dialog._.currentZIndex + 10, top : ( pos.y + el.getSize( 'height' ) ) + 'px' };
tooltip.setHtml( callback( editor, dialog, obj, tabName ) );
tooltip.show();
// Translate coordinate for RTL.
if ( editor.lang.dir == 'rtl' )
{
var viewPaneSize = CKEDITOR.document.getWindow().getViewPaneSize();
styles.right = ( viewPaneSize.width - pos.x - el.getSize( 'width' ) ) + 'px';
}
else
styles.left = pos.x + 'px';
tooltip.setStyles( styles );
}
var tooltip;
CKEDITOR.on( 'reset', function()
{
tooltip && tooltip.remove();
tooltip = null;
});
CKEDITOR.on( 'dialogDefinition', function( evt )
{
var editor = evt.editor;
if ( editor._.showDialogDefinitionTooltips )
{
if ( !tooltip )
{
tooltip = CKEDITOR.dom.element.createFromHtml( '<div id="cke_tooltip" tabindex="-1" style="position: absolute"></div>', CKEDITOR.document );
tooltip.hide();
tooltip.on( 'mouseover', function(){ this.show(); } );
tooltip.on( 'mouseout', function(){ this.hide(); } );
tooltip.appendTo( CKEDITOR.document.getBody() );
}
var dialog = evt.data.definition.dialog,
callback = editor.config.devtools_textCallback || defaultCallback;
dialog.on( 'load', function()
{
var tabs = dialog.parts.tabs.getChildren(), tab;
for ( var i = 0, len = tabs.count(); i < len; i++ )
{
tab = tabs.getItem( i );
tab.on( 'mouseover', function()
{
var id = this.$.id;
showTooltip( callback, this, editor, dialog, null, id.substring( 4, id.lastIndexOf( '_' ) ) );
});
tab.on( 'mouseout', function()
{
tooltip.hide();
});
}
dialog.foreach( function( obj )
{
if ( obj.type in { hbox : 1, vbox : 1 } )
return;
var el = obj.getElement();
if ( el )
{
el.on( 'mouseover', function()
{
showTooltip( callback, this, editor, dialog, obj, dialog._.currentTabId );
});
el.on( 'mouseout', function()
{
tooltip.hide();
});
}
});
});
}
});
})();
/**
* A function that returns the text to be displayed inside the Developer Tools tooltip when hovering over a dialog UI element.
* There are 4 parameters that are being passed into the function: editor, dialog window, element, tab name.
* @name editor.config.devtools_textCallback
* @since 3.6
* @type Function
* @default (see example)
* @example
* // This is actually the default value.
* // Show dialog window name, tab ID, and element ID.
* config.devtools_textCallback = function( editor, dialog, element, tabName )
* {
* var lang = editor.lang.devTools,
* link = '<a href="http://docs.cksource.com/ckeditor_api/symbols/CKEDITOR.dialog.definition.' +
* ( element ? ( element.type == 'text' ? 'textInput' : element.type ) : 'content' ) +
* '.html" target="_blank">' + ( element ? element.type : 'content' ) + '</a>',
* str =
* '<h2>' + lang.title + '</h2>' +
* '<ul>' +
* '<li><strong>' + lang.dialogName + '</strong> : ' + dialog.getName() + '</li>' +
* '<li><strong>' + lang.tabName + '</strong> : ' + tabName + '</li>';
*
* if ( element )
* str += '<li><strong>' + lang.elementId + '</strong> : ' + element.id + '</li>';
*
* str += '<li><strong>' + lang.elementType + '</strong> : ' + link + '</li>';
*
* return str + '</ul>';
* }
*/
/**
* A setting that stores CSS rules to be injected into the page with styles to be applied to the tooltip element.
* @name CKEDITOR.config.devtools_styles
* @since 3.6
* @type String
* @default (see example)
* @example
* // This is actually the default value.
* CKEDITOR.config.devtools_styles = "
* #cke_tooltip { padding: 5px; border: 2px solid #333; background: #ffffff }
* #cke_tooltip h2 { font-size: 1.1em; border-bottom: 1px solid; margin: 0; padding: 1px; }
* #cke_tooltip ul { padding: 0pt; list-style-type: none; }
* ";
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'nl',
{
devTools :
{
title : 'Elementinformatie',
dialogName : 'Naam dialoogvenster',
tabName : 'Tabnaam',
elementId : 'Element ID',
elementType : 'Elementtype'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'ug',
{
devTools :
{
title : 'ئېلېمېنت ئۇچۇرى',
dialogName : 'سۆزلەشكۈ كۆزنەك ئاتى',
tabName : 'Tab ئاتى',
elementId : 'ئېلېمېنت كىملىكى',
elementType : 'ئېلېمېنت تىپى'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'it',
{
devTools :
{
title : 'Informazioni elemento',
dialogName : 'Nome finestra di dialogo',
tabName : 'Nome Tab',
elementId : 'ID Elemento',
elementType : 'Tipo elemento'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'de',
{
devTools :
{
title : 'Elementinformation',
dialogName : 'Dialogfenstername',
tabName : 'Reitername',
elementId : 'Element ID',
elementType : 'Elementtyp'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'pl',
{
devTools :
{
title : 'Informacja o elemencie',
dialogName : 'Nazwa okna dialogowego',
tabName : 'Nazwa zakładki',
elementId : 'ID elementu',
elementType : 'Typ elementu'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'vi',
{
devTools :
{
title : 'Thông tin thành ph',
dialogName : 'Tên hộp tho',
tabName : 'Tên th',
elementId : 'Mã thành ph',
elementType : 'Loại thành ph'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'hr',
{
devTools :
{
title : 'Informacije elementa',
dialogName : 'Naziv prozora za dijalog',
tabName : 'Naziva jahača',
elementId : 'ID elementa',
elementType : 'Vrsta elementa'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'tr',
{
devTools :
{
title : 'Eleman Bilgisi',
dialogName : 'İletişim pencere ismi',
tabName : 'Sekme adı',
elementId : 'Eleman ID',
elementType : 'Eleman türü'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'fr',
{
devTools :
{
title : 'Information sur l\'élément',
dialogName : 'Nom de la fenêtre de dialogue',
tabName : 'Nom de l\'onglet',
elementId : 'ID de l\'élément',
elementType : 'Type de l\'élément'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'zh-cn',
{
devTools :
{
title : '元素信息',
dialogName : '对话框窗口名称',
tabName : 'Tab 名称',
elementId : '元素 ID',
elementType : '元素类型'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'eo',
{
devTools :
{
title : 'Informo pri la elemento',
dialogName : 'Nomo de la dialogfenestro',
tabName : 'Langetnomo',
elementId : 'ID de la elemento',
elementType : 'Tipo de la elemento'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'en',
{
devTools :
{
title : 'Element Information',
dialogName : 'Dialog window name',
tabName : 'Tab name',
elementId : 'Element ID',
elementType : 'Element type'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'da',
{
devTools :
{
title : 'Information på elementet',
dialogName : 'Dialogboks',
tabName : 'Tab beskrivelse',
elementId : 'ID på element',
elementType : 'Type af element'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'nb',
{
devTools :
{
title : 'Elementinformasjon',
dialogName : 'Navn på dialogvindu',
tabName : 'Navn på fane',
elementId : 'Element-ID',
elementType : 'Elementtype'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'bg',
{
devTools :
{
title : 'Информация за елемента',
dialogName : 'Име на диалоговия прозорец',
tabName : 'Име на таб',
elementId : 'ID на елемента',
elementType : 'Тип на елемента'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'el',
{
devTools :
{
title : 'Πληροφορίες Στοιχείου',
dialogName : 'Όνομα παραθύρου διαλόγου',
tabName : 'Όνομα καρτέλας',
elementId : 'ID Στοιχείου',
elementType : 'Τύπος στοιχείου'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'fi',
{
devTools :
{
title : 'Elementin tiedot',
dialogName : 'Dialogi-ikkunan nimi',
tabName : 'Välilehden nimi',
elementId : 'Elementin ID',
elementType : 'Elementin tyyppi'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'cy',
{
devTools :
{
title : 'Gwybodaeth am yr Elfen',
dialogName : 'Enw ffenestr y deialog',
tabName : 'Enw\'r tab',
elementId : 'ID yr Elfen',
elementType : 'Math yr elfen'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'no',
{
devTools :
{
title : 'Elementinformasjon',
dialogName : 'Navn på dialogvindu',
tabName : 'Navn på fane',
elementId : 'Element-ID',
elementType : 'Elementtype'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'fa',
{
devTools :
{
title : 'اطلاعات عنصر',
dialogName : 'نام پنجره محاورهای',
tabName : 'نام برگه',
elementId : 'ID عنصر',
elementType : 'نوع عنصر'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'et',
{
devTools :
{
title : 'Elemendi andmed',
dialogName : 'Dialoogiakna nimi',
tabName : 'Saki nimi',
elementId : 'Elemendi ID',
elementType : 'Elemendi liik'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'he',
{
devTools :
{
title : 'מידע על האלמנט',
dialogName : 'שם הדיאלוג',
tabName : 'שם הטאב',
elementId : 'ID של האלמנט',
elementType : 'סוג האלמנט'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'uk',
{
devTools :
{
title : 'Відомості про Елемент',
dialogName : 'Заголовок діалогового вікна',
tabName : 'Назва вкладки',
elementId : 'Ідентифікатор Елемента',
elementType : 'Тип Елемента'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'cs',
{
devTools :
{
title : 'Informace o prvku',
dialogName : 'Název dialogového okna',
tabName : 'Název karty',
elementId : 'ID prvku',
elementType : 'Typ prvku'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'pt-br',
{
devTools :
{
title : 'Informação do Elemento',
dialogName : 'Nome da janela de diálogo',
tabName : 'Nome da aba',
elementId : 'ID do elemento',
elementType : 'Tipo do elemento'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'devtools', 'gu',
{
devTools :
{
title : 'પ્રાથમિક માહિતી',
dialogName : 'વિન્ડોનું નામ',
tabName : 'ટેબનું નામ',
elementId : 'પ્રાથમિક આઈડી',
elementType : 'પ્રાથમિક પ્રકાર'
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileSave plugin.
*/
(function()
{
var saveCmd =
{
modes : { wysiwyg:1, source:1 },
readOnly : 1,
exec : function( editor )
{
var $form = editor.element.$.form;
if ( $form )
{
try
{
$form.submit();
}
catch( e )
{
// If there's a button named "submit" then the form.submit
// function is masked and can't be called in IE/FF, so we
// call the click() method of that button.
if ( $form.submit.click )
$form.submit.click();
}
}
}
};
var pluginName = 'save';
// Register a plugin named "save".
CKEDITOR.plugins.add( pluginName,
{
init : function( editor )
{
var command = editor.addCommand( pluginName, saveCmd );
command.modes = { wysiwyg : !!( editor.element.$.form ) };
editor.ui.addButton( 'Save',
{
label : editor.lang.save,
command : pluginName
});
}
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview Plugin for making iframe based dialogs.
*/
CKEDITOR.plugins.add( 'iframedialog',
{
requires : [ 'dialog' ],
onLoad : function()
{
/**
* An iframe base dialog.
* @param {String} name Name of the dialog
* @param {String} title Title of the dialog
* @param {Number} minWidth Minimum width of the dialog
* @param {Number} minHeight Minimum height of the dialog
* @param {Function} [onContentLoad] Function called when the iframe has been loaded.
* If it isn't specified, the inner frame is notified of the dialog events ('load',
* 'resize', 'ok' and 'cancel') on a function called 'onDialogEvent'
* @param {Object} [userDefinition] Additional properties for the dialog definition
* @example
*/
CKEDITOR.dialog.addIframe = function( name, title, src, minWidth, minHeight, onContentLoad, userDefinition )
{
var element =
{
type : 'iframe',
src : src,
width : '100%',
height : '100%'
};
if ( typeof( onContentLoad ) == 'function' )
element.onContentLoad = onContentLoad;
else
element.onContentLoad = function()
{
var element = this.getElement(),
childWindow = element.$.contentWindow;
// If the inner frame has defined a "onDialogEvent" function, setup listeners
if ( childWindow.onDialogEvent )
{
var dialog = this.getDialog(),
notifyEvent = function(e)
{
return childWindow.onDialogEvent(e);
};
dialog.on( 'ok', notifyEvent );
dialog.on( 'cancel', notifyEvent );
dialog.on( 'resize', notifyEvent );
// Clear listeners
dialog.on( 'hide', function(e)
{
dialog.removeListener( 'ok', notifyEvent );
dialog.removeListener( 'cancel', notifyEvent );
dialog.removeListener( 'resize', notifyEvent );
e.removeListener();
} );
// Notify child iframe of load:
childWindow.onDialogEvent( {
name : 'load',
sender : this,
editor : dialog._.editor
} );
}
};
var definition =
{
title : title,
minWidth : minWidth,
minHeight : minHeight,
contents :
[
{
id : 'iframe',
label : title,
expand : true,
elements : [ element ]
}
]
};
for ( var i in userDefinition )
definition[i] = userDefinition[i];
this.add( name, function(){ return definition; } );
};
(function()
{
/**
* An iframe element.
* @extends CKEDITOR.ui.dialog.uiElement
* @example
* @constructor
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>src</strong> (Required) The src field of the iframe. </li>
* <li><strong>width</strong> (Required) The iframe's width.</li>
* <li><strong>height</strong> (Required) The iframe's height.</li>
* <li><strong>onContentLoad</strong> (Optional) A function to be executed
* after the iframe's contents has finished loading.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
var iframeElement = function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
var _ = ( this._ || ( this._ = {} ) ),
contentLoad = elementDefinition.onContentLoad && CKEDITOR.tools.bind( elementDefinition.onContentLoad, this ),
cssWidth = CKEDITOR.tools.cssLength( elementDefinition.width ),
cssHeight = CKEDITOR.tools.cssLength( elementDefinition.height );
_.frameId = CKEDITOR.tools.getNextId() + '_iframe';
// IE BUG: Parent container does not resize to contain the iframe automatically.
dialog.on( 'load', function()
{
var iframe = CKEDITOR.document.getById( _.frameId ),
parentContainer = iframe.getParent();
parentContainer.setStyles(
{
width : cssWidth,
height : cssHeight
} );
} );
var attributes =
{
src : '%2',
id : _.frameId,
frameborder : 0,
allowtransparency : true
};
var myHtml = [];
if ( typeof( elementDefinition.onContentLoad ) == 'function' )
attributes.onload = 'CKEDITOR.tools.callFunction(%1);';
CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, myHtml, 'iframe',
{
width : cssWidth,
height : cssHeight
}, attributes, '' );
// Put a placeholder for the first time.
htmlList.push( '<div style="width:' + cssWidth + ';height:' + cssHeight + ';" id="' + this.domId + '"></div>' );
// Iframe elements should be refreshed whenever it is shown.
myHtml = myHtml.join( '' );
dialog.on( 'show', function()
{
var iframe = CKEDITOR.document.getById( _.frameId ),
parentContainer = iframe.getParent(),
callIndex = CKEDITOR.tools.addFunction( contentLoad ),
html = myHtml.replace( '%1', callIndex ).replace( '%2', CKEDITOR.tools.htmlEncode( elementDefinition.src ) );
parentContainer.setHtml( html );
} );
};
iframeElement.prototype = new CKEDITOR.ui.dialog.uiElement;
CKEDITOR.dialog.addUIElement( 'iframe',
{
build : function( dialog, elementDefinition, output )
{
return new iframeElement( dialog, elementDefinition, output );
}
} );
})();
}
} );
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'panel',
{
beforeInit : function( editor )
{
editor.ui.addHandler( CKEDITOR.UI_PANEL, CKEDITOR.ui.panel.handler );
}
});
/**
* Panel UI element.
* @constant
* @example
*/
CKEDITOR.UI_PANEL = 'panel';
CKEDITOR.ui.panel = function( document, definition )
{
// Copy all definition properties to this object.
if ( definition )
CKEDITOR.tools.extend( this, definition );
// Set defaults.
CKEDITOR.tools.extend( this,
{
className : '',
css : []
});
this.id = CKEDITOR.tools.getNextId();
this.document = document;
this._ =
{
blocks : {}
};
};
/**
* Transforms a rich combo definition in a {@link CKEDITOR.ui.richCombo}
* instance.
* @type Object
* @example
*/
CKEDITOR.ui.panel.handler =
{
create : function( definition )
{
return new CKEDITOR.ui.panel( definition );
}
};
CKEDITOR.ui.panel.prototype =
{
renderHtml : function( editor )
{
var output = [];
this.render( editor, output );
return output.join( '' );
},
/**
* Renders the combo.
* @param {CKEDITOR.editor} editor The editor instance which this button is
* to be used by.
* @param {Array} output The output array to which append the HTML relative
* to this button.
* @example
*/
render : function( editor, output )
{
var id = this.id;
output.push(
'<div class="', editor.skinClass ,'"' +
' lang="', editor.langCode, '"' +
' role="presentation"' +
// iframe loading need sometime, keep the panel hidden(#4186).
' style="display:none;z-index:' + ( editor.config.baseFloatZIndex + 1 ) + '">' +
'<div' +
' id=', id,
' dir=', editor.lang.dir,
' role="presentation"' +
' class="cke_panel cke_', editor.lang.dir );
if ( this.className )
output.push( ' ', this.className );
output.push(
'">' );
if ( this.forceIFrame || this.css.length )
{
output.push(
'<iframe id="', id, '_frame"' +
' frameborder="0"' +
' role="application" src="javascript:void(' );
output.push(
// Support for custom document.domain in IE.
CKEDITOR.env.isCustomDomain() ?
'(function(){' +
'document.open();' +
'document.domain=\'' + document.domain + '\';' +
'document.close();' +
'})()'
:
'0' );
output.push(
')"></iframe>' );
}
output.push(
'</div>' +
'</div>' );
return id;
},
getHolderElement : function()
{
var holder = this._.holder;
if ( !holder )
{
if ( this.forceIFrame || this.css.length )
{
var iframe = this.document.getById( this.id + '_frame' ),
parentDiv = iframe.getParent(),
dir = parentDiv.getAttribute( 'dir' ),
className = parentDiv.getParent().getAttribute( 'class' ),
langCode = parentDiv.getParent().getAttribute( 'lang' ),
doc = iframe.getFrameDocument();
// Make it scrollable on iOS. (#8308)
CKEDITOR.env.iOS && parentDiv.setStyles(
{
'overflow' : 'scroll',
'-webkit-overflow-scrolling' : 'touch'
});
var onLoad = CKEDITOR.tools.addFunction( CKEDITOR.tools.bind( function( ev )
{
this.isLoaded = true;
if ( this.onLoad )
this.onLoad();
}, this ) );
var data =
'<!DOCTYPE html>' +
'<html dir="' + dir + '" class="' + className + '_container" lang="' + langCode + '">' +
'<head>' +
'<style>.' + className + '_container{visibility:hidden}</style>' +
CKEDITOR.tools.buildStyleHtml( this.css ) +
'</head>' +
'<body class="cke_' + dir + ' cke_panel_frame ' + CKEDITOR.env.cssClass + '" style="margin:0;padding:0"' +
' onload="( window.CKEDITOR || window.parent.CKEDITOR ).tools.callFunction(' + onLoad + ');"></body>' +
'<\/html>';
doc.write( data );
var win = doc.getWindow();
// Register the CKEDITOR global.
win.$.CKEDITOR = CKEDITOR;
// Arrow keys for scrolling is only preventable with 'keypress' event in Opera (#4534).
doc.on( 'key' + ( CKEDITOR.env.opera? 'press':'down' ), function( evt )
{
var keystroke = evt.data.getKeystroke(),
dir = this.document.getById( this.id ).getAttribute( 'dir' );
// Delegate key processing to block.
if ( this._.onKeyDown && this._.onKeyDown( keystroke ) === false )
{
evt.data.preventDefault();
return;
}
// ESC/ARROW-LEFT(ltr) OR ARROW-RIGHT(rtl)
if ( keystroke == 27 || keystroke == ( dir == 'rtl' ? 39 : 37 ) )
{
if ( this.onEscape && this.onEscape( keystroke ) === false )
evt.data.preventDefault();
}
},
this );
holder = doc.getBody();
holder.unselectable();
CKEDITOR.env.air && CKEDITOR.tools.callFunction( onLoad );
}
else
holder = this.document.getById( this.id );
this._.holder = holder;
}
return holder;
},
addBlock : function( name, block )
{
block = this._.blocks[ name ] = block instanceof CKEDITOR.ui.panel.block ? block
: new CKEDITOR.ui.panel.block( this.getHolderElement(), block );
if ( !this._.currentBlock )
this.showBlock( name );
return block;
},
getBlock : function( name )
{
return this._.blocks[ name ];
},
showBlock : function( name )
{
var blocks = this._.blocks,
block = blocks[ name ],
current = this._.currentBlock;
// ARIA role works better in IE on the body element, while on the iframe
// for FF. (#8864)
var holder = !this.forceIFrame || CKEDITOR.env.ie ?
this._.holder : this.document.getById( this.id + '_frame' );
if ( current )
{
// Clean up the current block's effects on holder.
holder.removeAttributes( current.attributes );
current.hide();
}
this._.currentBlock = block;
holder.setAttributes( block.attributes );
CKEDITOR.fire( 'ariaWidget', holder );
// Reset the focus index, so it will always go into the first one.
block._.focusIndex = -1;
this._.onKeyDown = block.onKeyDown && CKEDITOR.tools.bind( block.onKeyDown, block );
block.show();
return block;
},
destroy : function()
{
this.element && this.element.remove();
}
};
CKEDITOR.ui.panel.block = CKEDITOR.tools.createClass(
{
$ : function( blockHolder, blockDefinition )
{
this.element = blockHolder.append(
blockHolder.getDocument().createElement( 'div',
{
attributes :
{
'tabIndex' : -1,
'class' : 'cke_panel_block',
'role' : 'presentation'
},
styles :
{
display : 'none'
}
}) );
// Copy all definition properties to this object.
if ( blockDefinition )
CKEDITOR.tools.extend( this, blockDefinition );
if ( !this.attributes.title )
this.attributes.title = this.attributes[ 'aria-label' ];
this.keys = {};
this._.focusIndex = -1;
// Disable context menu for panels.
this.element.disableContextMenu();
},
_ : {
/**
* Mark the item specified by the index as current activated.
*/
markItem: function( index )
{
if ( index == -1 )
return;
var links = this.element.getElementsByTag( 'a' );
var item = links.getItem( this._.focusIndex = index );
// Safari need focus on the iframe window first(#3389), but we need
// lock the blur to avoid hiding the panel.
if ( CKEDITOR.env.webkit || CKEDITOR.env.opera )
item.getDocument().getWindow().focus();
item.focus();
this.onMark && this.onMark( item );
}
},
proto :
{
show : function()
{
this.element.setStyle( 'display', '' );
},
hide : function()
{
if ( !this.onHide || this.onHide.call( this ) !== true )
this.element.setStyle( 'display', 'none' );
},
onKeyDown : function( keystroke )
{
var keyAction = this.keys[ keystroke ];
switch ( keyAction )
{
// Move forward.
case 'next' :
var index = this._.focusIndex,
links = this.element.getElementsByTag( 'a' ),
link;
while ( ( link = links.getItem( ++index ) ) )
{
// Move the focus only if the element is marked with
// the _cke_focus and it it's visible (check if it has
// width).
if ( link.getAttribute( '_cke_focus' ) && link.$.offsetWidth )
{
this._.focusIndex = index;
link.focus();
break;
}
}
return false;
// Move backward.
case 'prev' :
index = this._.focusIndex;
links = this.element.getElementsByTag( 'a' );
while ( index > 0 && ( link = links.getItem( --index ) ) )
{
// Move the focus only if the element is marked with
// the _cke_focus and it it's visible (check if it has
// width).
if ( link.getAttribute( '_cke_focus' ) && link.$.offsetWidth )
{
this._.focusIndex = index;
link.focus();
break;
}
}
return false;
case 'click' :
case 'mouseup' :
index = this._.focusIndex;
link = index >= 0 && this.element.getElementsByTag( 'a' ).getItem( index );
if ( link )
link.$[ keyAction ] ? link.$[ keyAction ]() : link.$[ 'on' + keyAction ]();
return false;
}
return true;
}
}
});
/**
* Fired when a panel is added to the document
* @name CKEDITOR#ariaWidget
* @event
* @param {Object} holder The element wrapping the panel
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
CKEDITOR.plugins.add( 'iframe',
{
requires : [ 'dialog', 'fakeobjects' ],
init : function( editor )
{
var pluginName = 'iframe',
lang = editor.lang.iframe;
CKEDITOR.dialog.add( pluginName, this.path + 'dialogs/iframe.js' );
editor.addCommand( pluginName, new CKEDITOR.dialogCommand( pluginName ) );
editor.addCss(
'img.cke_iframe' +
'{' +
'background-image: url(' + CKEDITOR.getUrl( this.path + 'images/placeholder.png' ) + ');' +
'background-position: center center;' +
'background-repeat: no-repeat;' +
'border: 1px solid #a9a9a9;' +
'width: 80px;' +
'height: 80px;' +
'}'
);
editor.ui.addButton( 'Iframe',
{
label : lang.toolbar,
command : pluginName
});
editor.on( 'doubleclick', function( evt )
{
var element = evt.data.element;
if ( element.is( 'img' ) && element.data( 'cke-real-element-type' ) == 'iframe' )
evt.data.dialog = 'iframe';
});
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
iframe :
{
label : lang.title,
command : 'iframe',
group : 'image'
}
});
}
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( element && element.is( 'img' ) && element.data( 'cke-real-element-type' ) == 'iframe' )
return { iframe : CKEDITOR.TRISTATE_OFF };
});
}
},
afterInit : function( editor )
{
var dataProcessor = editor.dataProcessor,
dataFilter = dataProcessor && dataProcessor.dataFilter;
if ( dataFilter )
{
dataFilter.addRules(
{
elements :
{
iframe : function( element )
{
return editor.createFakeParserElement( element, 'cke_iframe', 'iframe', true );
}
}
});
}
}
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
// Map 'true' and 'false' values to match W3C's specifications
// http://www.w3.org/TR/REC-html40/present/frames.html#h-16.5
var checkboxValues =
{
scrolling : { 'true' : 'yes', 'false' : 'no' },
frameborder : { 'true' : '1', 'false' : '0' }
};
function loadValue( iframeNode )
{
var isCheckbox = this instanceof CKEDITOR.ui.dialog.checkbox;
if ( iframeNode.hasAttribute( this.id ) )
{
var value = iframeNode.getAttribute( this.id );
if ( isCheckbox )
this.setValue( checkboxValues[ this.id ][ 'true' ] == value.toLowerCase() );
else
this.setValue( value );
}
}
function commitValue( iframeNode )
{
var isRemove = this.getValue() === '',
isCheckbox = this instanceof CKEDITOR.ui.dialog.checkbox,
value = this.getValue();
if ( isRemove )
iframeNode.removeAttribute( this.att || this.id );
else if ( isCheckbox )
iframeNode.setAttribute( this.id, checkboxValues[ this.id ][ value ] );
else
iframeNode.setAttribute( this.att || this.id, value );
}
CKEDITOR.dialog.add( 'iframe', function( editor )
{
var iframeLang = editor.lang.iframe,
commonLang = editor.lang.common,
dialogadvtab = editor.plugins.dialogadvtab;
return {
title : iframeLang.title,
minWidth : 350,
minHeight : 260,
onShow : function()
{
// Clear previously saved elements.
this.fakeImage = this.iframeNode = null;
var fakeImage = this.getSelectedElement();
if ( fakeImage && fakeImage.data( 'cke-real-element-type' ) && fakeImage.data( 'cke-real-element-type' ) == 'iframe' )
{
this.fakeImage = fakeImage;
var iframeNode = editor.restoreRealElement( fakeImage );
this.iframeNode = iframeNode;
this.setupContent( iframeNode );
}
},
onOk : function()
{
var iframeNode;
if ( !this.fakeImage )
iframeNode = new CKEDITOR.dom.element( 'iframe' );
else
iframeNode = this.iframeNode;
// A subset of the specified attributes/styles
// should also be applied on the fake element to
// have better visual effect. (#5240)
var extraStyles = {}, extraAttributes = {};
this.commitContent( iframeNode, extraStyles, extraAttributes );
// Refresh the fake image.
var newFakeImage = editor.createFakeElement( iframeNode, 'cke_iframe', 'iframe', true );
newFakeImage.setAttributes( extraAttributes );
newFakeImage.setStyles( extraStyles );
if ( this.fakeImage )
{
newFakeImage.replace( this.fakeImage );
editor.getSelection().selectElement( newFakeImage );
}
else
editor.insertElement( newFakeImage );
},
contents : [
{
id : 'info',
label : commonLang.generalTab,
accessKey : 'I',
elements :
[
{
type : 'vbox',
padding : 0,
children :
[
{
id : 'src',
type : 'text',
label : commonLang.url,
required : true,
validate : CKEDITOR.dialog.validate.notEmpty( iframeLang.noUrl ),
setup : loadValue,
commit : commitValue
}
]
},
{
type : 'hbox',
children :
[
{
id : 'width',
type : 'text',
style : 'width:100%',
labelLayout : 'vertical',
label : commonLang.width,
validate : CKEDITOR.dialog.validate.htmlLength( commonLang.invalidHtmlLength.replace( '%1', commonLang.width ) ),
setup : loadValue,
commit : commitValue
},
{
id : 'height',
type : 'text',
style : 'width:100%',
labelLayout : 'vertical',
label : commonLang.height,
validate : CKEDITOR.dialog.validate.htmlLength( commonLang.invalidHtmlLength.replace( '%1', commonLang.height ) ),
setup : loadValue,
commit : commitValue
},
{
id : 'align',
type : 'select',
'default' : '',
items :
[
[ commonLang.notSet , '' ],
[ commonLang.alignLeft , 'left' ],
[ commonLang.alignRight , 'right' ],
[ commonLang.alignTop , 'top' ],
[ commonLang.alignMiddle , 'middle' ],
[ commonLang.alignBottom , 'bottom' ]
],
style : 'width:100%',
labelLayout : 'vertical',
label : commonLang.align,
setup : function( iframeNode, fakeImage )
{
loadValue.apply( this, arguments );
if ( fakeImage )
{
var fakeImageAlign = fakeImage.getAttribute( 'align' );
this.setValue( fakeImageAlign && fakeImageAlign.toLowerCase() || '' );
}
},
commit : function( iframeNode, extraStyles, extraAttributes )
{
commitValue.apply( this, arguments );
if ( this.getValue() )
extraAttributes.align = this.getValue();
}
}
]
},
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
id : 'scrolling',
type : 'checkbox',
label : iframeLang.scrolling,
setup : loadValue,
commit : commitValue
},
{
id : 'frameborder',
type : 'checkbox',
label : iframeLang.border,
setup : loadValue,
commit : commitValue
}
]
},
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
id : 'name',
type : 'text',
label : commonLang.name,
setup : loadValue,
commit : commitValue
},
{
id : 'title',
type : 'text',
label : commonLang.advisoryTitle,
setup : loadValue,
commit : commitValue
}
]
},
{
id : 'longdesc',
type : 'text',
label : commonLang.longDescr,
setup : loadValue,
commit : commitValue
}
]
},
dialogadvtab && dialogadvtab.createAdvancedTab( editor, { id:1, classes:1, styles:1 })
]
};
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
CKEDITOR.plugins.liststyle =
{
requires : [ 'dialog' ],
init : function( editor )
{
editor.addCommand( 'numberedListStyle', new CKEDITOR.dialogCommand( 'numberedListStyle' ) );
CKEDITOR.dialog.add( 'numberedListStyle', this.path + 'dialogs/liststyle.js' );
editor.addCommand( 'bulletedListStyle', new CKEDITOR.dialogCommand( 'bulletedListStyle' ) );
CKEDITOR.dialog.add( 'bulletedListStyle', this.path + 'dialogs/liststyle.js' );
// If the "menu" plugin is loaded, register the menu items.
if ( editor.addMenuItems )
{
//Register map group;
editor.addMenuGroup("list", 108);
editor.addMenuItems(
{
numberedlist :
{
label : editor.lang.list.numberedTitle,
group : 'list',
command: 'numberedListStyle'
},
bulletedlist :
{
label : editor.lang.list.bulletedTitle,
group : 'list',
command: 'bulletedListStyle'
}
});
}
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( !element || element.isReadOnly() )
return null;
while ( element )
{
var name = element.getName();
if ( name == 'ol' )
return { numberedlist: CKEDITOR.TRISTATE_OFF };
else if ( name == 'ul' )
return { bulletedlist: CKEDITOR.TRISTATE_OFF };
element = element.getParent();
}
return null;
});
}
}
};
CKEDITOR.plugins.add( 'liststyle', CKEDITOR.plugins.liststyle );
})();
| JavaScript |
/*
* Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
* For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
function getListElement( editor, listTag )
{
var range;
try { range = editor.getSelection().getRanges()[ 0 ]; }
catch( e ) { return null; }
range.shrink( CKEDITOR.SHRINK_TEXT );
return range.getCommonAncestor().getAscendant( listTag, 1 );
}
var listItem = function( node ) { return node.type == CKEDITOR.NODE_ELEMENT && node.is( 'li' ); };
var mapListStyle = {
'a' : 'lower-alpha',
'A' : 'upper-alpha',
'i' : 'lower-roman',
'I' : 'upper-roman',
'1' : 'decimal',
'disc' : 'disc',
'circle': 'circle',
'square' : 'square'
};
function listStyle( editor, startupPage )
{
var lang = editor.lang.list;
if ( startupPage == 'bulletedListStyle' )
{
return {
title : lang.bulletedTitle,
minWidth : 300,
minHeight : 50,
contents :
[
{
id : 'info',
accessKey : 'I',
elements :
[
{
type : 'select',
label : lang.type,
id : 'type',
align : 'center',
style : 'width:150px',
items :
[
[ lang.notset, '' ],
[ lang.circle, 'circle' ],
[ lang.disc, 'disc' ],
[ lang.square, 'square' ]
],
setup : function( element )
{
var value = element.getStyle( 'list-style-type' )
|| mapListStyle[ element.getAttribute( 'type' ) ]
|| element.getAttribute( 'type' )
|| '';
this.setValue( value );
},
commit : function( element )
{
var value = this.getValue();
if ( value )
element.setStyle( 'list-style-type', value );
else
element.removeStyle( 'list-style-type' );
}
}
]
}
],
onShow: function()
{
var editor = this.getParentEditor(),
element = getListElement( editor, 'ul' );
element && this.setupContent( element );
},
onOk: function()
{
var editor = this.getParentEditor(),
element = getListElement( editor, 'ul' );
element && this.commitContent( element );
}
};
}
else if ( startupPage == 'numberedListStyle' )
{
var listStyleOptions =
[
[ lang.notset, '' ],
[ lang.lowerRoman, 'lower-roman' ],
[ lang.upperRoman, 'upper-roman' ],
[ lang.lowerAlpha, 'lower-alpha' ],
[ lang.upperAlpha, 'upper-alpha' ],
[ lang.decimal, 'decimal' ]
];
if ( !CKEDITOR.env.ie || CKEDITOR.env.version > 7 )
{
listStyleOptions.concat( [
[ lang.armenian, 'armenian' ],
[ lang.decimalLeadingZero, 'decimal-leading-zero' ],
[ lang.georgian, 'georgian' ],
[ lang.lowerGreek, 'lower-greek' ]
]);
}
return {
title : lang.numberedTitle,
minWidth : 300,
minHeight : 50,
contents :
[
{
id : 'info',
accessKey : 'I',
elements :
[
{
type : 'hbox',
widths : [ '25%', '75%' ],
children :
[
{
label : lang.start,
type : 'text',
id : 'start',
validate : CKEDITOR.dialog.validate.integer( lang.validateStartNumber ),
setup : function( element )
{
// List item start number dominates.
var value = element.getFirst( listItem ).getAttribute( 'value' ) || element.getAttribute( 'start' ) || 1;
value && this.setValue( value );
},
commit : function( element )
{
var firstItem = element.getFirst( listItem );
var oldStart = firstItem.getAttribute( 'value' ) || element.getAttribute( 'start' ) || 1;
// Force start number on list root.
element.getFirst( listItem ).removeAttribute( 'value' );
var val = parseInt( this.getValue(), 10 );
if ( isNaN( val ) )
element.removeAttribute( 'start' );
else
element.setAttribute( 'start', val );
// Update consequent list item numbering.
var nextItem = firstItem, conseq = oldStart, startNumber = isNaN( val ) ? 1 : val;
while ( ( nextItem = nextItem.getNext( listItem ) ) && conseq++ )
{
if ( nextItem.getAttribute( 'value' ) == conseq )
nextItem.setAttribute( 'value', startNumber + conseq - oldStart );
}
}
},
{
type : 'select',
label : lang.type,
id : 'type',
style : 'width: 100%;',
items : listStyleOptions,
setup : function( element )
{
var value = element.getStyle( 'list-style-type' )
|| mapListStyle[ element.getAttribute( 'type' ) ]
|| element.getAttribute( 'type' )
|| '';
this.setValue( value );
},
commit : function( element )
{
var value = this.getValue();
if ( value )
element.setStyle( 'list-style-type', value );
else
element.removeStyle( 'list-style-type' );
}
}
]
}
]
}
],
onShow: function()
{
var editor = this.getParentEditor(),
element = getListElement( editor, 'ol' );
element && this.setupContent( element );
},
onOk: function()
{
var editor = this.getParentEditor(),
element = getListElement( editor, 'ol' );
element && this.commitContent( element );
}
};
}
}
CKEDITOR.dialog.add( 'numberedListStyle', function( editor )
{
return listStyle( editor, 'numberedListStyle' );
});
CKEDITOR.dialog.add( 'bulletedListStyle', function( editor )
{
return listStyle( editor, 'bulletedListStyle' );
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var cellNodeRegex = /^(?:td|th)$/;
function getSelectedCells( selection )
{
var ranges = selection.getRanges();
var retval = [];
var database = {};
function moveOutOfCellGuard( node )
{
// Apply to the first cell only.
if ( retval.length > 0 )
return;
// If we are exiting from the first </td>, then the td should definitely be
// included.
if ( node.type == CKEDITOR.NODE_ELEMENT && cellNodeRegex.test( node.getName() )
&& !node.getCustomData( 'selected_cell' ) )
{
CKEDITOR.dom.element.setMarker( database, node, 'selected_cell', true );
retval.push( node );
}
}
for ( var i = 0 ; i < ranges.length ; i++ )
{
var range = ranges[ i ];
if ( range.collapsed )
{
// Walker does not handle collapsed ranges yet - fall back to old API.
var startNode = range.getCommonAncestor();
var nearestCell = startNode.getAscendant( 'td', true ) || startNode.getAscendant( 'th', true );
if ( nearestCell )
retval.push( nearestCell );
}
else
{
var walker = new CKEDITOR.dom.walker( range );
var node;
walker.guard = moveOutOfCellGuard;
while ( ( node = walker.next() ) )
{
// If may be possible for us to have a range like this:
// <td>^1</td><td>^2</td>
// The 2nd td shouldn't be included.
//
// So we have to take care to include a td we've entered only when we've
// walked into its children.
var parent = node.getAscendant( 'td' ) || node.getAscendant( 'th' );
if ( parent && !parent.getCustomData( 'selected_cell' ) )
{
CKEDITOR.dom.element.setMarker( database, parent, 'selected_cell', true );
retval.push( parent );
}
}
}
}
CKEDITOR.dom.element.clearAllMarkers( database );
return retval;
}
function getFocusElementAfterDelCells( cellsToDelete ) {
var i = 0,
last = cellsToDelete.length - 1,
database = {},
cell,focusedCell,
tr;
while ( ( cell = cellsToDelete[ i++ ] ) )
CKEDITOR.dom.element.setMarker( database, cell, 'delete_cell', true );
// 1.first we check left or right side focusable cell row by row;
i = 0;
while ( ( cell = cellsToDelete[ i++ ] ) )
{
if ( ( focusedCell = cell.getPrevious() ) && !focusedCell.getCustomData( 'delete_cell' )
|| ( focusedCell = cell.getNext() ) && !focusedCell.getCustomData( 'delete_cell' ) )
{
CKEDITOR.dom.element.clearAllMarkers( database );
return focusedCell;
}
}
CKEDITOR.dom.element.clearAllMarkers( database );
// 2. then we check the toppest row (outside the selection area square) focusable cell
tr = cellsToDelete[ 0 ].getParent();
if ( ( tr = tr.getPrevious() ) )
return tr.getLast();
// 3. last we check the lowerest row focusable cell
tr = cellsToDelete[ last ].getParent();
if ( ( tr = tr.getNext() ) )
return tr.getChild( 0 );
return null;
}
function insertRow( selection, insertBefore )
{
var cells = getSelectedCells( selection ),
firstCell = cells[ 0 ],
table = firstCell.getAscendant( 'table' ),
doc = firstCell.getDocument(),
startRow = cells[ 0 ].getParent(),
startRowIndex = startRow.$.rowIndex,
lastCell = cells[ cells.length - 1 ],
endRowIndex = lastCell.getParent().$.rowIndex + lastCell.$.rowSpan - 1,
endRow = new CKEDITOR.dom.element( table.$.rows[ endRowIndex ] ),
rowIndex = insertBefore ? startRowIndex : endRowIndex,
row = insertBefore ? startRow : endRow;
var map = CKEDITOR.tools.buildTableMap( table ),
cloneRow = map[ rowIndex ],
nextRow = insertBefore ? map[ rowIndex - 1 ] : map[ rowIndex + 1 ],
width = map[0].length;
var newRow = doc.createElement( 'tr' );
for ( var i = 0; cloneRow[ i ] && i < width; i++ )
{
var cell;
// Check whether there's a spanning row here, do not break it.
if ( cloneRow[ i ].rowSpan > 1 && nextRow && cloneRow[ i ] == nextRow[ i ] )
{
cell = cloneRow[ i ];
cell.rowSpan += 1;
}
else
{
cell = new CKEDITOR.dom.element( cloneRow[ i ] ).clone();
cell.removeAttribute( 'rowSpan' );
!CKEDITOR.env.ie && cell.appendBogus();
newRow.append( cell );
cell = cell.$;
}
i += cell.colSpan - 1;
}
insertBefore ?
newRow.insertBefore( row ) :
newRow.insertAfter( row );
}
function deleteRows( selectionOrRow )
{
if ( selectionOrRow instanceof CKEDITOR.dom.selection )
{
var cells = getSelectedCells( selectionOrRow ),
firstCell = cells[ 0 ],
table = firstCell.getAscendant( 'table' ),
map = CKEDITOR.tools.buildTableMap( table ),
startRow = cells[ 0 ].getParent(),
startRowIndex = startRow.$.rowIndex,
lastCell = cells[ cells.length - 1 ],
endRowIndex = lastCell.getParent().$.rowIndex + lastCell.$.rowSpan - 1,
rowsToDelete = [];
// Delete cell or reduce cell spans by checking through the table map.
for ( var i = startRowIndex; i <= endRowIndex; i++ )
{
var mapRow = map[ i ],
row = new CKEDITOR.dom.element( table.$.rows[ i ] );
for ( var j = 0; j < mapRow.length; j++ )
{
var cell = new CKEDITOR.dom.element( mapRow[ j ] ),
cellRowIndex = cell.getParent().$.rowIndex;
if ( cell.$.rowSpan == 1 )
cell.remove();
// Row spanned cell.
else
{
// Span row of the cell, reduce spanning.
cell.$.rowSpan -= 1;
// Root row of the cell, root cell to next row.
if ( cellRowIndex == i )
{
var nextMapRow = map[ i + 1 ];
nextMapRow[ j - 1 ] ?
cell.insertAfter( new CKEDITOR.dom.element( nextMapRow[ j - 1 ] ) )
: new CKEDITOR.dom.element( table.$.rows[ i + 1 ] ).append( cell, 1 );
}
}
j += cell.$.colSpan - 1;
}
rowsToDelete.push( row );
}
var rows = table.$.rows;
// Where to put the cursor after rows been deleted?
// 1. Into next sibling row if any;
// 2. Into previous sibling row if any;
// 3. Into table's parent element if it's the very last row.
var cursorPosition = new CKEDITOR.dom.element( rows[ endRowIndex + 1 ] || ( startRowIndex > 0 ? rows[ startRowIndex - 1 ] : null ) || table.$.parentNode );
for ( i = rowsToDelete.length ; i >= 0 ; i-- )
deleteRows( rowsToDelete[ i ] );
return cursorPosition;
}
else if ( selectionOrRow instanceof CKEDITOR.dom.element )
{
table = selectionOrRow.getAscendant( 'table' );
if ( table.$.rows.length == 1 )
table.remove();
else
selectionOrRow.remove();
}
return null;
}
function getCellColIndex( cell, isStart )
{
var row = cell.getParent(),
rowCells = row.$.cells;
var colIndex = 0;
for ( var i = 0; i < rowCells.length; i++ )
{
var mapCell = rowCells[ i ];
colIndex += isStart ? 1 : mapCell.colSpan;
if ( mapCell == cell.$ )
break;
}
return colIndex -1;
}
function getColumnsIndices( cells, isStart )
{
var retval = isStart ? Infinity : 0;
for ( var i = 0; i < cells.length; i++ )
{
var colIndex = getCellColIndex( cells[ i ], isStart );
if ( isStart ? colIndex < retval : colIndex > retval )
retval = colIndex;
}
return retval;
}
function insertColumn( selection, insertBefore )
{
var cells = getSelectedCells( selection ),
firstCell = cells[ 0 ],
table = firstCell.getAscendant( 'table' ),
startCol = getColumnsIndices( cells, 1 ),
lastCol = getColumnsIndices( cells ),
colIndex = insertBefore? startCol : lastCol;
var map = CKEDITOR.tools.buildTableMap( table ),
cloneCol = [],
nextCol = [],
height = map.length;
for ( var i = 0; i < height; i++ )
{
cloneCol.push( map[ i ][ colIndex ] );
var nextCell = insertBefore ? map[ i ][ colIndex - 1 ] : map[ i ][ colIndex + 1 ];
nextCell && nextCol.push( nextCell );
}
for ( i = 0; i < height; i++ )
{
var cell;
// Check whether there's a spanning column here, do not break it.
if ( cloneCol[ i ].colSpan > 1
&& nextCol.length
&& nextCol[ i ] == cloneCol[ i ] )
{
cell = cloneCol[ i ];
cell.colSpan += 1;
}
else
{
cell = new CKEDITOR.dom.element( cloneCol[ i ] ).clone();
cell.removeAttribute( 'colSpan' );
!CKEDITOR.env.ie && cell.appendBogus();
cell[ insertBefore? 'insertBefore' : 'insertAfter' ].call( cell, new CKEDITOR.dom.element ( cloneCol[ i ] ) );
cell = cell.$;
}
i += cell.rowSpan - 1;
}
}
function deleteColumns( selectionOrCell )
{
var cells = getSelectedCells( selectionOrCell ),
firstCell = cells[ 0 ],
lastCell = cells[ cells.length - 1 ],
table = firstCell.getAscendant( 'table' ),
map = CKEDITOR.tools.buildTableMap( table ),
startColIndex,
endColIndex,
rowsToDelete = [];
// Figure out selected cells' column indices.
for ( var i = 0, rows = map.length; i < rows; i++ )
{
for ( var j = 0, cols = map[ i ].length; j < cols; j++ )
{
if ( map[ i ][ j ] == firstCell.$ )
startColIndex = j;
if ( map[ i ][ j ] == lastCell.$ )
endColIndex = j;
}
}
// Delete cell or reduce cell spans by checking through the table map.
for ( i = startColIndex; i <= endColIndex; i++ )
{
for ( j = 0; j < map.length; j++ )
{
var mapRow = map[ j ],
row = new CKEDITOR.dom.element( table.$.rows[ j ] ),
cell = new CKEDITOR.dom.element( mapRow[ i ] );
if ( cell.$ )
{
if ( cell.$.colSpan == 1 )
cell.remove();
// Reduce the col spans.
else
cell.$.colSpan -= 1;
j += cell.$.rowSpan - 1;
if ( !row.$.cells.length )
rowsToDelete.push( row );
}
}
}
var firstRowCells = table.$.rows[ 0 ] && table.$.rows[ 0 ].cells;
// Where to put the cursor after columns been deleted?
// 1. Into next cell of the first row if any;
// 2. Into previous cell of the first row if any;
// 3. Into table's parent element;
var cursorPosition = new CKEDITOR.dom.element( firstRowCells[ startColIndex ] || ( startColIndex ? firstRowCells[ startColIndex - 1 ] : table.$.parentNode ) );
// Delete table rows only if all columns are gone (do not remove empty row).
if ( rowsToDelete.length == rows )
table.remove();
return cursorPosition;
}
function getFocusElementAfterDelCols( cells )
{
var cellIndexList = [],
table = cells[ 0 ] && cells[ 0 ].getAscendant( 'table' ),
i, length,
targetIndex, targetCell;
// get the cellIndex list of delete cells
for ( i = 0, length = cells.length; i < length; i++ )
cellIndexList.push( cells[i].$.cellIndex );
// get the focusable column index
cellIndexList.sort();
for ( i = 1, length = cellIndexList.length; i < length; i++ )
{
if ( cellIndexList[ i ] - cellIndexList[ i - 1 ] > 1 )
{
targetIndex = cellIndexList[ i - 1 ] + 1;
break;
}
}
if ( !targetIndex )
targetIndex = cellIndexList[ 0 ] > 0 ? ( cellIndexList[ 0 ] - 1 )
: ( cellIndexList[ cellIndexList.length - 1 ] + 1 );
// scan row by row to get the target cell
var rows = table.$.rows;
for ( i = 0, length = rows.length; i < length ; i++ )
{
targetCell = rows[ i ].cells[ targetIndex ];
if ( targetCell )
break;
}
return targetCell ? new CKEDITOR.dom.element( targetCell ) : table.getPrevious();
}
function insertCell( selection, insertBefore )
{
var startElement = selection.getStartElement();
var cell = startElement.getAscendant( 'td', 1 ) || startElement.getAscendant( 'th', 1 );
if ( !cell )
return;
// Create the new cell element to be added.
var newCell = cell.clone();
if ( !CKEDITOR.env.ie )
newCell.appendBogus();
if ( insertBefore )
newCell.insertBefore( cell );
else
newCell.insertAfter( cell );
}
function deleteCells( selectionOrCell )
{
if ( selectionOrCell instanceof CKEDITOR.dom.selection )
{
var cellsToDelete = getSelectedCells( selectionOrCell );
var table = cellsToDelete[ 0 ] && cellsToDelete[ 0 ].getAscendant( 'table' );
var cellToFocus = getFocusElementAfterDelCells( cellsToDelete );
for ( var i = cellsToDelete.length - 1 ; i >= 0 ; i-- )
deleteCells( cellsToDelete[ i ] );
if ( cellToFocus )
placeCursorInCell( cellToFocus, true );
else if ( table )
table.remove();
}
else if ( selectionOrCell instanceof CKEDITOR.dom.element )
{
var tr = selectionOrCell.getParent();
if ( tr.getChildCount() == 1 )
tr.remove();
else
selectionOrCell.remove();
}
}
// Remove filler at end and empty spaces around the cell content.
function trimCell( cell )
{
var bogus = cell.getBogus();
bogus && bogus.remove();
cell.trim();
}
function placeCursorInCell( cell, placeAtEnd )
{
var range = new CKEDITOR.dom.range( cell.getDocument() );
if ( !range[ 'moveToElementEdit' + ( placeAtEnd ? 'End' : 'Start' ) ]( cell ) )
{
range.selectNodeContents( cell );
range.collapse( placeAtEnd ? false : true );
}
range.select( true );
}
function cellInRow( tableMap, rowIndex, cell )
{
var oRow = tableMap[ rowIndex ];
if ( typeof cell == 'undefined' )
return oRow;
for ( var c = 0 ; oRow && c < oRow.length ; c++ )
{
if ( cell.is && oRow[c] == cell.$ )
return c;
else if ( c == cell )
return new CKEDITOR.dom.element( oRow[ c ] );
}
return cell.is ? -1 : null;
}
function cellInCol( tableMap, colIndex )
{
var oCol = [];
for ( var r = 0; r < tableMap.length; r++ )
{
var row = tableMap[ r ];
oCol.push( row[ colIndex ] );
// Avoid adding duplicate cells.
if ( row[ colIndex ].rowSpan > 1 )
r += row[ colIndex ].rowSpan - 1;
}
return oCol;
}
function mergeCells( selection, mergeDirection, isDetect )
{
var cells = getSelectedCells( selection );
// Invalid merge request if:
// 1. In batch mode despite that less than two selected.
// 2. In solo mode while not exactly only one selected.
// 3. Cells distributed in different table groups (e.g. from both thead and tbody).
var commonAncestor;
if ( ( mergeDirection ? cells.length != 1 : cells.length < 2 )
|| ( commonAncestor = selection.getCommonAncestor() )
&& commonAncestor.type == CKEDITOR.NODE_ELEMENT
&& commonAncestor.is( 'table' ) )
{
return false;
}
var cell,
firstCell = cells[ 0 ],
table = firstCell.getAscendant( 'table' ),
map = CKEDITOR.tools.buildTableMap( table ),
mapHeight = map.length,
mapWidth = map[ 0 ].length,
startRow = firstCell.getParent().$.rowIndex,
startColumn = cellInRow( map, startRow, firstCell );
if ( mergeDirection )
{
var targetCell;
try
{
var rowspan = parseInt( firstCell.getAttribute( 'rowspan' ), 10 ) || 1;
var colspan = parseInt( firstCell.getAttribute( 'colspan' ), 10 ) || 1;
targetCell =
map[ mergeDirection == 'up' ?
( startRow - rowspan ):
mergeDirection == 'down' ? ( startRow + rowspan ) : startRow ] [
mergeDirection == 'left' ?
( startColumn - colspan ):
mergeDirection == 'right' ? ( startColumn + colspan ) : startColumn ];
}
catch( er )
{
return false;
}
// 1. No cell could be merged.
// 2. Same cell actually.
if ( !targetCell || firstCell.$ == targetCell )
return false;
// Sort in map order regardless of the DOM sequence.
cells[ ( mergeDirection == 'up' || mergeDirection == 'left' ) ?
'unshift' : 'push' ]( new CKEDITOR.dom.element( targetCell ) );
}
// Start from here are merging way ignorance (merge up/right, batch merge).
var doc = firstCell.getDocument(),
lastRowIndex = startRow,
totalRowSpan = 0,
totalColSpan = 0,
// Use a documentFragment as buffer when appending cell contents.
frag = !isDetect && new CKEDITOR.dom.documentFragment( doc ),
dimension = 0;
for ( var i = 0; i < cells.length; i++ )
{
cell = cells[ i ];
var tr = cell.getParent(),
cellFirstChild = cell.getFirst(),
colSpan = cell.$.colSpan,
rowSpan = cell.$.rowSpan,
rowIndex = tr.$.rowIndex,
colIndex = cellInRow( map, rowIndex, cell );
// Accumulated the actual places taken by all selected cells.
dimension += colSpan * rowSpan;
// Accumulated the maximum virtual spans from column and row.
totalColSpan = Math.max( totalColSpan, colIndex - startColumn + colSpan ) ;
totalRowSpan = Math.max( totalRowSpan, rowIndex - startRow + rowSpan );
if ( !isDetect )
{
// Trim all cell fillers and check to remove empty cells.
if ( trimCell( cell ), cell.getChildren().count() )
{
// Merge vertically cells as two separated paragraphs.
if ( rowIndex != lastRowIndex
&& cellFirstChild
&& !( cellFirstChild.isBlockBoundary
&& cellFirstChild.isBlockBoundary( { br : 1 } ) ) )
{
var last = frag.getLast( CKEDITOR.dom.walker.whitespaces( true ) );
if ( last && !( last.is && last.is( 'br' ) ) )
frag.append( 'br' );
}
cell.moveChildren( frag );
}
i ? cell.remove() : cell.setHtml( '' );
}
lastRowIndex = rowIndex;
}
if ( !isDetect )
{
frag.moveChildren( firstCell );
if ( !CKEDITOR.env.ie )
firstCell.appendBogus();
if ( totalColSpan >= mapWidth )
firstCell.removeAttribute( 'rowSpan' );
else
firstCell.$.rowSpan = totalRowSpan;
if ( totalRowSpan >= mapHeight )
firstCell.removeAttribute( 'colSpan' );
else
firstCell.$.colSpan = totalColSpan;
// Swip empty <tr> left at the end of table due to the merging.
var trs = new CKEDITOR.dom.nodeList( table.$.rows ),
count = trs.count();
for ( i = count - 1; i >= 0; i-- )
{
var tailTr = trs.getItem( i );
if ( !tailTr.$.cells.length )
{
tailTr.remove();
count++;
continue;
}
}
return firstCell;
}
// Be able to merge cells only if actual dimension of selected
// cells equals to the caculated rectangle.
else
return ( totalRowSpan * totalColSpan ) == dimension;
}
function verticalSplitCell ( selection, isDetect )
{
var cells = getSelectedCells( selection );
if ( cells.length > 1 )
return false;
else if ( isDetect )
return true;
var cell = cells[ 0 ],
tr = cell.getParent(),
table = tr.getAscendant( 'table' ),
map = CKEDITOR.tools.buildTableMap( table ),
rowIndex = tr.$.rowIndex,
colIndex = cellInRow( map, rowIndex, cell ),
rowSpan = cell.$.rowSpan,
newCell,
newRowSpan,
newCellRowSpan,
newRowIndex;
if ( rowSpan > 1 )
{
newRowSpan = Math.ceil( rowSpan / 2 );
newCellRowSpan = Math.floor( rowSpan / 2 );
newRowIndex = rowIndex + newRowSpan;
var newCellTr = new CKEDITOR.dom.element( table.$.rows[ newRowIndex ] ),
newCellRow = cellInRow( map, newRowIndex ),
candidateCell;
newCell = cell.clone();
// Figure out where to insert the new cell by checking the vitual row.
for ( var c = 0; c < newCellRow.length; c++ )
{
candidateCell = newCellRow[ c ];
// Catch first cell actually following the column.
if ( candidateCell.parentNode == newCellTr.$
&& c > colIndex )
{
newCell.insertBefore( new CKEDITOR.dom.element( candidateCell ) );
break;
}
else
candidateCell = null;
}
// The destination row is empty, append at will.
if ( !candidateCell )
newCellTr.append( newCell, true );
}
else
{
newCellRowSpan = newRowSpan = 1;
newCellTr = tr.clone();
newCellTr.insertAfter( tr );
newCellTr.append( newCell = cell.clone() );
var cellsInSameRow = cellInRow( map, rowIndex );
for ( var i = 0; i < cellsInSameRow.length; i++ )
cellsInSameRow[ i ].rowSpan++;
}
if ( !CKEDITOR.env.ie )
newCell.appendBogus();
cell.$.rowSpan = newRowSpan;
newCell.$.rowSpan = newCellRowSpan;
if ( newRowSpan == 1 )
cell.removeAttribute( 'rowSpan' );
if ( newCellRowSpan == 1 )
newCell.removeAttribute( 'rowSpan' );
return newCell;
}
function horizontalSplitCell( selection, isDetect )
{
var cells = getSelectedCells( selection );
if ( cells.length > 1 )
return false;
else if ( isDetect )
return true;
var cell = cells[ 0 ],
tr = cell.getParent(),
table = tr.getAscendant( 'table' ),
map = CKEDITOR.tools.buildTableMap( table ),
rowIndex = tr.$.rowIndex,
colIndex = cellInRow( map, rowIndex, cell ),
colSpan = cell.$.colSpan,
newCell,
newColSpan,
newCellColSpan;
if ( colSpan > 1 )
{
newColSpan = Math.ceil( colSpan / 2 );
newCellColSpan = Math.floor( colSpan / 2 );
}
else
{
newCellColSpan = newColSpan = 1;
var cellsInSameCol = cellInCol( map, colIndex );
for ( var i = 0; i < cellsInSameCol.length; i++ )
cellsInSameCol[ i ].colSpan++;
}
newCell = cell.clone();
newCell.insertAfter( cell );
if ( !CKEDITOR.env.ie )
newCell.appendBogus();
cell.$.colSpan = newColSpan;
newCell.$.colSpan = newCellColSpan;
if ( newColSpan == 1 )
cell.removeAttribute( 'colSpan' );
if ( newCellColSpan == 1 )
newCell.removeAttribute( 'colSpan' );
return newCell;
}
// Context menu on table caption incorrect (#3834)
var contextMenuTags = { thead : 1, tbody : 1, tfoot : 1, td : 1, tr : 1, th : 1 };
CKEDITOR.plugins.tabletools =
{
requires : [ 'table', 'dialog', 'contextmenu' ],
init : function( editor )
{
var lang = editor.lang.table;
editor.addCommand( 'cellProperties', new CKEDITOR.dialogCommand( 'cellProperties' ) );
CKEDITOR.dialog.add( 'cellProperties', this.path + 'dialogs/tableCell.js' );
editor.addCommand( 'tableDelete',
{
exec : function( editor )
{
var selection = editor.getSelection(),
startElement = selection && selection.getStartElement(),
table = startElement && startElement.getAscendant( 'table', 1 );
if ( !table )
return;
// If the table's parent has only one child remove it as well (unless it's the body or a table cell) (#5416, #6289)
var parent = table.getParent();
if ( parent.getChildCount() == 1 && !parent.is( 'body', 'td', 'th' ) )
table = parent;
var range = new CKEDITOR.dom.range( editor.document );
range.moveToPosition( table, CKEDITOR.POSITION_BEFORE_START );
table.remove();
range.select();
}
} );
editor.addCommand( 'rowDelete',
{
exec : function( editor )
{
var selection = editor.getSelection();
placeCursorInCell( deleteRows( selection ) );
}
} );
editor.addCommand( 'rowInsertBefore',
{
exec : function( editor )
{
var selection = editor.getSelection();
insertRow( selection, true );
}
} );
editor.addCommand( 'rowInsertAfter',
{
exec : function( editor )
{
var selection = editor.getSelection();
insertRow( selection );
}
} );
editor.addCommand( 'columnDelete',
{
exec : function( editor )
{
var selection = editor.getSelection();
var element = deleteColumns( selection );
element && placeCursorInCell( element, true );
}
} );
editor.addCommand( 'columnInsertBefore',
{
exec : function( editor )
{
var selection = editor.getSelection();
insertColumn( selection, true );
}
} );
editor.addCommand( 'columnInsertAfter',
{
exec : function( editor )
{
var selection = editor.getSelection();
insertColumn( selection );
}
} );
editor.addCommand( 'cellDelete',
{
exec : function( editor )
{
var selection = editor.getSelection();
deleteCells( selection );
}
} );
editor.addCommand( 'cellMerge',
{
exec : function( editor )
{
placeCursorInCell( mergeCells( editor.getSelection() ), true );
}
} );
editor.addCommand( 'cellMergeRight',
{
exec : function( editor )
{
placeCursorInCell( mergeCells( editor.getSelection(), 'right' ), true );
}
} );
editor.addCommand( 'cellMergeDown',
{
exec : function( editor )
{
placeCursorInCell( mergeCells( editor.getSelection(), 'down' ), true );
}
} );
editor.addCommand( 'cellVerticalSplit',
{
exec : function( editor )
{
placeCursorInCell( verticalSplitCell( editor.getSelection() ) );
}
} );
editor.addCommand( 'cellHorizontalSplit',
{
exec : function( editor )
{
placeCursorInCell( horizontalSplitCell( editor.getSelection() ) );
}
} );
editor.addCommand( 'cellInsertBefore',
{
exec : function( editor )
{
var selection = editor.getSelection();
insertCell( selection, true );
}
} );
editor.addCommand( 'cellInsertAfter',
{
exec : function( editor )
{
var selection = editor.getSelection();
insertCell( selection );
}
} );
// If the "menu" plugin is loaded, register the menu items.
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
tablecell :
{
label : lang.cell.menu,
group : 'tablecell',
order : 1,
getItems : function()
{
var selection = editor.getSelection(),
cells = getSelectedCells( selection );
return {
tablecell_insertBefore : CKEDITOR.TRISTATE_OFF,
tablecell_insertAfter : CKEDITOR.TRISTATE_OFF,
tablecell_delete : CKEDITOR.TRISTATE_OFF,
tablecell_merge : mergeCells( selection, null, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
tablecell_merge_right : mergeCells( selection, 'right', true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
tablecell_merge_down : mergeCells( selection, 'down', true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
tablecell_split_vertical : verticalSplitCell( selection, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
tablecell_split_horizontal : horizontalSplitCell( selection, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
tablecell_properties : cells.length > 0 ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED
};
}
},
tablecell_insertBefore :
{
label : lang.cell.insertBefore,
group : 'tablecell',
command : 'cellInsertBefore',
order : 5
},
tablecell_insertAfter :
{
label : lang.cell.insertAfter,
group : 'tablecell',
command : 'cellInsertAfter',
order : 10
},
tablecell_delete :
{
label : lang.cell.deleteCell,
group : 'tablecell',
command : 'cellDelete',
order : 15
},
tablecell_merge :
{
label : lang.cell.merge,
group : 'tablecell',
command : 'cellMerge',
order : 16
},
tablecell_merge_right :
{
label : lang.cell.mergeRight,
group : 'tablecell',
command : 'cellMergeRight',
order : 17
},
tablecell_merge_down :
{
label : lang.cell.mergeDown,
group : 'tablecell',
command : 'cellMergeDown',
order : 18
},
tablecell_split_horizontal :
{
label : lang.cell.splitHorizontal,
group : 'tablecell',
command : 'cellHorizontalSplit',
order : 19
},
tablecell_split_vertical :
{
label : lang.cell.splitVertical,
group : 'tablecell',
command : 'cellVerticalSplit',
order : 20
},
tablecell_properties :
{
label : lang.cell.title,
group : 'tablecellproperties',
command : 'cellProperties',
order : 21
},
tablerow :
{
label : lang.row.menu,
group : 'tablerow',
order : 1,
getItems : function()
{
return {
tablerow_insertBefore : CKEDITOR.TRISTATE_OFF,
tablerow_insertAfter : CKEDITOR.TRISTATE_OFF,
tablerow_delete : CKEDITOR.TRISTATE_OFF
};
}
},
tablerow_insertBefore :
{
label : lang.row.insertBefore,
group : 'tablerow',
command : 'rowInsertBefore',
order : 5
},
tablerow_insertAfter :
{
label : lang.row.insertAfter,
group : 'tablerow',
command : 'rowInsertAfter',
order : 10
},
tablerow_delete :
{
label : lang.row.deleteRow,
group : 'tablerow',
command : 'rowDelete',
order : 15
},
tablecolumn :
{
label : lang.column.menu,
group : 'tablecolumn',
order : 1,
getItems : function()
{
return {
tablecolumn_insertBefore : CKEDITOR.TRISTATE_OFF,
tablecolumn_insertAfter : CKEDITOR.TRISTATE_OFF,
tablecolumn_delete : CKEDITOR.TRISTATE_OFF
};
}
},
tablecolumn_insertBefore :
{
label : lang.column.insertBefore,
group : 'tablecolumn',
command : 'columnInsertBefore',
order : 5
},
tablecolumn_insertAfter :
{
label : lang.column.insertAfter,
group : 'tablecolumn',
command : 'columnInsertAfter',
order : 10
},
tablecolumn_delete :
{
label : lang.column.deleteColumn,
group : 'tablecolumn',
command : 'columnDelete',
order : 15
}
});
}
// If the "contextmenu" plugin is laoded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( !element || element.isReadOnly() )
return null;
while ( element )
{
if ( element.getName() in contextMenuTags )
{
return {
tablecell : CKEDITOR.TRISTATE_OFF,
tablerow : CKEDITOR.TRISTATE_OFF,
tablecolumn : CKEDITOR.TRISTATE_OFF
};
}
element = element.getParent();
}
return null;
} );
}
},
getSelectedCells : getSelectedCells
};
CKEDITOR.plugins.add( 'tabletools', CKEDITOR.plugins.tabletools );
})();
/**
* Create a two-dimension array that reflects the actual layout of table cells,
* with cell spans, with mappings to the original td elements.
* @param table {CKEDITOR.dom.element}
*/
CKEDITOR.tools.buildTableMap = function ( table )
{
var aRows = table.$.rows ;
// Row and Column counters.
var r = -1 ;
var aMap = [];
for ( var i = 0 ; i < aRows.length ; i++ )
{
r++ ;
!aMap[r] && ( aMap[r] = [] );
var c = -1 ;
for ( var j = 0 ; j < aRows[i].cells.length ; j++ )
{
var oCell = aRows[i].cells[j] ;
c++ ;
while ( aMap[r][c] )
c++ ;
var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ;
var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ;
for ( var rs = 0 ; rs < iRowSpan ; rs++ )
{
if ( !aMap[r + rs] )
aMap[r + rs] = [];
for ( var cs = 0 ; cs < iColSpan ; cs++ )
{
aMap[r + rs][c + cs] = aRows[i].cells[j] ;
}
}
c += iColSpan - 1 ;
}
}
return aMap ;
};
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'cellProperties', function( editor )
{
var langTable = editor.lang.table,
langCell = langTable.cell,
langCommon = editor.lang.common,
validate = CKEDITOR.dialog.validate,
widthPattern = /^(\d+(?:\.\d+)?)(px|%)$/,
heightPattern = /^(\d+(?:\.\d+)?)px$/,
bind = CKEDITOR.tools.bind,
spacer = { type : 'html', html : ' ' },
rtl = editor.lang.dir == 'rtl';
/**
*
* @param dialogName
* @param callback [ childDialog ]
*/
function getDialogValue( dialogName, callback )
{
var onOk = function()
{
releaseHandlers( this );
callback( this, this._.parentDialog );
this._.parentDialog.changeFocus();
};
var onCancel = function()
{
releaseHandlers( this );
this._.parentDialog.changeFocus();
};
var releaseHandlers = function( dialog )
{
dialog.removeListener( 'ok', onOk );
dialog.removeListener( 'cancel', onCancel );
};
var bindToDialog = function( dialog )
{
dialog.on( 'ok', onOk );
dialog.on( 'cancel', onCancel );
};
editor.execCommand( dialogName );
if ( editor._.storedDialogs.colordialog )
bindToDialog( editor._.storedDialogs.colordialog );
else
{
CKEDITOR.on( 'dialogDefinition', function( e )
{
if ( e.data.name != dialogName )
return;
var definition = e.data.definition;
e.removeListener();
definition.onLoad = CKEDITOR.tools.override( definition.onLoad, function( orginal )
{
return function()
{
bindToDialog( this );
definition.onLoad = orginal;
if ( typeof orginal == 'function' )
orginal.call( this );
};
} );
});
}
}
return {
title : langCell.title,
minWidth : CKEDITOR.env.ie && CKEDITOR.env.quirks? 450 : 410,
minHeight : CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.quirks )? 230 : 220,
contents : [
{
id : 'info',
label : langCell.title,
accessKey : 'I',
elements :
[
{
type : 'hbox',
widths : [ '40%', '5%', '40%' ],
children :
[
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'hbox',
widths : [ '70%', '30%' ],
children :
[
{
type : 'text',
id : 'width',
width: '100px',
label : langCommon.width,
validate : validate[ 'number' ]( langCell.invalidWidth ),
// Extra labelling of width unit type.
onLoad : function()
{
var widthType = this.getDialog().getContentElement( 'info', 'widthType' ),
labelElement = widthType.getElement(),
inputElement = this.getInputElement(),
ariaLabelledByAttr = inputElement.getAttribute( 'aria-labelledby' );
inputElement.setAttribute( 'aria-labelledby', [ ariaLabelledByAttr, labelElement.$.id ].join( ' ' ) );
},
setup : function( element )
{
var widthAttr = parseInt( element.getAttribute( 'width' ), 10 ),
widthStyle = parseInt( element.getStyle( 'width' ), 10 );
!isNaN( widthAttr ) && this.setValue( widthAttr );
!isNaN( widthStyle ) && this.setValue( widthStyle );
},
commit : function( element )
{
var value = parseInt( this.getValue(), 10 ),
unit = this.getDialog().getValueOf( 'info', 'widthType' );
if ( !isNaN( value ) )
element.setStyle( 'width', value + unit );
else
element.removeStyle( 'width' );
element.removeAttribute( 'width' );
},
'default' : ''
},
{
type : 'select',
id : 'widthType',
label : editor.lang.table.widthUnit,
labelStyle: 'visibility:hidden',
'default' : 'px',
items :
[
[ langTable.widthPx, 'px' ],
[ langTable.widthPc, '%' ]
],
setup : function( selectedCell )
{
var widthMatch = widthPattern.exec( selectedCell.getStyle( 'width' ) || selectedCell.getAttribute( 'width' ) );
if ( widthMatch )
this.setValue( widthMatch[2] );
}
}
]
},
{
type : 'hbox',
widths : [ '70%', '30%' ],
children :
[
{
type : 'text',
id : 'height',
label : langCommon.height,
width: '100px',
'default' : '',
validate : validate[ 'number' ]( langCell.invalidHeight ),
// Extra labelling of height unit type.
onLoad : function()
{
var heightType = this.getDialog().getContentElement( 'info', 'htmlHeightType' ),
labelElement = heightType.getElement(),
inputElement = this.getInputElement(),
ariaLabelledByAttr = inputElement.getAttribute( 'aria-labelledby' );
inputElement.setAttribute( 'aria-labelledby', [ ariaLabelledByAttr, labelElement.$.id ].join( ' ' ) );
},
setup : function( element )
{
var heightAttr = parseInt( element.getAttribute( 'height' ), 10 ),
heightStyle = parseInt( element.getStyle( 'height' ), 10 );
!isNaN( heightAttr ) && this.setValue( heightAttr );
!isNaN( heightStyle ) && this.setValue( heightStyle );
},
commit : function( element )
{
var value = parseInt( this.getValue(), 10 );
if ( !isNaN( value ) )
element.setStyle( 'height', CKEDITOR.tools.cssLength( value ) );
else
element.removeStyle( 'height' );
element.removeAttribute( 'height' );
}
},
{
id : 'htmlHeightType',
type : 'html',
html : '<br />'+ langTable.widthPx
}
]
},
spacer,
{
type : 'select',
id : 'wordWrap',
label : langCell.wordWrap,
'default' : 'yes',
items :
[
[ langCell.yes, 'yes' ],
[ langCell.no, 'no' ]
],
setup : function( element )
{
var wordWrapAttr = element.getAttribute( 'noWrap' ),
wordWrapStyle = element.getStyle( 'white-space' );
if ( wordWrapStyle == 'nowrap' || wordWrapAttr )
this.setValue( 'no' );
},
commit : function( element )
{
if ( this.getValue() == 'no' )
element.setStyle( 'white-space', 'nowrap' );
else
element.removeStyle( 'white-space' );
element.removeAttribute( 'noWrap' );
}
},
spacer,
{
type : 'select',
id : 'hAlign',
label : langCell.hAlign,
'default' : '',
items :
[
[ langCommon.notSet, '' ],
[ langCommon.alignLeft, 'left' ],
[ langCommon.alignCenter, 'center' ],
[ langCommon.alignRight, 'right' ]
],
setup : function( element )
{
var alignAttr = element.getAttribute( 'align' ),
textAlignStyle = element.getStyle( 'text-align');
this.setValue( textAlignStyle || alignAttr || '' );
},
commit : function( selectedCell )
{
var value = this.getValue();
if ( value )
selectedCell.setStyle( 'text-align', value );
else
selectedCell.removeStyle( 'text-align' );
selectedCell.removeAttribute( 'align' );
}
},
{
type : 'select',
id : 'vAlign',
label : langCell.vAlign,
'default' : '',
items :
[
[ langCommon.notSet, '' ],
[ langCommon.alignTop, 'top' ],
[ langCommon.alignMiddle, 'middle' ],
[ langCommon.alignBottom, 'bottom' ],
[ langCell.alignBaseline, 'baseline' ]
],
setup : function( element )
{
var vAlignAttr = element.getAttribute( 'vAlign' ),
vAlignStyle = element.getStyle( 'vertical-align' );
switch( vAlignStyle )
{
// Ignore all other unrelated style values..
case 'top':
case 'middle':
case 'bottom':
case 'baseline':
break;
default:
vAlignStyle = '';
}
this.setValue( vAlignStyle || vAlignAttr || '' );
},
commit : function( element )
{
var value = this.getValue();
if ( value )
element.setStyle( 'vertical-align', value );
else
element.removeStyle( 'vertical-align' );
element.removeAttribute( 'vAlign' );
}
}
]
},
spacer,
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'select',
id : 'cellType',
label : langCell.cellType,
'default' : 'td',
items :
[
[ langCell.data, 'td' ],
[ langCell.header, 'th' ]
],
setup : function( selectedCell )
{
this.setValue( selectedCell.getName() );
},
commit : function( selectedCell )
{
selectedCell.renameNode( this.getValue() );
}
},
spacer,
{
type : 'text',
id : 'rowSpan',
label : langCell.rowSpan,
'default' : '',
validate : validate.integer( langCell.invalidRowSpan ),
setup : function( selectedCell )
{
var attrVal = parseInt( selectedCell.getAttribute( 'rowSpan' ), 10 );
if ( attrVal && attrVal != 1 )
this.setValue( attrVal );
},
commit : function( selectedCell )
{
var value = parseInt( this.getValue(), 10 );
if ( value && value != 1 )
selectedCell.setAttribute( 'rowSpan', this.getValue() );
else
selectedCell.removeAttribute( 'rowSpan' );
}
},
{
type : 'text',
id : 'colSpan',
label : langCell.colSpan,
'default' : '',
validate : validate.integer( langCell.invalidColSpan ),
setup : function( element )
{
var attrVal = parseInt( element.getAttribute( 'colSpan' ), 10 );
if ( attrVal && attrVal != 1 )
this.setValue( attrVal );
},
commit : function( selectedCell )
{
var value = parseInt( this.getValue(), 10 );
if ( value && value != 1 )
selectedCell.setAttribute( 'colSpan', this.getValue() );
else
selectedCell.removeAttribute( 'colSpan' );
}
},
spacer,
{
type : 'hbox',
padding : 0,
widths : [ '60%', '40%' ],
children :
[
{
type : 'text',
id : 'bgColor',
label : langCell.bgColor,
'default' : '',
setup : function( element )
{
var bgColorAttr = element.getAttribute( 'bgColor' ),
bgColorStyle = element.getStyle( 'background-color' );
this.setValue( bgColorStyle || bgColorAttr );
},
commit : function( selectedCell )
{
var value = this.getValue();
if ( value )
selectedCell.setStyle( 'background-color', this.getValue() );
else
selectedCell.removeStyle( 'background-color' );
selectedCell.removeAttribute( 'bgColor');
}
},
{
type : 'button',
id : 'bgColorChoose',
"class" : 'colorChooser',
label : langCell.chooseColor,
onLoad : function()
{
// Stick the element to the bottom (#5587)
this.getElement().getParent().setStyle( 'vertical-align', 'bottom' );
},
onClick : function()
{
var self = this;
getDialogValue( 'colordialog', function( colorDialog )
{
self.getDialog().getContentElement( 'info', 'bgColor' ).setValue(
colorDialog.getContentElement( 'picker', 'selectedColor' ).getValue()
);
} );
}
}
]
},
spacer,
{
type : 'hbox',
padding : 0,
widths : [ '60%', '40%' ],
children :
[
{
type : 'text',
id : 'borderColor',
label : langCell.borderColor,
'default' : '',
setup : function( element )
{
var borderColorAttr = element.getAttribute( 'borderColor' ),
borderColorStyle = element.getStyle( 'border-color' );
this.setValue( borderColorStyle || borderColorAttr );
},
commit : function( selectedCell )
{
var value = this.getValue();
if ( value )
selectedCell.setStyle( 'border-color', this.getValue() );
else
selectedCell.removeStyle( 'border-color' );
selectedCell.removeAttribute( 'borderColor');
}
},
{
type : 'button',
id : 'borderColorChoose',
"class" : 'colorChooser',
label : langCell.chooseColor,
style : ( rtl ? 'margin-right' : 'margin-left' ) + ': 10px',
onLoad : function()
{
// Stick the element to the bottom (#5587)
this.getElement().getParent().setStyle( 'vertical-align', 'bottom' );
},
onClick : function()
{
var self = this;
getDialogValue( 'colordialog', function( colorDialog )
{
self.getDialog().getContentElement( 'info', 'borderColor' ).setValue(
colorDialog.getContentElement( 'picker', 'selectedColor' ).getValue()
);
} );
}
}
]
}
]
}
]
}
]
}
],
onShow : function()
{
this.cells = CKEDITOR.plugins.tabletools.getSelectedCells(
this._.editor.getSelection() );
this.setupContent( this.cells[ 0 ] );
},
onOk : function()
{
var selection = this._.editor.getSelection(),
bookmarks = selection.createBookmarks();
var cells = this.cells;
for ( var i = 0 ; i < cells.length ; i++ )
this.commitContent( cells[ i ] );
this._.editor.forceNextSelectionCheck();
selection.selectBookmarks( bookmarks );
this._.editor.selectionChange();
}
};
} );
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Image plugin
*/
(function()
{
CKEDITOR.plugins.add( 'image',
{
requires: [ 'dialog' ],
init : function( editor )
{
var pluginName = 'image';
// Register the dialog.
CKEDITOR.dialog.add( pluginName, this.path + 'dialogs/image.js' );
// Register the command.
editor.addCommand( pluginName, new CKEDITOR.dialogCommand( pluginName ) );
// Register the toolbar button.
editor.ui.addButton( 'Image',
{
label : editor.lang.common.image,
command : pluginName
});
editor.on( 'doubleclick', function( evt )
{
var element = evt.data.element;
if ( element.is( 'img' ) && !element.data( 'cke-realelement' ) && !element.isReadOnly() )
evt.data.dialog = 'image';
});
// If the "menu" plugin is loaded, register the menu items.
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
image :
{
label : editor.lang.image.menu,
command : 'image',
group : 'image'
}
});
}
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( getSelectedImage( editor, element ) )
return { image : CKEDITOR.TRISTATE_OFF };
});
}
},
afterInit : function( editor )
{
// Customize the behavior of the alignment commands. (#7430)
setupAlignCommand( 'left' );
setupAlignCommand( 'right' );
setupAlignCommand( 'center' );
setupAlignCommand( 'block' );
function setupAlignCommand( value )
{
var command = editor.getCommand( 'justify' + value );
if ( command )
{
if ( value == 'left' || value == 'right' )
{
command.on( 'exec', function( evt )
{
var img = getSelectedImage( editor ), align;
if ( img )
{
align = getImageAlignment( img );
if ( align == value )
{
img.removeStyle( 'float' );
// Remove "align" attribute when necessary.
if ( value == getImageAlignment( img ) )
img.removeAttribute( 'align' );
}
else
img.setStyle( 'float', value );
evt.cancel();
}
});
}
command.on( 'refresh', function( evt )
{
var img = getSelectedImage( editor ), align;
if ( img )
{
align = getImageAlignment( img );
this.setState(
( align == value ) ? CKEDITOR.TRISTATE_ON :
( value == 'right' || value == 'left' ) ? CKEDITOR.TRISTATE_OFF :
CKEDITOR.TRISTATE_DISABLED );
evt.cancel();
}
});
}
}
}
});
function getSelectedImage( editor, element )
{
if ( !element )
{
var sel = editor.getSelection();
element = ( sel.getType() == CKEDITOR.SELECTION_ELEMENT ) && sel.getSelectedElement();
}
if ( element && element.is( 'img' ) && !element.data( 'cke-realelement' ) && !element.isReadOnly() )
return element;
}
function getImageAlignment( element )
{
var align = element.getStyle( 'float' );
if ( align == 'inherit' || align == 'none' )
align = 0;
if ( !align )
align = element.getAttribute( 'align' );
return align;
}
})();
/**
* Whether to remove links when emptying the link URL field in the image dialog.
* @type Boolean
* @default true
* @example
* config.image_removeLinkByEmptyURL = false;
*/
CKEDITOR.config.image_removeLinkByEmptyURL = true;
/**
* Padding text to set off the image in preview area.
* @name CKEDITOR.config.image_previewText
* @type String
* @default "Lorem ipsum dolor..." placehoder text.
* @example
* config.image_previewText = CKEDITOR.tools.repeat( '___ ', 100 );
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var imageDialog = function( editor, dialogType )
{
// Load image preview.
var IMAGE = 1,
LINK = 2,
PREVIEW = 4,
CLEANUP = 8,
regexGetSize = /^\s*(\d+)((px)|\%)?\s*$/i,
regexGetSizeOrEmpty = /(^\s*(\d+)((px)|\%)?\s*$)|^$/i,
pxLengthRegex = /^\d+px$/;
var onSizeChange = function()
{
var value = this.getValue(), // This = input element.
dialog = this.getDialog(),
aMatch = value.match( regexGetSize ); // Check value
if ( aMatch )
{
if ( aMatch[2] == '%' ) // % is allowed - > unlock ratio.
switchLockRatio( dialog, false ); // Unlock.
value = aMatch[1];
}
// Only if ratio is locked
if ( dialog.lockRatio )
{
var oImageOriginal = dialog.originalElement;
if ( oImageOriginal.getCustomData( 'isReady' ) == 'true' )
{
if ( this.id == 'txtHeight' )
{
if ( value && value != '0' )
value = Math.round( oImageOriginal.$.width * ( value / oImageOriginal.$.height ) );
if ( !isNaN( value ) )
dialog.setValueOf( 'info', 'txtWidth', value );
}
else //this.id = txtWidth.
{
if ( value && value != '0' )
value = Math.round( oImageOriginal.$.height * ( value / oImageOriginal.$.width ) );
if ( !isNaN( value ) )
dialog.setValueOf( 'info', 'txtHeight', value );
}
}
}
updatePreview( dialog );
};
var updatePreview = function( dialog )
{
//Don't load before onShow.
if ( !dialog.originalElement || !dialog.preview )
return 1;
// Read attributes and update imagePreview;
dialog.commitContent( PREVIEW, dialog.preview );
return 0;
};
// Custom commit dialog logic, where we're intended to give inline style
// field (txtdlgGenStyle) higher priority to avoid overwriting styles contribute
// by other fields.
function commitContent()
{
var args = arguments;
var inlineStyleField = this.getContentElement( 'advanced', 'txtdlgGenStyle' );
inlineStyleField && inlineStyleField.commit.apply( inlineStyleField, args );
this.foreach( function( widget )
{
if ( widget.commit && widget.id != 'txtdlgGenStyle' )
widget.commit.apply( widget, args );
});
}
// Avoid recursions.
var incommit;
// Synchronous field values to other impacted fields is required, e.g. border
// size change should alter inline-style text as well.
function commitInternally( targetFields )
{
if ( incommit )
return;
incommit = 1;
var dialog = this.getDialog(),
element = dialog.imageElement;
if ( element )
{
// Commit this field and broadcast to target fields.
this.commit( IMAGE, element );
targetFields = [].concat( targetFields );
var length = targetFields.length,
field;
for ( var i = 0; i < length; i++ )
{
field = dialog.getContentElement.apply( dialog, targetFields[ i ].split( ':' ) );
// May cause recursion.
field && field.setup( IMAGE, element );
}
}
incommit = 0;
}
var switchLockRatio = function( dialog, value )
{
if ( !dialog.getContentElement( 'info', 'ratioLock' ) )
return null;
var oImageOriginal = dialog.originalElement;
// Dialog may already closed. (#5505)
if( !oImageOriginal )
return null;
// Check image ratio and original image ratio, but respecting user's preference.
if ( value == 'check' )
{
if ( !dialog.userlockRatio && oImageOriginal.getCustomData( 'isReady' ) == 'true' )
{
var width = dialog.getValueOf( 'info', 'txtWidth' ),
height = dialog.getValueOf( 'info', 'txtHeight' ),
originalRatio = oImageOriginal.$.width * 1000 / oImageOriginal.$.height,
thisRatio = width * 1000 / height;
dialog.lockRatio = false; // Default: unlock ratio
if ( !width && !height )
dialog.lockRatio = true;
else if ( !isNaN( originalRatio ) && !isNaN( thisRatio ) )
{
if ( Math.round( originalRatio ) == Math.round( thisRatio ) )
dialog.lockRatio = true;
}
}
}
else if ( value != undefined )
dialog.lockRatio = value;
else
{
dialog.userlockRatio = 1;
dialog.lockRatio = !dialog.lockRatio;
}
var ratioButton = CKEDITOR.document.getById( btnLockSizesId );
if ( dialog.lockRatio )
ratioButton.removeClass( 'cke_btn_unlocked' );
else
ratioButton.addClass( 'cke_btn_unlocked' );
ratioButton.setAttribute( 'aria-checked', dialog.lockRatio );
// Ratio button hc presentation - WHITE SQUARE / BLACK SQUARE
if ( CKEDITOR.env.hc )
{
var icon = ratioButton.getChild( 0 );
icon.setHtml( dialog.lockRatio ? CKEDITOR.env.ie ? '\u25A0': '\u25A3' : CKEDITOR.env.ie ? '\u25A1' : '\u25A2' );
}
return dialog.lockRatio;
};
var resetSize = function( dialog )
{
var oImageOriginal = dialog.originalElement;
if ( oImageOriginal.getCustomData( 'isReady' ) == 'true' )
{
var widthField = dialog.getContentElement( 'info', 'txtWidth' ),
heightField = dialog.getContentElement( 'info', 'txtHeight' );
widthField && widthField.setValue( oImageOriginal.$.width );
heightField && heightField.setValue( oImageOriginal.$.height );
}
updatePreview( dialog );
};
var setupDimension = function( type, element )
{
if ( type != IMAGE )
return;
function checkDimension( size, defaultValue )
{
var aMatch = size.match( regexGetSize );
if ( aMatch )
{
if ( aMatch[2] == '%' ) // % is allowed.
{
aMatch[1] += '%';
switchLockRatio( dialog, false ); // Unlock ratio
}
return aMatch[1];
}
return defaultValue;
}
var dialog = this.getDialog(),
value = '',
dimension = this.id == 'txtWidth' ? 'width' : 'height',
size = element.getAttribute( dimension );
if ( size )
value = checkDimension( size, value );
value = checkDimension( element.getStyle( dimension ), value );
this.setValue( value );
};
var previewPreloader;
var onImgLoadEvent = function()
{
// Image is ready.
var original = this.originalElement;
original.setCustomData( 'isReady', 'true' );
original.removeListener( 'load', onImgLoadEvent );
original.removeListener( 'error', onImgLoadErrorEvent );
original.removeListener( 'abort', onImgLoadErrorEvent );
// Hide loader
CKEDITOR.document.getById( imagePreviewLoaderId ).setStyle( 'display', 'none' );
// New image -> new domensions
if ( !this.dontResetSize )
resetSize( this );
if ( this.firstLoad )
CKEDITOR.tools.setTimeout( function(){ switchLockRatio( this, 'check' ); }, 0, this );
this.firstLoad = false;
this.dontResetSize = false;
};
var onImgLoadErrorEvent = function()
{
// Error. Image is not loaded.
var original = this.originalElement;
original.removeListener( 'load', onImgLoadEvent );
original.removeListener( 'error', onImgLoadErrorEvent );
original.removeListener( 'abort', onImgLoadErrorEvent );
// Set Error image.
var noimage = CKEDITOR.getUrl( editor.skinPath + 'images/noimage.png' );
if ( this.preview )
this.preview.setAttribute( 'src', noimage );
// Hide loader
CKEDITOR.document.getById( imagePreviewLoaderId ).setStyle( 'display', 'none' );
switchLockRatio( this, false ); // Unlock.
};
var numbering = function( id )
{
return CKEDITOR.tools.getNextId() + '_' + id;
},
btnLockSizesId = numbering( 'btnLockSizes' ),
btnResetSizeId = numbering( 'btnResetSize' ),
imagePreviewLoaderId = numbering( 'ImagePreviewLoader' ),
previewLinkId = numbering( 'previewLink' ),
previewImageId = numbering( 'previewImage' );
return {
title : editor.lang.image[ dialogType == 'image' ? 'title' : 'titleButton' ],
minWidth : 420,
minHeight : 360,
onShow : function()
{
this.imageElement = false;
this.linkElement = false;
// Default: create a new element.
this.imageEditMode = false;
this.linkEditMode = false;
this.lockRatio = true;
this.userlockRatio = 0;
this.dontResetSize = false;
this.firstLoad = true;
this.addLink = false;
var editor = this.getParentEditor(),
sel = editor.getSelection(),
element = sel && sel.getSelectedElement(),
link = element && element.getAscendant( 'a' );
//Hide loader.
CKEDITOR.document.getById( imagePreviewLoaderId ).setStyle( 'display', 'none' );
// Create the preview before setup the dialog contents.
previewPreloader = new CKEDITOR.dom.element( 'img', editor.document );
this.preview = CKEDITOR.document.getById( previewImageId );
// Copy of the image
this.originalElement = editor.document.createElement( 'img' );
this.originalElement.setAttribute( 'alt', '' );
this.originalElement.setCustomData( 'isReady', 'false' );
if ( link )
{
this.linkElement = link;
this.linkEditMode = true;
// Look for Image element.
var linkChildren = link.getChildren();
if ( linkChildren.count() == 1 ) // 1 child.
{
var childTagName = linkChildren.getItem( 0 ).getName();
if ( childTagName == 'img' || childTagName == 'input' )
{
this.imageElement = linkChildren.getItem( 0 );
if ( this.imageElement.getName() == 'img' )
this.imageEditMode = 'img';
else if ( this.imageElement.getName() == 'input' )
this.imageEditMode = 'input';
}
}
// Fill out all fields.
if ( dialogType == 'image' )
this.setupContent( LINK, link );
}
if ( element && element.getName() == 'img' && !element.data( 'cke-realelement' )
|| element && element.getName() == 'input' && element.getAttribute( 'type' ) == 'image' )
{
this.imageEditMode = element.getName();
this.imageElement = element;
}
if ( this.imageEditMode )
{
// Use the original element as a buffer from since we don't want
// temporary changes to be committed, e.g. if the dialog is canceled.
this.cleanImageElement = this.imageElement;
this.imageElement = this.cleanImageElement.clone( true, true );
// Fill out all fields.
this.setupContent( IMAGE, this.imageElement );
}
else
this.imageElement = editor.document.createElement( 'img' );
// Refresh LockRatio button
switchLockRatio ( this, true );
// Dont show preview if no URL given.
if ( !CKEDITOR.tools.trim( this.getValueOf( 'info', 'txtUrl' ) ) )
{
this.preview.removeAttribute( 'src' );
this.preview.setStyle( 'display', 'none' );
}
},
onOk : function()
{
// Edit existing Image.
if ( this.imageEditMode )
{
var imgTagName = this.imageEditMode;
// Image dialog and Input element.
if ( dialogType == 'image' && imgTagName == 'input' && confirm( editor.lang.image.button2Img ) )
{
// Replace INPUT-> IMG
imgTagName = 'img';
this.imageElement = editor.document.createElement( 'img' );
this.imageElement.setAttribute( 'alt', '' );
editor.insertElement( this.imageElement );
}
// ImageButton dialog and Image element.
else if ( dialogType != 'image' && imgTagName == 'img' && confirm( editor.lang.image.img2Button ))
{
// Replace IMG -> INPUT
imgTagName = 'input';
this.imageElement = editor.document.createElement( 'input' );
this.imageElement.setAttributes(
{
type : 'image',
alt : ''
}
);
editor.insertElement( this.imageElement );
}
else
{
// Restore the original element before all commits.
this.imageElement = this.cleanImageElement;
delete this.cleanImageElement;
}
}
else // Create a new image.
{
// Image dialog -> create IMG element.
if ( dialogType == 'image' )
this.imageElement = editor.document.createElement( 'img' );
else
{
this.imageElement = editor.document.createElement( 'input' );
this.imageElement.setAttribute ( 'type' ,'image' );
}
this.imageElement.setAttribute( 'alt', '' );
}
// Create a new link.
if ( !this.linkEditMode )
this.linkElement = editor.document.createElement( 'a' );
// Set attributes.
this.commitContent( IMAGE, this.imageElement );
this.commitContent( LINK, this.linkElement );
// Remove empty style attribute.
if ( !this.imageElement.getAttribute( 'style' ) )
this.imageElement.removeAttribute( 'style' );
// Insert a new Image.
if ( !this.imageEditMode )
{
if ( this.addLink )
{
//Insert a new Link.
if ( !this.linkEditMode )
{
editor.insertElement( this.linkElement );
this.linkElement.append( this.imageElement, false );
}
else //Link already exists, image not.
editor.insertElement( this.imageElement );
}
else
editor.insertElement( this.imageElement );
}
else // Image already exists.
{
//Add a new link element.
if ( !this.linkEditMode && this.addLink )
{
editor.insertElement( this.linkElement );
this.imageElement.appendTo( this.linkElement );
}
//Remove Link, Image exists.
else if ( this.linkEditMode && !this.addLink )
{
editor.getSelection().selectElement( this.linkElement );
editor.insertElement( this.imageElement );
}
}
},
onLoad : function()
{
if ( dialogType != 'image' )
this.hidePage( 'Link' ); //Hide Link tab.
var doc = this._.element.getDocument();
if ( this.getContentElement( 'info', 'ratioLock' ) )
{
this.addFocusable( doc.getById( btnResetSizeId ), 5 );
this.addFocusable( doc.getById( btnLockSizesId ), 5 );
}
this.commitContent = commitContent;
},
onHide : function()
{
if ( this.preview )
this.commitContent( CLEANUP, this.preview );
if ( this.originalElement )
{
this.originalElement.removeListener( 'load', onImgLoadEvent );
this.originalElement.removeListener( 'error', onImgLoadErrorEvent );
this.originalElement.removeListener( 'abort', onImgLoadErrorEvent );
this.originalElement.remove();
this.originalElement = false; // Dialog is closed.
}
delete this.imageElement;
},
contents : [
{
id : 'info',
label : editor.lang.image.infoTab,
accessKey : 'I',
elements :
[
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'hbox',
widths : [ '280px', '110px' ],
align : 'right',
children :
[
{
id : 'txtUrl',
type : 'text',
label : editor.lang.common.url,
required: true,
onChange : function()
{
var dialog = this.getDialog(),
newUrl = this.getValue();
//Update original image
if ( newUrl.length > 0 ) //Prevent from load before onShow
{
dialog = this.getDialog();
var original = dialog.originalElement;
dialog.preview.removeStyle( 'display' );
original.setCustomData( 'isReady', 'false' );
// Show loader
var loader = CKEDITOR.document.getById( imagePreviewLoaderId );
if ( loader )
loader.setStyle( 'display', '' );
original.on( 'load', onImgLoadEvent, dialog );
original.on( 'error', onImgLoadErrorEvent, dialog );
original.on( 'abort', onImgLoadErrorEvent, dialog );
original.setAttribute( 'src', newUrl );
// Query the preloader to figure out the url impacted by based href.
previewPreloader.setAttribute( 'src', newUrl );
dialog.preview.setAttribute( 'src', previewPreloader.$.src );
updatePreview( dialog );
}
// Dont show preview if no URL given.
else if ( dialog.preview )
{
dialog.preview.removeAttribute( 'src' );
dialog.preview.setStyle( 'display', 'none' );
}
},
setup : function( type, element )
{
if ( type == IMAGE )
{
var url = element.data( 'cke-saved-src' ) || element.getAttribute( 'src' );
var field = this;
this.getDialog().dontResetSize = true;
field.setValue( url ); // And call this.onChange()
// Manually set the initial value.(#4191)
field.setInitValue();
}
},
commit : function( type, element )
{
if ( type == IMAGE && ( this.getValue() || this.isChanged() ) )
{
element.data( 'cke-saved-src', this.getValue() );
element.setAttribute( 'src', this.getValue() );
}
else if ( type == CLEANUP )
{
element.setAttribute( 'src', '' ); // If removeAttribute doesn't work.
element.removeAttribute( 'src' );
}
},
validate : CKEDITOR.dialog.validate.notEmpty( editor.lang.image.urlMissing )
},
{
type : 'button',
id : 'browse',
// v-align with the 'txtUrl' field.
// TODO: We need something better than a fixed size here.
style : 'display:inline-block;margin-top:10px;',
align : 'center',
label : editor.lang.common.browseServer,
hidden : true,
filebrowser : 'info:txtUrl'
}
]
}
]
},
{
id : 'txtAlt',
type : 'text',
label : editor.lang.image.alt,
accessKey : 'T',
'default' : '',
onChange : function()
{
updatePreview( this.getDialog() );
},
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'alt' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'alt', this.getValue() );
}
else if ( type == PREVIEW )
{
element.setAttribute( 'alt', this.getValue() );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'alt' );
}
}
},
{
type : 'hbox',
children :
[
{
id : 'basic',
type : 'vbox',
children :
[
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
type : 'vbox',
padding : 1,
children :
[
{
type : 'text',
width: '40px',
id : 'txtWidth',
label : editor.lang.common.width,
onKeyUp : onSizeChange,
onChange : function()
{
commitInternally.call( this, 'advanced:txtdlgGenStyle' );
},
validate : function()
{
var aMatch = this.getValue().match( regexGetSizeOrEmpty ),
isValid = !!( aMatch && parseInt( aMatch[1], 10 ) !== 0 );
if ( !isValid )
alert( editor.lang.common.invalidWidth );
return isValid;
},
setup : setupDimension,
commit : function( type, element, internalCommit )
{
var value = this.getValue();
if ( type == IMAGE )
{
if ( value )
element.setStyle( 'width', CKEDITOR.tools.cssLength( value ) );
else
element.removeStyle( 'width' );
!internalCommit && element.removeAttribute( 'width' );
}
else if ( type == PREVIEW )
{
var aMatch = value.match( regexGetSize );
if ( !aMatch )
{
var oImageOriginal = this.getDialog().originalElement;
if ( oImageOriginal.getCustomData( 'isReady' ) == 'true' )
element.setStyle( 'width', oImageOriginal.$.width + 'px');
}
else
element.setStyle( 'width', CKEDITOR.tools.cssLength( value ) );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'width' );
element.removeStyle( 'width' );
}
}
},
{
type : 'text',
id : 'txtHeight',
width: '40px',
label : editor.lang.common.height,
onKeyUp : onSizeChange,
onChange : function()
{
commitInternally.call( this, 'advanced:txtdlgGenStyle' );
},
validate : function()
{
var aMatch = this.getValue().match( regexGetSizeOrEmpty ),
isValid = !!( aMatch && parseInt( aMatch[1], 10 ) !== 0 );
if ( !isValid )
alert( editor.lang.common.invalidHeight );
return isValid;
},
setup : setupDimension,
commit : function( type, element, internalCommit )
{
var value = this.getValue();
if ( type == IMAGE )
{
if ( value )
element.setStyle( 'height', CKEDITOR.tools.cssLength( value ) );
else
element.removeStyle( 'height' );
!internalCommit && element.removeAttribute( 'height' );
}
else if ( type == PREVIEW )
{
var aMatch = value.match( regexGetSize );
if ( !aMatch )
{
var oImageOriginal = this.getDialog().originalElement;
if ( oImageOriginal.getCustomData( 'isReady' ) == 'true' )
element.setStyle( 'height', oImageOriginal.$.height + 'px' );
}
else
element.setStyle( 'height', CKEDITOR.tools.cssLength( value ) );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'height' );
element.removeStyle( 'height' );
}
}
}
]
},
{
id : 'ratioLock',
type : 'html',
style : 'margin-top:30px;width:40px;height:40px;',
onLoad : function()
{
// Activate Reset button
var resetButton = CKEDITOR.document.getById( btnResetSizeId ),
ratioButton = CKEDITOR.document.getById( btnLockSizesId );
if ( resetButton )
{
resetButton.on( 'click', function( evt )
{
resetSize( this );
evt.data && evt.data.preventDefault();
}, this.getDialog() );
resetButton.on( 'mouseover', function()
{
this.addClass( 'cke_btn_over' );
}, resetButton );
resetButton.on( 'mouseout', function()
{
this.removeClass( 'cke_btn_over' );
}, resetButton );
}
// Activate (Un)LockRatio button
if ( ratioButton )
{
ratioButton.on( 'click', function(evt)
{
var locked = switchLockRatio( this ),
oImageOriginal = this.originalElement,
width = this.getValueOf( 'info', 'txtWidth' );
if ( oImageOriginal.getCustomData( 'isReady' ) == 'true' && width )
{
var height = oImageOriginal.$.height / oImageOriginal.$.width * width;
if ( !isNaN( height ) )
{
this.setValueOf( 'info', 'txtHeight', Math.round( height ) );
updatePreview( this );
}
}
evt.data && evt.data.preventDefault();
}, this.getDialog() );
ratioButton.on( 'mouseover', function()
{
this.addClass( 'cke_btn_over' );
}, ratioButton );
ratioButton.on( 'mouseout', function()
{
this.removeClass( 'cke_btn_over' );
}, ratioButton );
}
},
html : '<div>'+
'<a href="javascript:void(0)" tabindex="-1" title="' + editor.lang.image.lockRatio +
'" class="cke_btn_locked" id="' + btnLockSizesId + '" role="checkbox"><span class="cke_icon"></span><span class="cke_label">' + editor.lang.image.lockRatio + '</span></a>' +
'<a href="javascript:void(0)" tabindex="-1" title="' + editor.lang.image.resetSize +
'" class="cke_btn_reset" id="' + btnResetSizeId + '" role="button"><span class="cke_label">' + editor.lang.image.resetSize + '</span></a>'+
'</div>'
}
]
},
{
type : 'vbox',
padding : 1,
children :
[
{
type : 'text',
id : 'txtBorder',
width: '60px',
label : editor.lang.image.border,
'default' : '',
onKeyUp : function()
{
updatePreview( this.getDialog() );
},
onChange : function()
{
commitInternally.call( this, 'advanced:txtdlgGenStyle' );
},
validate : CKEDITOR.dialog.validate.integer( editor.lang.image.validateBorder ),
setup : function( type, element )
{
if ( type == IMAGE )
{
var value,
borderStyle = element.getStyle( 'border-width' );
borderStyle = borderStyle && borderStyle.match( /^(\d+px)(?: \1 \1 \1)?$/ );
value = borderStyle && parseInt( borderStyle[ 1 ], 10 );
isNaN ( parseInt( value, 10 ) ) && ( value = element.getAttribute( 'border' ) );
this.setValue( value );
}
},
commit : function( type, element, internalCommit )
{
var value = parseInt( this.getValue(), 10 );
if ( type == IMAGE || type == PREVIEW )
{
if ( !isNaN( value ) )
{
element.setStyle( 'border-width', CKEDITOR.tools.cssLength( value ) );
element.setStyle( 'border-style', 'solid' );
}
else if ( !value && this.isChanged() )
{
element.removeStyle( 'border-width' );
element.removeStyle( 'border-style' );
element.removeStyle( 'border-color' );
}
if ( !internalCommit && type == IMAGE )
element.removeAttribute( 'border' );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'border' );
element.removeStyle( 'border-width' );
element.removeStyle( 'border-style' );
element.removeStyle( 'border-color' );
}
}
},
{
type : 'text',
id : 'txtHSpace',
width: '60px',
label : editor.lang.image.hSpace,
'default' : '',
onKeyUp : function()
{
updatePreview( this.getDialog() );
},
onChange : function()
{
commitInternally.call( this, 'advanced:txtdlgGenStyle' );
},
validate : CKEDITOR.dialog.validate.integer( editor.lang.image.validateHSpace ),
setup : function( type, element )
{
if ( type == IMAGE )
{
var value,
marginLeftPx,
marginRightPx,
marginLeftStyle = element.getStyle( 'margin-left' ),
marginRightStyle = element.getStyle( 'margin-right' );
marginLeftStyle = marginLeftStyle && marginLeftStyle.match( pxLengthRegex );
marginRightStyle = marginRightStyle && marginRightStyle.match( pxLengthRegex );
marginLeftPx = parseInt( marginLeftStyle, 10 );
marginRightPx = parseInt( marginRightStyle, 10 );
value = ( marginLeftPx == marginRightPx ) && marginLeftPx;
isNaN( parseInt( value, 10 ) ) && ( value = element.getAttribute( 'hspace' ) );
this.setValue( value );
}
},
commit : function( type, element, internalCommit )
{
var value = parseInt( this.getValue(), 10 );
if ( type == IMAGE || type == PREVIEW )
{
if ( !isNaN( value ) )
{
element.setStyle( 'margin-left', CKEDITOR.tools.cssLength( value ) );
element.setStyle( 'margin-right', CKEDITOR.tools.cssLength( value ) );
}
else if ( !value && this.isChanged( ) )
{
element.removeStyle( 'margin-left' );
element.removeStyle( 'margin-right' );
}
if ( !internalCommit && type == IMAGE )
element.removeAttribute( 'hspace' );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'hspace' );
element.removeStyle( 'margin-left' );
element.removeStyle( 'margin-right' );
}
}
},
{
type : 'text',
id : 'txtVSpace',
width : '60px',
label : editor.lang.image.vSpace,
'default' : '',
onKeyUp : function()
{
updatePreview( this.getDialog() );
},
onChange : function()
{
commitInternally.call( this, 'advanced:txtdlgGenStyle' );
},
validate : CKEDITOR.dialog.validate.integer( editor.lang.image.validateVSpace ),
setup : function( type, element )
{
if ( type == IMAGE )
{
var value,
marginTopPx,
marginBottomPx,
marginTopStyle = element.getStyle( 'margin-top' ),
marginBottomStyle = element.getStyle( 'margin-bottom' );
marginTopStyle = marginTopStyle && marginTopStyle.match( pxLengthRegex );
marginBottomStyle = marginBottomStyle && marginBottomStyle.match( pxLengthRegex );
marginTopPx = parseInt( marginTopStyle, 10 );
marginBottomPx = parseInt( marginBottomStyle, 10 );
value = ( marginTopPx == marginBottomPx ) && marginTopPx;
isNaN ( parseInt( value, 10 ) ) && ( value = element.getAttribute( 'vspace' ) );
this.setValue( value );
}
},
commit : function( type, element, internalCommit )
{
var value = parseInt( this.getValue(), 10 );
if ( type == IMAGE || type == PREVIEW )
{
if ( !isNaN( value ) )
{
element.setStyle( 'margin-top', CKEDITOR.tools.cssLength( value ) );
element.setStyle( 'margin-bottom', CKEDITOR.tools.cssLength( value ) );
}
else if ( !value && this.isChanged( ) )
{
element.removeStyle( 'margin-top' );
element.removeStyle( 'margin-bottom' );
}
if ( !internalCommit && type == IMAGE )
element.removeAttribute( 'vspace' );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'vspace' );
element.removeStyle( 'margin-top' );
element.removeStyle( 'margin-bottom' );
}
}
},
{
id : 'cmbAlign',
type : 'select',
widths : [ '35%','65%' ],
style : 'width:90px',
label : editor.lang.common.align,
'default' : '',
items :
[
[ editor.lang.common.notSet , ''],
[ editor.lang.common.alignLeft , 'left'],
[ editor.lang.common.alignRight , 'right']
// Backward compatible with v2 on setup when specified as attribute value,
// while these values are no more available as select options.
// [ editor.lang.image.alignAbsBottom , 'absBottom'],
// [ editor.lang.image.alignAbsMiddle , 'absMiddle'],
// [ editor.lang.image.alignBaseline , 'baseline'],
// [ editor.lang.image.alignTextTop , 'text-top'],
// [ editor.lang.image.alignBottom , 'bottom'],
// [ editor.lang.image.alignMiddle , 'middle'],
// [ editor.lang.image.alignTop , 'top']
],
onChange : function()
{
updatePreview( this.getDialog() );
commitInternally.call( this, 'advanced:txtdlgGenStyle' );
},
setup : function( type, element )
{
if ( type == IMAGE )
{
var value = element.getStyle( 'float' );
switch( value )
{
// Ignore those unrelated values.
case 'inherit':
case 'none':
value = '';
}
!value && ( value = ( element.getAttribute( 'align' ) || '' ).toLowerCase() );
this.setValue( value );
}
},
commit : function( type, element, internalCommit )
{
var value = this.getValue();
if ( type == IMAGE || type == PREVIEW )
{
if ( value )
element.setStyle( 'float', value );
else
element.removeStyle( 'float' );
if ( !internalCommit && type == IMAGE )
{
value = ( element.getAttribute( 'align' ) || '' ).toLowerCase();
switch( value )
{
// we should remove it only if it matches "left" or "right",
// otherwise leave it intact.
case 'left':
case 'right':
element.removeAttribute( 'align' );
}
}
}
else if ( type == CLEANUP )
element.removeStyle( 'float' );
}
}
]
}
]
},
{
type : 'vbox',
height : '250px',
children :
[
{
type : 'html',
id : 'htmlPreview',
style : 'width:95%;',
html : '<div>' + CKEDITOR.tools.htmlEncode( editor.lang.common.preview ) +'<br>'+
'<div id="' + imagePreviewLoaderId + '" class="ImagePreviewLoader" style="display:none"><div class="loading"> </div></div>'+
'<div class="ImagePreviewBox"><table><tr><td>'+
'<a href="javascript:void(0)" target="_blank" onclick="return false;" id="' + previewLinkId + '">'+
'<img id="' + previewImageId + '" alt="" /></a>' +
( editor.config.image_previewText ||
'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. '+
'Maecenas feugiat consequat diam. Maecenas metus. Vivamus diam purus, cursus a, commodo non, facilisis vitae, '+
'nulla. Aenean dictum lacinia tortor. Nunc iaculis, nibh non iaculis aliquam, orci felis euismod neque, sed ornare massa mauris sed velit. Nulla pretium mi et risus. Fusce mi pede, tempor id, cursus ac, ullamcorper nec, enim. Sed tortor. Curabitur molestie. Duis velit augue, condimentum at, ultrices a, luctus ut, orci. Donec pellentesque egestas eros. Integer cursus, augue in cursus faucibus, eros pede bibendum sem, in tempus tellus justo quis ligula. Etiam eget tortor. Vestibulum rutrum, est ut placerat elementum, lectus nisl aliquam velit, tempor aliquam eros nunc nonummy metus. In eros metus, gravida a, gravida sed, lobortis id, turpis. Ut ultrices, ipsum at venenatis fringilla, sem nulla lacinia tellus, eget aliquet turpis mauris non enim. Nam turpis. Suspendisse lacinia. Curabitur ac tortor ut ipsum egestas elementum. Nunc imperdiet gravida mauris.' ) +
'</td></tr></table></div></div>'
}
]
}
]
}
]
},
{
id : 'Link',
label : editor.lang.link.title,
padding : 0,
elements :
[
{
id : 'txtUrl',
type : 'text',
label : editor.lang.common.url,
style : 'width: 100%',
'default' : '',
setup : function( type, element )
{
if ( type == LINK )
{
var href = element.data( 'cke-saved-href' );
if ( !href )
href = element.getAttribute( 'href' );
this.setValue( href );
}
},
commit : function( type, element )
{
if ( type == LINK )
{
if ( this.getValue() || this.isChanged() )
{
var url = decodeURI( this.getValue() );
element.data( 'cke-saved-href', url );
element.setAttribute( 'href', url );
if ( this.getValue() || !editor.config.image_removeLinkByEmptyURL )
this.getDialog().addLink = true;
}
}
}
},
{
type : 'button',
id : 'browse',
filebrowser :
{
action : 'Browse',
target: 'Link:txtUrl',
url: editor.config.filebrowserImageBrowseLinkUrl
},
style : 'float:right',
hidden : true,
label : editor.lang.common.browseServer
},
{
id : 'cmbTarget',
type : 'select',
label : editor.lang.common.target,
'default' : '',
items :
[
[ editor.lang.common.notSet , ''],
[ editor.lang.common.targetNew , '_blank'],
[ editor.lang.common.targetTop , '_top'],
[ editor.lang.common.targetSelf , '_self'],
[ editor.lang.common.targetParent , '_parent']
],
setup : function( type, element )
{
if ( type == LINK )
this.setValue( element.getAttribute( 'target' ) || '' );
},
commit : function( type, element )
{
if ( type == LINK )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'target', this.getValue() );
}
}
}
]
},
{
id : 'Upload',
hidden : true,
filebrowser : 'uploadButton',
label : editor.lang.image.upload,
elements :
[
{
type : 'file',
id : 'upload',
label : editor.lang.image.btnUpload,
style: 'height:40px',
size : 38
},
{
type : 'fileButton',
id : 'uploadButton',
filebrowser : 'info:txtUrl',
label : editor.lang.image.btnUpload,
'for' : [ 'Upload', 'upload' ]
}
]
},
{
id : 'advanced',
label : editor.lang.common.advancedTab,
elements :
[
{
type : 'hbox',
widths : [ '50%', '25%', '25%' ],
children :
[
{
type : 'text',
id : 'linkId',
label : editor.lang.common.id,
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'id' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'id', this.getValue() );
}
}
},
{
id : 'cmbLangDir',
type : 'select',
style : 'width : 100px;',
label : editor.lang.common.langDir,
'default' : '',
items :
[
[ editor.lang.common.notSet, '' ],
[ editor.lang.common.langDirLtr, 'ltr' ],
[ editor.lang.common.langDirRtl, 'rtl' ]
],
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'dir' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'dir', this.getValue() );
}
}
},
{
type : 'text',
id : 'txtLangCode',
label : editor.lang.common.langCode,
'default' : '',
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'lang' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'lang', this.getValue() );
}
}
}
]
},
{
type : 'text',
id : 'txtGenLongDescr',
label : editor.lang.common.longDescr,
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'longDesc' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'longDesc', this.getValue() );
}
}
},
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
type : 'text',
id : 'txtGenClass',
label : editor.lang.common.cssClass,
'default' : '',
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'class' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'class', this.getValue() );
}
}
},
{
type : 'text',
id : 'txtGenTitle',
label : editor.lang.common.advisoryTitle,
'default' : '',
onChange : function()
{
updatePreview( this.getDialog() );
},
setup : function( type, element )
{
if ( type == IMAGE )
this.setValue( element.getAttribute( 'title' ) );
},
commit : function( type, element )
{
if ( type == IMAGE )
{
if ( this.getValue() || this.isChanged() )
element.setAttribute( 'title', this.getValue() );
}
else if ( type == PREVIEW )
{
element.setAttribute( 'title', this.getValue() );
}
else if ( type == CLEANUP )
{
element.removeAttribute( 'title' );
}
}
}
]
},
{
type : 'text',
id : 'txtdlgGenStyle',
label : editor.lang.common.cssStyle,
validate : CKEDITOR.dialog.validate.inlineStyle( editor.lang.common.invalidInlineStyle ),
'default' : '',
setup : function( type, element )
{
if ( type == IMAGE )
{
var genStyle = element.getAttribute( 'style' );
if ( !genStyle && element.$.style.cssText )
genStyle = element.$.style.cssText;
this.setValue( genStyle );
var height = element.$.style.height,
width = element.$.style.width,
aMatchH = ( height ? height : '' ).match( regexGetSize ),
aMatchW = ( width ? width : '').match( regexGetSize );
this.attributesInStyle =
{
height : !!aMatchH,
width : !!aMatchW
};
}
},
onChange : function ()
{
commitInternally.call( this,
[ 'info:cmbFloat', 'info:cmbAlign',
'info:txtVSpace', 'info:txtHSpace',
'info:txtBorder',
'info:txtWidth', 'info:txtHeight' ] );
updatePreview( this );
},
commit : function( type, element )
{
if ( type == IMAGE && ( this.getValue() || this.isChanged() ) )
{
element.setAttribute( 'style', this.getValue() );
}
}
}
]
}
]
};
};
CKEDITOR.dialog.add( 'image', function( editor )
{
return imageDialog( editor, 'image' );
});
CKEDITOR.dialog.add( 'imagebutton', function( editor )
{
return imageDialog( editor, 'imagebutton' );
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Insert and remove numbered and bulleted lists.
*/
(function()
{
var listNodeNames = { ol : 1, ul : 1 },
emptyTextRegex = /^[\n\r\t ]*$/;
var whitespaces = CKEDITOR.dom.walker.whitespaces(),
bookmarks = CKEDITOR.dom.walker.bookmark(),
nonEmpty = function( node ){ return !( whitespaces( node ) || bookmarks( node ) );},
blockBogus = CKEDITOR.dom.walker.bogus();
function cleanUpDirection( element )
{
var dir, parent, parentDir;
if ( ( dir = element.getDirection() ) )
{
parent = element.getParent();
while ( parent && !( parentDir = parent.getDirection() ) )
parent = parent.getParent();
if ( dir == parentDir )
element.removeAttribute( 'dir' );
}
}
// Inheirt inline styles from another element.
function inheirtInlineStyles( parent, el )
{
var style = parent.getAttribute( 'style' );
// Put parent styles before child styles.
style && el.setAttribute( 'style',
style.replace( /([^;])$/, '$1;' ) +
( el.getAttribute( 'style' ) || '' ) );
}
CKEDITOR.plugins.list = {
/*
* Convert a DOM list tree into a data structure that is easier to
* manipulate. This operation should be non-intrusive in the sense that it
* does not change the DOM tree, with the exception that it may add some
* markers to the list item nodes when database is specified.
*/
listToArray : function( listNode, database, baseArray, baseIndentLevel, grandparentNode )
{
if ( !listNodeNames[ listNode.getName() ] )
return [];
if ( !baseIndentLevel )
baseIndentLevel = 0;
if ( !baseArray )
baseArray = [];
// Iterate over all list items to and look for inner lists.
for ( var i = 0, count = listNode.getChildCount() ; i < count ; i++ )
{
var listItem = listNode.getChild( i );
// Fixing malformed nested lists by moving it into a previous list item. (#6236)
if( listItem.type == CKEDITOR.NODE_ELEMENT && listItem.getName() in CKEDITOR.dtd.$list )
CKEDITOR.plugins.list.listToArray( listItem, database, baseArray, baseIndentLevel + 1 );
// It may be a text node or some funny stuff.
if ( listItem.$.nodeName.toLowerCase() != 'li' )
continue;
var itemObj = { 'parent' : listNode, indent : baseIndentLevel, element : listItem, contents : [] };
if ( !grandparentNode )
{
itemObj.grandparent = listNode.getParent();
if ( itemObj.grandparent && itemObj.grandparent.$.nodeName.toLowerCase() == 'li' )
itemObj.grandparent = itemObj.grandparent.getParent();
}
else
itemObj.grandparent = grandparentNode;
if ( database )
CKEDITOR.dom.element.setMarker( database, listItem, 'listarray_index', baseArray.length );
baseArray.push( itemObj );
for ( var j = 0, itemChildCount = listItem.getChildCount(), child; j < itemChildCount ; j++ )
{
child = listItem.getChild( j );
if ( child.type == CKEDITOR.NODE_ELEMENT && listNodeNames[ child.getName() ] )
// Note the recursion here, it pushes inner list items with
// +1 indentation in the correct order.
CKEDITOR.plugins.list.listToArray( child, database, baseArray, baseIndentLevel + 1, itemObj.grandparent );
else
itemObj.contents.push( child );
}
}
return baseArray;
},
// Convert our internal representation of a list back to a DOM forest.
arrayToList : function( listArray, database, baseIndex, paragraphMode, dir )
{
if ( !baseIndex )
baseIndex = 0;
if ( !listArray || listArray.length < baseIndex + 1 )
return null;
var i,
doc = listArray[ baseIndex ].parent.getDocument(),
retval = new CKEDITOR.dom.documentFragment( doc ),
rootNode = null,
currentIndex = baseIndex,
indentLevel = Math.max( listArray[ baseIndex ].indent, 0 ),
currentListItem = null,
orgDir,
block,
paragraphName = ( paragraphMode == CKEDITOR.ENTER_P ? 'p' : 'div' );
while ( 1 )
{
var item = listArray[ currentIndex ],
itemGrandParent = item.grandparent;
orgDir = item.element.getDirection( 1 );
if ( item.indent == indentLevel )
{
if ( !rootNode || listArray[ currentIndex ].parent.getName() != rootNode.getName() )
{
rootNode = listArray[ currentIndex ].parent.clone( false, 1 );
dir && rootNode.setAttribute( 'dir', dir );
retval.append( rootNode );
}
currentListItem = rootNode.append( item.element.clone( 0, 1 ) );
if ( orgDir != rootNode.getDirection( 1 ) )
currentListItem.setAttribute( 'dir', orgDir );
for ( i = 0 ; i < item.contents.length ; i++ )
currentListItem.append( item.contents[i].clone( 1, 1 ) );
currentIndex++;
}
else if ( item.indent == Math.max( indentLevel, 0 ) + 1 )
{
// Maintain original direction (#6861).
var currDir = listArray[ currentIndex - 1 ].element.getDirection( 1 ),
listData = CKEDITOR.plugins.list.arrayToList( listArray, null, currentIndex, paragraphMode,
currDir != orgDir ? orgDir: null );
// If the next block is an <li> with another list tree as the first
// child, we'll need to append a filler (<br>/NBSP) or the list item
// wouldn't be editable. (#6724)
if ( !currentListItem.getChildCount() && CKEDITOR.env.ie && !( doc.$.documentMode > 7 ))
currentListItem.append( doc.createText( '\xa0' ) );
currentListItem.append( listData.listNode );
currentIndex = listData.nextIndex;
}
else if ( item.indent == -1 && !baseIndex && itemGrandParent )
{
if ( listNodeNames[ itemGrandParent.getName() ] )
{
currentListItem = item.element.clone( false, true );
if ( orgDir != itemGrandParent.getDirection( 1 ) )
currentListItem.setAttribute( 'dir', orgDir );
}
else
currentListItem = new CKEDITOR.dom.documentFragment( doc );
// Migrate all children to the new container,
// apply the proper text direction.
var dirLoose = itemGrandParent.getDirection( 1 ) != orgDir,
li = item.element,
className = li.getAttribute( 'class' ),
style = li.getAttribute( 'style' );
var needsBlock = currentListItem.type ==
CKEDITOR.NODE_DOCUMENT_FRAGMENT &&
( paragraphMode != CKEDITOR.ENTER_BR || dirLoose ||
style || className );
var child, count = item.contents.length;
for ( i = 0 ; i < count; i++ )
{
child = item.contents[ i ];
if ( child.type == CKEDITOR.NODE_ELEMENT && child.isBlockBoundary() )
{
// Apply direction on content blocks.
if ( dirLoose && !child.getDirection() )
child.setAttribute( 'dir', orgDir );
inheirtInlineStyles( li, child );
className && child.addClass( className );
}
else if ( needsBlock )
{
// Establish new block to hold text direction and styles.
if ( !block )
{
block = doc.createElement( paragraphName );
dirLoose && block.setAttribute( 'dir', orgDir );
}
// Copy over styles to new block;
style && block.setAttribute( 'style', style );
className && block.setAttribute( 'class', className );
block.append( child.clone( 1, 1 ) );
}
currentListItem.append( block || child.clone( 1, 1 ) );
}
if ( currentListItem.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT
&& currentIndex != listArray.length - 1 )
{
var last = currentListItem.getLast();
if ( last && last.type == CKEDITOR.NODE_ELEMENT
&& last.getAttribute( 'type' ) == '_moz' )
{
last.remove();
}
if ( !( last = currentListItem.getLast( nonEmpty )
&& last.type == CKEDITOR.NODE_ELEMENT
&& last.getName() in CKEDITOR.dtd.$block ) )
{
currentListItem.append( doc.createElement( 'br' ) );
}
}
var currentListItemName = currentListItem.$.nodeName.toLowerCase();
if ( !CKEDITOR.env.ie && ( currentListItemName == 'div' || currentListItemName == 'p' ) )
currentListItem.appendBogus();
retval.append( currentListItem );
rootNode = null;
currentIndex++;
}
else
return null;
block = null;
if ( listArray.length <= currentIndex || Math.max( listArray[ currentIndex ].indent, 0 ) < indentLevel )
break;
}
if ( database )
{
var currentNode = retval.getFirst(),
listRoot = listArray[ 0 ].parent;
while ( currentNode )
{
if ( currentNode.type == CKEDITOR.NODE_ELEMENT )
{
// Clear marker attributes for the new list tree made of cloned nodes, if any.
CKEDITOR.dom.element.clearMarkers( database, currentNode );
// Clear redundant direction attribute specified on list items.
if ( currentNode.getName() in CKEDITOR.dtd.$listItem )
cleanUpDirection( currentNode );
}
currentNode = currentNode.getNextSourceNode();
}
}
return { listNode : retval, nextIndex : currentIndex };
}
};
function onSelectionChange( evt )
{
if ( evt.editor.readOnly )
return null;
var path = evt.data.path,
blockLimit = path.blockLimit,
elements = path.elements,
element,
i;
// Grouping should only happen under blockLimit.(#3940).
for ( i = 0 ; i < elements.length && ( element = elements[ i ] )
&& !element.equals( blockLimit ); i++ )
{
if ( listNodeNames[ elements[ i ].getName() ] )
return this.setState( this.type == elements[ i ].getName() ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF );
}
return this.setState( CKEDITOR.TRISTATE_OFF );
}
function changeListType( editor, groupObj, database, listsCreated )
{
// This case is easy...
// 1. Convert the whole list into a one-dimensional array.
// 2. Change the list type by modifying the array.
// 3. Recreate the whole list by converting the array to a list.
// 4. Replace the original list with the recreated list.
var listArray = CKEDITOR.plugins.list.listToArray( groupObj.root, database ),
selectedListItems = [];
for ( var i = 0 ; i < groupObj.contents.length ; i++ )
{
var itemNode = groupObj.contents[i];
itemNode = itemNode.getAscendant( 'li', true );
if ( !itemNode || itemNode.getCustomData( 'list_item_processed' ) )
continue;
selectedListItems.push( itemNode );
CKEDITOR.dom.element.setMarker( database, itemNode, 'list_item_processed', true );
}
var root = groupObj.root,
doc = root.getDocument(),
listNode,
newListNode;
for ( i = 0 ; i < selectedListItems.length ; i++ )
{
var listIndex = selectedListItems[i].getCustomData( 'listarray_index' );
listNode = listArray[ listIndex ].parent;
// Switch to new list node for this particular item.
if ( !listNode.is( this.type ) )
{
newListNode = doc.createElement( this.type );
// Copy all attributes, except from 'start' and 'type'.
listNode.copyAttributes( newListNode, { start : 1, type : 1 } );
// The list-style-type property should be ignored.
newListNode.removeStyle( 'list-style-type' );
listArray[ listIndex ].parent = newListNode;
}
}
var newList = CKEDITOR.plugins.list.arrayToList( listArray, database, null, editor.config.enterMode );
var child, length = newList.listNode.getChildCount();
for ( i = 0 ; i < length && ( child = newList.listNode.getChild( i ) ) ; i++ )
{
if ( child.getName() == this.type )
listsCreated.push( child );
}
newList.listNode.replace( groupObj.root );
}
var headerTagRegex = /^h[1-6]$/;
function createList( editor, groupObj, listsCreated )
{
var contents = groupObj.contents,
doc = groupObj.root.getDocument(),
listContents = [];
// It is possible to have the contents returned by DomRangeIterator to be the same as the root.
// e.g. when we're running into table cells.
// In such a case, enclose the childNodes of contents[0] into a <div>.
if ( contents.length == 1 && contents[0].equals( groupObj.root ) )
{
var divBlock = doc.createElement( 'div' );
contents[0].moveChildren && contents[0].moveChildren( divBlock );
contents[0].append( divBlock );
contents[0] = divBlock;
}
// Calculate the common parent node of all content blocks.
var commonParent = groupObj.contents[0].getParent();
for ( var i = 0 ; i < contents.length ; i++ )
commonParent = commonParent.getCommonAncestor( contents[i].getParent() );
var useComputedState = editor.config.useComputedState,
listDir, explicitDirection;
useComputedState = useComputedState === undefined || useComputedState;
// We want to insert things that are in the same tree level only, so calculate the contents again
// by expanding the selected blocks to the same tree level.
for ( i = 0 ; i < contents.length ; i++ )
{
var contentNode = contents[i],
parentNode;
while ( ( parentNode = contentNode.getParent() ) )
{
if ( parentNode.equals( commonParent ) )
{
listContents.push( contentNode );
// Determine the lists's direction.
if ( !explicitDirection && contentNode.getDirection() )
explicitDirection = 1;
var itemDir = contentNode.getDirection( useComputedState );
if ( listDir !== null )
{
// If at least one LI have a different direction than current listDir, we can't have listDir.
if ( listDir && listDir != itemDir )
listDir = null;
else
listDir = itemDir;
}
break;
}
contentNode = parentNode;
}
}
if ( listContents.length < 1 )
return;
// Insert the list to the DOM tree.
var insertAnchor = listContents[ listContents.length - 1 ].getNext(),
listNode = doc.createElement( this.type );
listsCreated.push( listNode );
var contentBlock, listItem;
while ( listContents.length )
{
contentBlock = listContents.shift();
listItem = doc.createElement( 'li' );
// Preserve preformat block and heading structure when converting to list item. (#5335) (#5271)
if ( contentBlock.is( 'pre' ) || headerTagRegex.test( contentBlock.getName() ) )
contentBlock.appendTo( listItem );
else
{
contentBlock.copyAttributes( listItem );
// Remove direction attribute after it was merged into list root. (#7657)
if ( listDir && contentBlock.getDirection() )
{
listItem.removeStyle( 'direction' );
listItem.removeAttribute( 'dir' );
}
contentBlock.moveChildren( listItem );
contentBlock.remove();
}
listItem.appendTo( listNode );
}
// Apply list root dir only if it has been explicitly declared.
if ( listDir && explicitDirection )
listNode.setAttribute( 'dir', listDir );
if ( insertAnchor )
listNode.insertBefore( insertAnchor );
else
listNode.appendTo( commonParent );
}
function removeList( editor, groupObj, database )
{
// This is very much like the change list type operation.
// Except that we're changing the selected items' indent to -1 in the list array.
var listArray = CKEDITOR.plugins.list.listToArray( groupObj.root, database ),
selectedListItems = [];
for ( var i = 0 ; i < groupObj.contents.length ; i++ )
{
var itemNode = groupObj.contents[i];
itemNode = itemNode.getAscendant( 'li', true );
if ( !itemNode || itemNode.getCustomData( 'list_item_processed' ) )
continue;
selectedListItems.push( itemNode );
CKEDITOR.dom.element.setMarker( database, itemNode, 'list_item_processed', true );
}
var lastListIndex = null;
for ( i = 0 ; i < selectedListItems.length ; i++ )
{
var listIndex = selectedListItems[i].getCustomData( 'listarray_index' );
listArray[listIndex].indent = -1;
lastListIndex = listIndex;
}
// After cutting parts of the list out with indent=-1, we still have to maintain the array list
// model's nextItem.indent <= currentItem.indent + 1 invariant. Otherwise the array model of the
// list cannot be converted back to a real DOM list.
for ( i = lastListIndex + 1 ; i < listArray.length ; i++ )
{
if ( listArray[i].indent > listArray[i-1].indent + 1 )
{
var indentOffset = listArray[i-1].indent + 1 - listArray[i].indent;
var oldIndent = listArray[i].indent;
while ( listArray[i] && listArray[i].indent >= oldIndent )
{
listArray[i].indent += indentOffset;
i++;
}
i--;
}
}
var newList = CKEDITOR.plugins.list.arrayToList( listArray, database, null, editor.config.enterMode,
groupObj.root.getAttribute( 'dir' ) );
// Compensate <br> before/after the list node if the surrounds are non-blocks.(#3836)
var docFragment = newList.listNode, boundaryNode, siblingNode;
function compensateBrs( isStart )
{
if ( ( boundaryNode = docFragment[ isStart ? 'getFirst' : 'getLast' ]() )
&& !( boundaryNode.is && boundaryNode.isBlockBoundary() )
&& ( siblingNode = groupObj.root[ isStart ? 'getPrevious' : 'getNext' ]
( CKEDITOR.dom.walker.whitespaces( true ) ) )
&& !( siblingNode.is && siblingNode.isBlockBoundary( { br : 1 } ) ) )
editor.document.createElement( 'br' )[ isStart ? 'insertBefore' : 'insertAfter' ]( boundaryNode );
}
compensateBrs( true );
compensateBrs();
docFragment.replace( groupObj.root );
}
function listCommand( name, type )
{
this.name = name;
this.type = type;
}
var elementType = CKEDITOR.dom.walker.nodeType( CKEDITOR.NODE_ELEMENT );
// Merge child nodes with direction preserved. (#7448)
function mergeChildren( from, into, refNode, forward )
{
var child, itemDir;
while ( ( child = from[ forward ? 'getLast' : 'getFirst' ]( elementType ) ) )
{
if ( ( itemDir = child.getDirection( 1 ) ) !== into.getDirection( 1 ) )
child.setAttribute( 'dir', itemDir );
child.remove();
refNode ?
child[ forward ? 'insertBefore' : 'insertAfter' ]( refNode ) :
into.append( child, forward );
}
}
listCommand.prototype = {
exec : function( editor )
{
var doc = editor.document,
config = editor.config,
selection = editor.getSelection(),
ranges = selection && selection.getRanges( true );
// There should be at least one selected range.
if ( !ranges || ranges.length < 1 )
return;
// Midas lists rule #1 says we can create a list even in an empty document.
// But DOM iterator wouldn't run if the document is really empty.
// So create a paragraph if the document is empty and we're going to create a list.
if ( this.state == CKEDITOR.TRISTATE_OFF )
{
var body = doc.getBody();
if ( !body.getFirst( nonEmpty ) )
{
config.enterMode == CKEDITOR.ENTER_BR ?
body.appendBogus() :
ranges[ 0 ].fixBlock( 1, config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' );
selection.selectRanges( ranges );
}
// Maybe a single range there enclosing the whole list,
// turn on the list state manually(#4129).
else
{
var range = ranges.length == 1 && ranges[ 0 ],
enclosedNode = range && range.getEnclosedNode();
if ( enclosedNode && enclosedNode.is
&& this.type == enclosedNode.getName() )
this.setState( CKEDITOR.TRISTATE_ON );
}
}
var bookmarks = selection.createBookmarks( true );
// Group the blocks up because there are many cases where multiple lists have to be created,
// or multiple lists have to be cancelled.
var listGroups = [],
database = {},
rangeIterator = ranges.createIterator(),
index = 0;
while ( ( range = rangeIterator.getNextRange() ) && ++index )
{
var boundaryNodes = range.getBoundaryNodes(),
startNode = boundaryNodes.startNode,
endNode = boundaryNodes.endNode;
if ( startNode.type == CKEDITOR.NODE_ELEMENT && startNode.getName() == 'td' )
range.setStartAt( boundaryNodes.startNode, CKEDITOR.POSITION_AFTER_START );
if ( endNode.type == CKEDITOR.NODE_ELEMENT && endNode.getName() == 'td' )
range.setEndAt( boundaryNodes.endNode, CKEDITOR.POSITION_BEFORE_END );
var iterator = range.createIterator(),
block;
iterator.forceBrBreak = ( this.state == CKEDITOR.TRISTATE_OFF );
while ( ( block = iterator.getNextParagraph() ) )
{
// Avoid duplicate blocks get processed across ranges.
if( block.getCustomData( 'list_block' ) )
continue;
else
CKEDITOR.dom.element.setMarker( database, block, 'list_block', 1 );
var path = new CKEDITOR.dom.elementPath( block ),
pathElements = path.elements,
pathElementsCount = pathElements.length,
listNode = null,
processedFlag = 0,
blockLimit = path.blockLimit,
element;
// First, try to group by a list ancestor.
for ( var i = pathElementsCount - 1; i >= 0 && ( element = pathElements[ i ] ); i-- )
{
if ( listNodeNames[ element.getName() ]
&& blockLimit.contains( element ) ) // Don't leak outside block limit (#3940).
{
// If we've encountered a list inside a block limit
// The last group object of the block limit element should
// no longer be valid. Since paragraphs after the list
// should belong to a different group of paragraphs before
// the list. (Bug #1309)
blockLimit.removeCustomData( 'list_group_object_' + index );
var groupObj = element.getCustomData( 'list_group_object' );
if ( groupObj )
groupObj.contents.push( block );
else
{
groupObj = { root : element, contents : [ block ] };
listGroups.push( groupObj );
CKEDITOR.dom.element.setMarker( database, element, 'list_group_object', groupObj );
}
processedFlag = 1;
break;
}
}
if ( processedFlag )
continue;
// No list ancestor? Group by block limit, but don't mix contents from different ranges.
var root = blockLimit;
if ( root.getCustomData( 'list_group_object_' + index ) )
root.getCustomData( 'list_group_object_' + index ).contents.push( block );
else
{
groupObj = { root : root, contents : [ block ] };
CKEDITOR.dom.element.setMarker( database, root, 'list_group_object_' + index, groupObj );
listGroups.push( groupObj );
}
}
}
// Now we have two kinds of list groups, groups rooted at a list, and groups rooted at a block limit element.
// We either have to build lists or remove lists, for removing a list does not makes sense when we are looking
// at the group that's not rooted at lists. So we have three cases to handle.
var listsCreated = [];
while ( listGroups.length > 0 )
{
groupObj = listGroups.shift();
if ( this.state == CKEDITOR.TRISTATE_OFF )
{
if ( listNodeNames[ groupObj.root.getName() ] )
changeListType.call( this, editor, groupObj, database, listsCreated );
else
createList.call( this, editor, groupObj, listsCreated );
}
else if ( this.state == CKEDITOR.TRISTATE_ON && listNodeNames[ groupObj.root.getName() ] )
removeList.call( this, editor, groupObj, database );
}
// For all new lists created, merge into adjacent, same type lists.
for ( i = 0 ; i < listsCreated.length ; i++ )
mergeListSiblings( listsCreated[ i ] );
// Clean up, restore selection and update toolbar button states.
CKEDITOR.dom.element.clearAllMarkers( database );
selection.selectBookmarks( bookmarks );
editor.focus();
}
};
// Merge list adjacent, of same type lists.
function mergeListSiblings( listNode )
{
var mergeSibling;
( mergeSibling = function( rtl )
{
var sibling = listNode[ rtl ? 'getPrevious' : 'getNext' ]( nonEmpty );
if ( sibling && sibling.type == CKEDITOR.NODE_ELEMENT &&
sibling.is( listNode.getName() ) )
{
// Move children order by merge direction.(#3820)
mergeChildren( listNode, sibling, null, !rtl );
listNode.remove();
listNode = sibling;
}
} )();
mergeSibling( 1 );
}
var dtd = CKEDITOR.dtd;
var tailNbspRegex = /[\t\r\n ]*(?: |\xa0)$/;
function indexOfFirstChildElement( element, tagNameList )
{
var child,
children = element.children,
length = children.length;
for ( var i = 0 ; i < length ; i++ )
{
child = children[ i ];
if ( child.name && ( child.name in tagNameList ) )
return i;
}
return length;
}
function getExtendNestedListFilter( isHtmlFilter )
{
// An element filter function that corrects nested list start in an empty
// list item for better displaying/outputting. (#3165)
return function( listItem )
{
var children = listItem.children,
firstNestedListIndex = indexOfFirstChildElement( listItem, dtd.$list ),
firstNestedList = children[ firstNestedListIndex ],
nodeBefore = firstNestedList && firstNestedList.previous,
tailNbspmatch;
if ( nodeBefore
&& ( nodeBefore.name && nodeBefore.name == 'br'
|| nodeBefore.value && ( tailNbspmatch = nodeBefore.value.match( tailNbspRegex ) ) ) )
{
var fillerNode = nodeBefore;
// Always use 'nbsp' as filler node if we found a nested list appear
// in front of a list item.
if ( !( tailNbspmatch && tailNbspmatch.index ) && fillerNode == children[ 0 ] )
children[ 0 ] = ( isHtmlFilter || CKEDITOR.env.ie ) ?
new CKEDITOR.htmlParser.text( '\xa0' ) :
new CKEDITOR.htmlParser.element( 'br', {} );
// Otherwise the filler is not needed anymore.
else if ( fillerNode.name == 'br' )
children.splice( firstNestedListIndex - 1, 1 );
else
fillerNode.value = fillerNode.value.replace( tailNbspRegex, '' );
}
};
}
var defaultListDataFilterRules = { elements : {} };
for ( var i in dtd.$listItem )
defaultListDataFilterRules.elements[ i ] = getExtendNestedListFilter();
var defaultListHtmlFilterRules = { elements : {} };
for ( i in dtd.$listItem )
defaultListHtmlFilterRules.elements[ i ] = getExtendNestedListFilter( true );
// Check if node is block element that recieves text.
function isTextBlock( node )
{
return node.type == CKEDITOR.NODE_ELEMENT &&
( node.getName() in CKEDITOR.dtd.$block ||
node.getName() in CKEDITOR.dtd.$listItem ) &&
CKEDITOR.dtd[ node.getName() ][ '#' ];
}
// Merge the visual line content at the cursor range into the block.
function joinNextLineToCursor( editor, cursor, nextCursor )
{
editor.fire( 'saveSnapshot' );
// Merge with previous block's content.
nextCursor.enlarge( CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS );
var frag = nextCursor.extractContents();
cursor.trim( false, true );
var bm = cursor.createBookmark();
// Kill original bogus;
var currentPath = new CKEDITOR.dom.elementPath( cursor.startContainer );
var currentLi = currentPath.lastElement.getAscendant( 'li', 1 );
var bogus = currentPath.block.getBogus();
bogus && bogus.remove();
// Kill the tail br in extracted.
var last = frag.getLast();
if ( last && last.type == CKEDITOR.NODE_ELEMENT && last.is( 'br' ) )
last.remove();
// Insert fragment at the range position.
var nextNode = cursor.startContainer.getChild( cursor.startOffset );
if ( nextNode )
frag.insertBefore( nextNode );
else
cursor.startContainer.append( frag );
var nextPath = new CKEDITOR.dom.elementPath( nextCursor.startContainer );
var nextLi = nextCursor.startContainer.getAscendant( 'li', 1 );
// Move the sub list nested in the next list item.
if ( nextLi )
{
var sublist = getSubList( nextLi );
if ( sublist )
{
// If next line is in the sub list of the current list item.
if ( currentLi.contains( nextLi ) )
{
mergeChildren( sublist, nextLi.getParent(), nextLi );
sublist.remove();
}
// Migrate the sub list to current list item.
else
currentLi.append( sublist );
}
}
// Remove any remaining empty path blocks at next line after merging.
while ( nextCursor.checkStartOfBlock() &&
nextCursor.checkEndOfBlock() )
{
nextPath = new CKEDITOR.dom.elementPath( nextCursor.startContainer );
var nextBlock = nextPath.block, parent;
// Check if also to remove empty list.
if ( nextBlock.is( 'li' ) )
{
parent = nextBlock.getParent();
if ( nextBlock.equals( parent.getLast( nonEmpty ) )
&& nextBlock.equals( parent.getFirst( nonEmpty ) ) )
nextBlock = parent;
}
nextCursor.moveToPosition( nextBlock, CKEDITOR.POSITION_BEFORE_START );
nextBlock.remove();
}
// Check if need to further merge with the list resides after the merged block. (#9080)
var walkerRng = nextCursor.clone(), body = editor.document.getBody();
walkerRng.setEndAt( body, CKEDITOR.POSITION_BEFORE_END );
var walker = new CKEDITOR.dom.walker( walkerRng );
walker.evaluator = function( node ) { return nonEmpty( node ) && !blockBogus( node ); };
var next = walker.next();
if ( next && next.type == CKEDITOR.NODE_ELEMENT && next.getName() in CKEDITOR.dtd.$list )
mergeListSiblings( next );
cursor.moveToBookmark( bm );
// Make fresh selection.
cursor.select();
editor.selectionChange( 1 );
editor.fire( 'saveSnapshot' );
}
function getSubList( li )
{
var last = li.getLast( nonEmpty );
return last && last.type == CKEDITOR.NODE_ELEMENT && last.getName() in listNodeNames ? last : null;
}
CKEDITOR.plugins.add( 'list',
{
init : function( editor )
{
// Register commands.
var numberedListCommand = editor.addCommand( 'numberedlist', new listCommand( 'numberedlist', 'ol' ) ),
bulletedListCommand = editor.addCommand( 'bulletedlist', new listCommand( 'bulletedlist', 'ul' ) );
// Register the toolbar button.
editor.ui.addButton( 'NumberedList',
{
label : editor.lang.numberedlist,
command : 'numberedlist'
} );
editor.ui.addButton( 'BulletedList',
{
label : editor.lang.bulletedlist,
command : 'bulletedlist'
} );
// Register the state changing handlers.
editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, numberedListCommand ) );
editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, bulletedListCommand ) );
// Handled backspace/del key to join list items. (#8248,#9080)
editor.on( 'key', function( evt )
{
var key = evt.data.keyCode;
// DEl/BACKSPACE
if ( editor.mode == 'wysiwyg' && key in { 8 : 1, 46 : 1 } )
{
var sel = editor.getSelection(),
range = sel.getRanges()[ 0 ];
if ( !range.collapsed )
return;
var isBackspace = key == 8;
var body = editor.document.getBody();
var walker = new CKEDITOR.dom.walker( range.clone() );
walker.evaluator = function( node ) { return nonEmpty( node ) && !blockBogus( node ); };
var cursor = range.clone();
if ( isBackspace )
{
var previous, joinWith;
var path = new CKEDITOR.dom.elementPath( range.startContainer );
// Join a sub list's first line, with the previous visual line in parent.
if ( ( previous = path.contains( listNodeNames ) ) &&
range.checkBoundaryOfElement( previous, CKEDITOR.START ) &&
( previous = previous.getParent() ) && previous.is( 'li' ) &&
( previous = getSubList( previous ) ) )
{
joinWith = previous;
previous = previous.getPrevious( nonEmpty );
// Place cursor before the nested list.
cursor.moveToPosition(
previous && blockBogus( previous ) ? previous : joinWith,
CKEDITOR.POSITION_BEFORE_START );
}
// Join any line following a list, with the last visual line of the list.
else
{
walker.range.setStartAt( body, CKEDITOR.POSITION_AFTER_START );
walker.range.setEnd( range.startContainer, range.startOffset );
previous = walker.previous();
if ( previous && previous.type == CKEDITOR.NODE_ELEMENT &&
( previous.getName() in listNodeNames || previous.is( 'li' ) ) )
{
if ( !previous.is( 'li' ) )
{
walker.range.selectNodeContents( previous );
walker.reset();
walker.evaluator = isTextBlock;
previous = walker.previous();
}
joinWith = previous;
// Place cursor at the end of previous block.
cursor.moveToElementEditEnd( joinWith );
}
}
if ( joinWith )
{
joinNextLineToCursor( editor, cursor, range );
evt.cancel();
}
}
else
{
var li = range.startContainer.getAscendant( 'li', 1 );
if ( li )
{
walker.range.setEndAt( body, CKEDITOR.POSITION_BEFORE_END );
var last = li.getLast( nonEmpty );
var block = last && isTextBlock( last ) ? last : li;
// Indicate cursor at the visual end of an list item.
var isAtEnd = 0;
var next = walker.next();
// When list item contains a sub list.
if ( next && next.type == CKEDITOR.NODE_ELEMENT &&
next.getName() in listNodeNames
&& next.equals( last ) )
{
isAtEnd = 1;
// Move to the first item in sub list.
next = walker.next();
}
// Right at the end of list item.
else if ( range.checkBoundaryOfElement( block, CKEDITOR.END ) )
isAtEnd = 1;
if ( isAtEnd && next )
{
// Put cursor range there.
var nextLine = range.clone();
nextLine.moveToElementEditStart( next );
joinNextLineToCursor( editor, cursor, nextLine );
evt.cancel();
}
}
}
// The backspace/del could potentially put cursor at a bad position,
// being it handled or not, check immediately the selection to have it fixed.
setTimeout( function() { editor.selectionChange( 1 ); } );
}
} );
},
afterInit : function ( editor )
{
var dataProcessor = editor.dataProcessor;
if ( dataProcessor )
{
dataProcessor.dataFilter.addRules( defaultListDataFilterRules );
dataProcessor.htmlFilter.addRules( defaultListHtmlFilterRules );
}
},
requires : [ 'domiterator' ]
} );
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview The default editing block plugin, which holds the editing area
* and source view.
*/
(function()
{
// This is a semaphore used to avoid recursive calls between
// the following data handling functions.
var isHandlingData;
CKEDITOR.plugins.add( 'editingblock',
{
init : function( editor )
{
if ( !editor.config.editingBlock )
return;
editor.on( 'themeSpace', function( event )
{
if ( event.data.space == 'contents' )
event.data.html += '<br>';
});
editor.on( 'themeLoaded', function()
{
editor.fireOnce( 'editingBlockReady' );
});
editor.on( 'uiReady', function()
{
editor.setMode( editor.config.startupMode );
});
editor.on( 'afterSetData', function()
{
if ( !isHandlingData )
{
function setData()
{
isHandlingData = true;
editor.getMode().loadData( editor.getData() );
isHandlingData = false;
}
if ( editor.mode )
setData();
else
{
editor.on( 'mode', function()
{
if ( editor.mode )
{
setData();
editor.removeListener( 'mode', arguments.callee );
}
});
}
}
});
editor.on( 'beforeGetData', function()
{
if ( !isHandlingData && editor.mode )
{
isHandlingData = true;
editor.setData( editor.getMode().getData(), null, 1 );
isHandlingData = false;
}
});
editor.on( 'getSnapshot', function( event )
{
if ( editor.mode )
event.data = editor.getMode().getSnapshotData();
});
editor.on( 'loadSnapshot', function( event )
{
if ( editor.mode )
editor.getMode().loadSnapshotData( event.data );
});
// For the first "mode" call, we'll also fire the "instanceReady"
// event.
editor.on( 'mode', function( event )
{
// Do that once only.
event.removeListener();
// Redirect the focus into editor for webkit. (#5713)
CKEDITOR.env.webkit && editor.container.on( 'focus', function()
{
editor.focus();
});
if ( editor.config.startupFocus )
editor.focus();
// Fire instanceReady for both the editor and CKEDITOR, but
// defer this until the whole execution has completed
// to guarantee the editor is fully responsible.
setTimeout( function(){
editor.fireOnce( 'instanceReady' );
CKEDITOR.fire( 'instanceReady', null, editor );
}, 0 );
});
editor.on( 'destroy', function ()
{
// -> currentMode.unload( holderElement );
if ( this.mode )
this._.modes[ this.mode ].unload( this.getThemeSpace( 'contents' ) );
});
}
});
/**
* The current editing mode. An editing mode is basically a viewport for
* editing or content viewing. By default the possible values for this
* property are "wysiwyg" and "source".
* @type String
* @example
* alert( CKEDITOR.instances.editor1.mode ); // "wysiwyg" (e.g.)
*/
CKEDITOR.editor.prototype.mode = '';
/**
* Registers an editing mode. This function is to be used mainly by plugins.
* @param {String} mode The mode name.
* @param {Object} modeEditor The mode editor definition.
* @example
*/
CKEDITOR.editor.prototype.addMode = function( mode, modeEditor )
{
modeEditor.name = mode;
( this._.modes || ( this._.modes = {} ) )[ mode ] = modeEditor;
};
/**
* Sets the current editing mode in this editor instance.
* @param {String} mode A registered mode name.
* @example
* // Switch to "source" view.
* CKEDITOR.instances.editor1.setMode( 'source' );
*/
CKEDITOR.editor.prototype.setMode = function( mode )
{
this.fire( 'beforeSetMode', { newMode : mode } );
var data,
holderElement = this.getThemeSpace( 'contents' ),
isDirty = this.checkDirty();
// Unload the previous mode.
if ( this.mode )
{
if ( mode == this.mode )
return;
this._.previousMode = this.mode;
this.fire( 'beforeModeUnload' );
var currentMode = this.getMode();
data = currentMode.getData();
currentMode.unload( holderElement );
this.mode = '';
}
holderElement.setHtml( '' );
// Load required mode.
var modeEditor = this.getMode( mode );
if ( !modeEditor )
throw '[CKEDITOR.editor.setMode] Unknown mode "' + mode + '".';
if ( !isDirty )
{
this.on( 'mode', function()
{
this.resetDirty();
this.removeListener( 'mode', arguments.callee );
});
}
modeEditor.load( holderElement, ( typeof data ) != 'string' ? this.getData() : data );
};
/**
* Gets the current or any of the objects that represent the editing
* area modes. The two most common editing modes are "wysiwyg" and "source".
* @param {String} [mode] The mode to be retrieved. If not specified, the
* current one is returned.
*/
CKEDITOR.editor.prototype.getMode = function( mode )
{
return this._.modes && this._.modes[ mode || this.mode ];
};
/**
* Moves the selection focus to the editing are space in the editor.
*/
CKEDITOR.editor.prototype.focus = function()
{
this.forceNextSelectionCheck();
var mode = this.getMode();
if ( mode )
mode.focus();
};
})();
/**
* The mode to load at the editor startup. It depends on the plugins
* loaded. By default, the "wysiwyg" and "source" modes are available.
* @type String
* @default 'wysiwyg'
* @example
* config.startupMode = 'source';
*/
CKEDITOR.config.startupMode = 'wysiwyg';
/**
* Sets whether the editor should have the focus when the page loads.
* @name CKEDITOR.config.startupFocus
* @type Boolean
* @default false
* @example
* config.startupFocus = true;
*/
/**
* Whether to render or not the editing block area in the editor interface.
* @type Boolean
* @default true
* @example
* config.editingBlock = false;
*/
CKEDITOR.config.editingBlock = true;
/**
* Fired when a CKEDITOR instance is created, fully initialized and ready for interaction.
* @name CKEDITOR#instanceReady
* @event
* @param {CKEDITOR.editor} editor The editor instance that has been created.
*/
/**
* Fired when the CKEDITOR instance is created, fully initialized and ready for interaction.
* @name CKEDITOR.editor#instanceReady
* @event
*/
/**
* Fired before changing the editing mode. See also CKEDITOR.editor#beforeSetMode and CKEDITOR.editor#mode
* @name CKEDITOR.editor#beforeModeUnload
* @event
*/
/**
* Fired before the editor mode is set. See also CKEDITOR.editor#mode and CKEDITOR.editor#beforeModeUnload
* @name CKEDITOR.editor#beforeSetMode
* @event
* @since 3.5.3
* @param {String} newMode The name of the mode which is about to be set.
*/
/**
* Fired after setting the editing mode. See also CKEDITOR.editor#beforeSetMode and CKEDITOR.editor#beforeModeUnload
* @name CKEDITOR.editor#mode
* @event
* @param {String} previousMode The previous mode of the editor.
*/
| JavaScript |
/*
Copyright (c) 2003-2012, 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.
*/
/**
* The definition of a dialog window.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create dialogs.
* </div>
* @name CKEDITOR.dialog.definition
* @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.definition.prototype.title
* @field
* @type String
* @example
*/
/**
* How the dialog can be resized, must be one of the four contents defined below.
* <br /><br />
* <strong>CKEDITOR.DIALOG_RESIZE_NONE</strong><br />
* <strong>CKEDITOR.DIALOG_RESIZE_WIDTH</strong><br />
* <strong>CKEDITOR.DIALOG_RESIZE_HEIGHT</strong><br />
* <strong>CKEDITOR.DIALOG_RESIZE_BOTH</strong><br />
* @name CKEDITOR.dialog.definition.prototype.resizable
* @field
* @type Number
* @default CKEDITOR.DIALOG_RESIZE_NONE
* @example
*/
/**
* The minimum width of the dialog, in pixels.
* @name CKEDITOR.dialog.definition.prototype.minWidth
* @field
* @type Number
* @default 600
* @example
*/
/**
* The minimum height of the dialog, in pixels.
* @name CKEDITOR.dialog.definition.prototype.minHeight
* @field
* @type Number
* @default 400
* @example
*/
/**
* The initial width of the dialog, in pixels.
* @name CKEDITOR.dialog.definition.prototype.width
* @field
* @type Number
* @default @CKEDITOR.dialog.definition.prototype.minWidth
* @since 3.5.3
* @example
*/
/**
* The initial height of the dialog, in pixels.
* @name CKEDITOR.dialog.definition.prototype.height
* @field
* @type Number
* @default @CKEDITOR.dialog.definition.prototype.minHeight
* @since 3.5.3
* @example
*/
/**
* The buttons in the dialog, defined as an array of
* {@link CKEDITOR.dialog.definition.button} objects.
* @name CKEDITOR.dialog.definition.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.definition.content} objects. Required.
* @name CKEDITOR.dialog.definition.prototype.contents
* @field
* @type Array
* @example
*/
/**
* The function to execute when OK is pressed.
* @name CKEDITOR.dialog.definition.prototype.onOk
* @field
* @type Function
* @example
*/
/**
* The function to execute when Cancel is pressed.
* @name CKEDITOR.dialog.definition.prototype.onCancel
* @field
* @type Function
* @example
*/
/**
* The function to execute when the dialog is displayed for the first time.
* @name CKEDITOR.dialog.definition.prototype.onLoad
* @field
* @type Function
* @example
*/
/**
* The function to execute when the dialog is loaded (executed every time the dialog is opened).
* @name CKEDITOR.dialog.definition.prototype.onShow
* @field
* @type Function
* @example
*/
/**
* <div class="notapi">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.</div>
* @name CKEDITOR.dialog.definition.content
* @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.definition.content.prototype.id
* @field
* @type String
* @example
*/
/**
* The tab label of the content page.
* @name CKEDITOR.dialog.definition.content.prototype.label
* @field
* @type String
* @example
*/
/**
* The popup message of the tab label.
* @name CKEDITOR.dialog.definition.content.prototype.title
* @field
* @type String
* @example
*/
/**
* The CTRL hotkey for switching to the tab.
* @name CKEDITOR.dialog.definition.content.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.definition.uiElement} objects.
* @name CKEDITOR.dialog.definition.content.prototype.elements
* @field
* @type Array
* @example
*/
/**
* The definition of user interface element (textarea, radio etc).
* <div class="notapi">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.</div>
* @name CKEDITOR.dialog.definition.uiElement
* @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.definition.uiElement.prototype.id
* @field
* @type String
* @example
*/
/**
* The type of the UI element. Required.
* @name CKEDITOR.dialog.definition.uiElement.prototype.type
* @field
* @type String
* @example
*/
/**
* The popup label of the UI element.
* @name CKEDITOR.dialog.definition.uiElement.prototype.title
* @field
* @type String
* @example
*/
/**
* CSS class names to append to the UI element.
* @name CKEDITOR.dialog.definition.uiElement.prototype.className
* @field
* @type String
* @example
*/
/**
* Inline CSS classes to append to the UI element.
* @name CKEDITOR.dialog.definition.uiElement.prototype.style
* @field
* @type String
* @example
*/
/**
* Horizontal alignment (in container) of the UI element.
* @name CKEDITOR.dialog.definition.uiElement.prototype.align
* @field
* @type String
* @example
*/
/**
* Function to execute the first time the UI element is displayed.
* @name CKEDITOR.dialog.definition.uiElement.prototype.onLoad
* @field
* @type Function
* @example
*/
/**
* Function to execute whenever the UI element's parent dialog is displayed.
* @name CKEDITOR.dialog.definition.uiElement.prototype.onShow
* @field
* @type Function
* @example
*/
/**
* Function to execute whenever the UI element's parent dialog is closed.
* @name CKEDITOR.dialog.definition.uiElement.prototype.onHide
* @field
* @type Function
* @example
*/
/**
* Function to execute whenever the UI element's parent dialog's {@link CKEDITOR.dialog.definition.setupContent} method is executed.
* It usually takes care of the respective UI element as a standalone element.
* @name CKEDITOR.dialog.definition.uiElement.prototype.setup
* @field
* @type Function
* @example
*/
/**
* Function to execute whenever the UI element's parent dialog's {@link CKEDITOR.dialog.definition.commitContent} method is executed.
* It usually takes care of the respective UI element as a standalone element.
* @name CKEDITOR.dialog.definition.uiElement.prototype.commit
* @field
* @type Function
* @example
*/
// ----- hbox -----
/**
* Horizontal layout box for dialog UI elements, auto-expends to available width of container.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create horizontal layouts.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.hbox} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* @name CKEDITOR.dialog.definition.hbox
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'hbox',</b>
* widths : [ '25%', '25%', '50%' ],
* children :
* [
* {
* type : 'text',
* id : 'id1',
* width : '40px',
* },
* {
* type : 'text',
* id : 'id2',
* width : '40px',
* },
* {
* type : 'text',
* id : 'id3'
* }
* ]
* }
*/
/**
* Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
* @name CKEDITOR.dialog.definition.hbox.prototype.children
* @field
* @type Array
* @example
*/
/**
* (Optional) The widths of child cells.
* @name CKEDITOR.dialog.definition.hbox.prototype.widths
* @field
* @type Array
* @example
*/
/**
* (Optional) The height of the layout.
* @name CKEDITOR.dialog.definition.hbox.prototype.height
* @field
* @type Number
* @example
*/
/**
* The CSS styles to apply to this element.
* @name CKEDITOR.dialog.definition.hbox.prototype.styles
* @field
* @type String
* @example
*/
/**
* (Optional) The padding width inside child cells. Example: 0, 1.
* @name CKEDITOR.dialog.definition.hbox.prototype.padding
* @field
* @type Number
* @example
*/
/**
* (Optional) The alignment of the whole layout. Example: center, top.
* @name CKEDITOR.dialog.definition.hbox.prototype.align
* @field
* @type String
* @example
*/
// ----- vbox -----
/**
* Vertical layout box for dialog UI elements.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create vertical layouts.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.vbox} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* <style type="text/css">.details .detailList {display:none;} </style>
* @name CKEDITOR.dialog.definition.vbox
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'vbox',</b>
* align : 'right',
* width : '200px',
* children :
* [
* {
* type : 'text',
* id : 'age',
* label : 'Age'
* },
* {
* type : 'text',
* id : 'sex',
* label : 'Sex'
* },
* {
* type : 'text',
* id : 'nationality',
* label : 'Nationality'
* }
* ]
* }
*/
/**
* Array of {@link CKEDITOR.ui.dialog.uiElement} objects inside this container.
* @name CKEDITOR.dialog.definition.vbox.prototype.children
* @field
* @type Array
* @example
*/
/**
* (Optional) The width of the layout.
* @name CKEDITOR.dialog.definition.vbox.prototype.width
* @field
* @type Array
* @example
*/
/**
* (Optional) The heights of individual cells.
* @name CKEDITOR.dialog.definition.vbox.prototype.heights
* @field
* @type Number
* @example
*/
/**
* The CSS styles to apply to this element.
* @name CKEDITOR.dialog.definition.vbox.prototype.styles
* @field
* @type String
* @example
*/
/**
* (Optional) The padding width inside child cells. Example: 0, 1.
* @name CKEDITOR.dialog.definition.vbox.prototype.padding
* @field
* @type Number
* @example
*/
/**
* (Optional) The alignment of the whole layout. Example: center, top.
* @name CKEDITOR.dialog.definition.vbox.prototype.align
* @field
* @type String
* @example
*/
/**
* (Optional) Whether the layout should expand vertically to fill its container.
* @name CKEDITOR.dialog.definition.vbox.prototype.expand
* @field
* @type Boolean
* @example
*/
// ----- labeled element ------
/**
* The definition of labeled user interface element (textarea, textInput etc).
* <div class="notapi">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.</div>
* @name CKEDITOR.dialog.definition.labeledElement
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @see CKEDITOR.ui.dialog.labeledElement
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*/
/**
* The label of the UI element.
* @name CKEDITOR.dialog.definition.labeledElement.prototype.label
* @type String
* @field
* @example
* {
* type : 'text',
* label : 'My Label '
* }
*/
/**
* (Optional) Specify the layout of the label. Set to 'horizontal' for horizontal layout.
* The default layout is vertical.
* @name CKEDITOR.dialog.definition.labeledElement.prototype.labelLayout
* @type String
* @field
* @example
* {
* type : 'text',
* label : 'My Label ',
* <strong> labelLayout : 'horizontal',</strong>
* }
*/
/**
* (Optional) Applies only to horizontal layouts: a two elements array of lengths to specify the widths of the
* label and the content element. See also {@link CKEDITOR.dialog.definition.labeledElement#labelLayout}.
* @name CKEDITOR.dialog.definition.labeledElement.prototype.widths
* @type Array
* @field
* @example
* {
* type : 'text',
* label : 'My Label ',
* labelLayout : 'horizontal',
* <strong> widths : [100, 200],</strong>
* }
*/
/**
* Specify the inline style of the uiElement label.
* @name CKEDITOR.dialog.definition.labeledElement.prototype.labelStyle
* @type String
* @field
* @example
* {
* type : 'text',
* label : 'My Label ',
* <strong> labelStyle : 'color: red',</strong>
* }
*/
/**
* Specify the inline style of the input element.
* @name CKEDITOR.dialog.definition.labeledElement.prototype.inputStyle
* @type String
* @since 3.6.1
* @field
* @example
* {
* type : 'text',
* label : 'My Label ',
* <strong> inputStyle : 'text-align:center',</strong>
* }
*/
/**
* Specify the inline style of the input element container .
* @name CKEDITOR.dialog.definition.labeledElement.prototype.controlStyle
* @type String
* @since 3.6.1
* @field
* @example
* {
* type : 'text',
* label : 'My Label ',
* <strong> controlStyle : 'width:3em',</strong>
* }
*/
// ----- button ------
/**
* The definition of a button.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create buttons.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.button} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.button
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'button',</b>
* id : 'buttonId',
* label : 'Click me',
* title : 'My title',
* onClick : function() {
* // this = CKEDITOR.ui.dialog.button
* alert( 'Clicked: ' + this.id );
* }
* }
*/
/**
* Whether the button is disabled.
* @name CKEDITOR.dialog.definition.button.prototype.disabled
* @type Boolean
* @field
* @example
*/
/**
* The label of the UI element.
* @name CKEDITOR.dialog.definition.button.prototype.label
* @type String
* @field
* @example
*/
// ----- checkbox ------
/**
* The definition of a checkbox element.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create groups of checkbox buttons.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.checkbox} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.checkbox
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'checkbox',</b>
* id : 'agree',
* label : 'I agree',
* 'default' : 'checked',
* onClick : function() {
* // this = CKEDITOR.ui.dialog.checkbox
* alert( 'Checked: ' + this.getValue() );
* }
* }
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.checkbox.prototype.validate
* @field
* @type Function
* @example
*/
/**
* The label of the UI element.
* @name CKEDITOR.dialog.definition.checkbox.prototype.label
* @type String
* @field
* @example
*/
/**
* The default state.
* @name CKEDITOR.dialog.definition.checkbox.prototype.default
* @type String
* @field
* @default
* '' (unchecked)
* @example
*/
// ----- file -----
/**
* The definition of a file upload input.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create file upload elements.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.file} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.file
* @extends CKEDITOR.dialog.definition.labeledElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'file'</b>,
* id : 'upload',
* label : 'Select file from your computer',
* size : 38
* },
* {
* type : 'fileButton',
* id : 'fileId',
* label : 'Upload file',
* 'for' : [ 'tab1', 'upload' ]
* filebrowser : {
* onSelect : function( fileUrl, data ) {
* alert( 'Successfully uploaded: ' + fileUrl );
* }
* }
* }
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.file.prototype.validate
* @field
* @type Function
* @example
*/
/**
* (Optional) The action attribute of the form element associated with this file upload input.
* If empty, CKEditor will use path to server connector for currently opened folder.
* @name CKEDITOR.dialog.definition.file.prototype.action
* @type String
* @field
* @example
*/
/**
* The size of the UI element.
* @name CKEDITOR.dialog.definition.file.prototype.size
* @type Number
* @field
* @example
*/
// ----- fileButton -----
/**
* The definition of a button for submitting the file in a file upload input.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create a button for submitting the file in a file upload input.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.fileButton} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.fileButton
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* type : 'file',
* id : 'upload',
* label : 'Select file from your computer',
* size : 38
* },
* {
* <b>type : 'fileButton'</b>,
* id : 'fileId',
* label : 'Upload file',
* 'for' : [ 'tab1', 'upload' ]
* filebrowser : {
* onSelect : function( fileUrl, data ) {
* alert( 'Successfully uploaded: ' + fileUrl );
* }
* }
* }
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.fileButton.prototype.validate
* @field
* @type Function
* @example
*/
/**
* The label of the UI element.
* @name CKEDITOR.dialog.definition.fileButton.prototype.label
* @type String
* @field
* @example
*/
/**
* The instruction for CKEditor how to deal with file upload.
* By default, the file and fileButton elements will not work "as expected" if this attribute is not set.
* @name CKEDITOR.dialog.definition.fileButton.prototype.filebrowser
* @type String|Object
* @field
* @example
* // Update field with id 'txtUrl' in the 'tab1' tab when file is uploaded.
* filebrowser : 'tab1:txtUrl'
*
* // Call custom onSelect function when file is successfully uploaded.
* filebrowser : {
* onSelect : function( fileUrl, data ) {
* alert( 'Successfully uploaded: ' + fileUrl );
* }
* }
*/
/**
* An array that contains pageId and elementId of the file upload input element for which this button is created.
* @name CKEDITOR.dialog.definition.fileButton.prototype.for
* @type String
* @field
* @example
* [ pageId, elementId ]
*/
// ----- html -----
/**
* The definition of a raw HTML element.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create elements made from raw HTML code.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.html} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.<br />
* To access HTML elements use {@link CKEDITOR.dom.document#getById}
* @name CKEDITOR.dialog.definition.html
* @extends CKEDITOR.dialog.definition.uiElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example 1:
* {
* <b>type : 'html',</b>
* html : '<h3>This is some sample HTML content.</h3>'
* }
* @example
* // Example 2:
* // Complete sample with document.getById() call when the "Ok" button is clicked.
* var dialogDefinition =
* {
* title : 'Sample dialog',
* minWidth : 300,
* minHeight : 200,
* onOk : function() {
* // "this" is now a CKEDITOR.dialog object.
* var document = this.getElement().getDocument();
* // document = CKEDITOR.dom.document
* var element = <b>document.getById( 'myDiv' );</b>
* if ( element )
* alert( element.getHtml() );
* },
* contents : [
* {
* id : 'tab1',
* label : '',
* title : '',
* elements :
* [
* {
* <b>type : 'html',</b>
* html : '<b><div id="myDiv">Sample <b>text</b>.</div></b><div id="otherId">Another div.</div>'
* },
* ]
* }
* ],
* buttons : [ CKEDITOR.dialog.cancelButton, CKEDITOR.dialog.okButton ]
* };
*/
/**
* (Required) HTML code of this element.
* @name CKEDITOR.dialog.definition.html.prototype.html
* @type String
* @field
* @example
*/
// ----- radio ------
/**
* The definition of a radio group.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create groups of radio buttons.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.radio} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.radio
* @extends CKEDITOR.dialog.definition.labeledElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'radio',</b>
* id : 'country',
* label : 'Which country is bigger',
* items : [ [ 'France', 'FR' ], [ 'Germany', 'DE' ] ] ,
* style : 'color:green',
* 'default' : 'DE',
* onClick : function() {
* // this = CKEDITOR.ui.dialog.radio
* alert( 'Current value: ' + this.getValue() );
* }
* }
*/
/**
* The default value.
* @name CKEDITOR.dialog.definition.radio.prototype.default
* @type String
* @field
* @example
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.radio.prototype.validate
* @field
* @type Function
* @example
*/
/**
* An array of options. Each option is a 1- or 2-item array of format [ 'Description', 'Value' ]. If 'Value' is missing, then the value would be assumed to be the same as the description.
* @name CKEDITOR.dialog.definition.radio.prototype.items
* @field
* @type Array
* @example
*/
// ----- selectElement ------
/**
* The definition of a select element.
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create select elements.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.select} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.select
* @extends CKEDITOR.dialog.definition.labeledElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'select',</b>
* id : 'sport',
* label : 'Select your favourite sport',
* items : [ [ 'Basketball' ], [ 'Baseball' ], [ 'Hockey' ], [ 'Football' ] ],
* 'default' : 'Football',
* onChange : function( api ) {
* // this = CKEDITOR.ui.dialog.select
* alert( 'Current value: ' + this.getValue() );
* }
* }
*/
/**
* The default value.
* @name CKEDITOR.dialog.definition.select.prototype.default
* @type String
* @field
* @example
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.select.prototype.validate
* @field
* @type Function
* @example
*/
/**
* An array of options. Each option is a 1- or 2-item array of format [ 'Description', 'Value' ]. If 'Value' is missing, then the value would be assumed to be the same as the description.
* @name CKEDITOR.dialog.definition.select.prototype.items
* @field
* @type Array
* @example
*/
/**
* (Optional) Set this to true if you'd like to have a multiple-choice select box.
* @name CKEDITOR.dialog.definition.select.prototype.multiple
* @type Boolean
* @field
* @example
* @default false
*/
/**
* (Optional) The number of items to display in the select box.
* @name CKEDITOR.dialog.definition.select.prototype.size
* @type Number
* @field
* @example
*/
// ----- textInput -----
/**
* The definition of a text field (single line).
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create text fields.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.textInput} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.textInput
* @extends CKEDITOR.dialog.definition.labeledElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* {
* <b>type : 'text',</b>
* id : 'name',
* label : 'Your name',
* 'default' : '',
* validate : function() {
* if ( !this.getValue() )
* {
* api.openMsgDialog( '', 'Name cannot be empty.' );
* return false;
* }
* }
* }
*/
/**
* The default value.
* @name CKEDITOR.dialog.definition.textInput.prototype.default
* @type String
* @field
* @example
*/
/**
* (Optional) The maximum length.
* @name CKEDITOR.dialog.definition.textInput.prototype.maxLength
* @type Number
* @field
* @example
*/
/**
* (Optional) The size of the input field.
* @name CKEDITOR.dialog.definition.textInput.prototype.size
* @type Number
* @field
* @example
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.textInput.prototype.validate
* @field
* @type Function
* @example
*/
// ----- textarea ------
/**
* The definition of a text field (multiple lines).
* <div class="notapi">
* This class is not really part of the API. It just illustrates the properties
* that developers can use to define and create textarea.
* <br /><br />Once the dialog is opened, the created element becomes a {@link CKEDITOR.ui.dialog.textarea} object and can be accessed with {@link CKEDITOR.dialog#getContentElement}.
* </div>
* For a complete example of dialog definition, please check {@link CKEDITOR.dialog.add}.
* @name CKEDITOR.dialog.definition.textarea
* @extends CKEDITOR.dialog.definition.labeledElement
* @constructor
* @example
* // There is no constructor for this class, the user just has to define an
* // object with the appropriate properties.
*
* // Example:
* {
* <b>type : 'textarea',</b>
* id : 'message',
* label : 'Your comment',
* 'default' : '',
* validate : function() {
* if ( this.getValue().length < 5 )
* {
* api.openMsgDialog( 'The comment is too short.' );
* return false;
* }
* }
* }
*/
/**
* The number of rows.
* @name CKEDITOR.dialog.definition.textarea.prototype.rows
* @type Number
* @field
* @example
*/
/**
* The number of columns.
* @name CKEDITOR.dialog.definition.textarea.prototype.cols
* @type Number
* @field
* @example
*/
/**
* (Optional) The validation function.
* @name CKEDITOR.dialog.definition.textarea.prototype.validate
* @field
* @type Function
* @example
*/
/**
* The default value.
* @name CKEDITOR.dialog.definition.textarea.prototype.default
* @type String
* @field
* @example
*/
| JavaScript |
/*
Copyright (c) 2003-2012, 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()
{
var cssLength = CKEDITOR.tools.cssLength;
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;
}
function clearOrRecoverTextInputValue( container, isRecover )
{
var inputs = container.$.getElementsByTagName( 'input' );
for ( var i = 0, length = inputs.length; i < length ; i++ )
{
var item = new CKEDITOR.dom.element( inputs[ i ] );
if ( item.getAttribute( 'type' ).toLowerCase() == 'text' )
{
if ( isRecover )
{
item.setAttribute( 'value', item.getCustomData( 'fake_value' ) || '' );
item.removeCustomData( 'fake_value' );
}
else
{
item.setCustomData( 'fake_value', item.getAttribute( 'value' ) );
item.setAttribute( 'value', '' );
}
}
}
}
// Handle dialog element validation state UI changes.
function handleFieldValidated( isValid, msg )
{
var input = this.getInputElement();
if ( input )
{
isValid ? input.removeAttribute( 'aria-invalid' )
: input.setAttribute( 'aria-invalid', true );
}
if ( !isValid )
{
if ( this.select )
this.select();
else
this.focus();
}
msg && alert( msg );
this.fire( 'validated', { valid : isValid, msg : msg } );
}
function resetField()
{
var input = this.getInputElement();
input && input.removeAttribute( 'aria-invalid' );
}
/**
* 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 ],
defaultDefinition = CKEDITOR.tools.clone( defaultDialogDefinition ),
buttonsOrder = editor.config.dialog_buttonsOrder || 'OS',
dir = editor.lang.dir,
tabsToRemove = {},
i,
processed, stopPropagation;
if ( ( buttonsOrder == 'OS' && CKEDITOR.env.mac ) || // The buttons in MacOS Apps are in reverse order (#4750)
( buttonsOrder == 'rtl' && dir == 'ltr' ) ||
( buttonsOrder == 'ltr' && dir == 'rtl' ) )
defaultDefinition.buttons.reverse();
// Completes the definition with the default values.
definition = CKEDITOR.tools.extend( definition( editor ), defaultDefinition );
// 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 },
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.
var startStyles = {
position : CKEDITOR.env.ie6Compat ? 'absolute' : 'fixed',
top : 0,
visibility : 'hidden'
};
startStyles[ dir == 'rtl' ? 'right' : 'left' ] = 0;
this.parts.dialog.setStyles( startStyles );
// 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;
// Cache tabs that should be removed.
if ( !( 'removeDialogTabs' in editor._ ) && editor.config.removeDialogTabs )
{
var removeContents = editor.config.removeDialogTabs.split( ';' );
for ( i = 0; i < removeContents.length; i++ )
{
var parts = removeContents[ i ].split( ':' );
if ( parts.length == 2 )
{
var removeDialogName = parts[ 0 ];
if ( !tabsToRemove[ removeDialogName ] )
tabsToRemove[ removeDialogName ] = [];
tabsToRemove[ removeDialogName ].push( parts[ 1 ] );
}
}
editor._.removeDialogTabs = tabsToRemove;
}
// Remove tabs of this dialog.
if ( editor._.removeDialogTabs && ( tabsToRemove = editor._.removeDialogTabs[ dialogName ] ) )
{
for ( i = 0; i < tabsToRemove.length; i++ )
definition.removeContents( tabsToRemove[ i ] );
}
// 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 )
{
// Dialog confirm might probably introduce content changes (#5415).
editor.fire( 'saveSnapshot' );
setTimeout( function () { editor.fire( 'saveSnapshot' ); }, 0 );
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 retval = item.validate( this ),
invalid = typeof ( retval ) == 'string' || retval === false;
if ( invalid )
{
evt.data.hide = false;
evt.stop();
}
handleFieldValidated.call( item, !invalid, typeof retval == 'string' ? retval : undefined );
return invalid;
}
});
}, 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();
evt.data.preventDefault();
}, 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( offset )
{
var focusList = me._.focusList;
offset = offset || 0;
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 ( offset && !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;
function keydownHandler( evt )
{
// If I'm not the top dialog, ignore.
if ( me != CKEDITOR.dialog._.currentTop )
return;
var keystroke = evt.data.getKeystroke(),
rtl = editor.lang.dir == 'rtl',
button;
processed = stopPropagation = 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 ? -1 : 1 );
}
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 == ( rtl ? 39 : 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( 1 );
processed = 1;
}
// If user presses enter key in a text box, it implies clicking OK for the dialog.
else if ( keystroke == 13 /*ENTER*/ )
{
// Don't do that for a target that handles ENTER.
var target = evt.data.getTarget();
if ( !target.is( 'a', 'button', 'select' ) && ( !target.is( 'input' ) || target.$.type != 'button' ) )
{
button = this.getButton( 'ok' );
button && CKEDITOR.tools.setTimeout( button.click, 0, button );
processed = 1;
}
stopPropagation = 1; // Always block the propagation (#4269)
}
else if ( keystroke == 27 /*ESC*/ )
{
button = this.getButton( 'cancel' );
// If there's a Cancel button, click it, else just fire the cancel event and hide the dialog.
if ( button )
CKEDITOR.tools.setTimeout( button.click, 0, button );
else
{
if ( this.fire( 'cancel', { hide : true } ).hide !== false )
this.hide();
}
stopPropagation = 1; // Always block the propagation (#4269)
}
else
return;
keypressHandler( evt );
}
function keypressHandler( evt )
{
if ( processed )
evt.data.preventDefault(1);
else if ( stopPropagation )
evt.data.stopPropagation();
}
var dialogElement = this._.element;
// Add the dialog keyboard handlers.
this.on( 'show', function()
{
dialogElement.on( 'keydown', keydownHandler, this );
// 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,#8985)
if ( CKEDITOR.env.opera || CKEDITOR.env.gecko )
dialogElement.on( 'keypress', keypressHandler, this );
} );
this.on( 'hide', function()
{
dialogElement.removeListener( 'keydown', keydownHandler );
if ( CKEDITOR.env.opera || CKEDITOR.env.gecko )
dialogElement.removeListener( 'keypress', keypressHandler );
// Reset fields state when closing dialog.
iterContents( function( item ) { resetField.apply( item ); } );
} );
this.on( 'iframeAdded', function( evt )
{
var doc = new CKEDITOR.dom.document( evt.data.iframe.$.contentWindow.document );
doc.on( 'keydown', keydownHandler, 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._.pageCount > 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( 1 );
/*
* 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 ( i = 0 ; i < definition.contents.length ; i++ )
{
var page = definition.contents[i];
page && this.addPage( page );
}
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' ) )
{
// Get the ID of the tab, without the 'cke_' prefix and the unique number suffix.
var id = target.$.id;
this.selectPage( id.substring( 4, id.lastIndexOf( '_' ) ) );
if ( this._.tabBarMode )
{
this._.tabBarMode = false;
this._.currentFocusIndex = -1;
changeFocus( 1 );
}
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 =
{
destroy : function()
{
this.hide();
this._.element.remove();
},
/**
* 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.fire( 'resize',
{
skin : this._.editor.skinName,
width : width,
height : height
}, this._.editor );
// Update dialog position when dimension get changed in RTL.
if ( this._.editor.lang.dir == 'rtl' && this._.position )
this._.position.x = CKEDITOR.document.getWindow().getViewPaneSize().width -
this._.contentSize.width - parseInt( this._.element.getFirst().getStyle( 'right' ), 10 );
this._.contentSize = { width : width, height : height };
};
})(),
/**
* 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()
{
var element = this._.element.getFirst();
return { width : element.$.offsetWidth || 0, height : element.$.offsetHeight || 0};
},
/**
* 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.
* @param {Boolean} save Flag indicate whether the dialog position should be remembered on next open up.
* @example
* dialogObj.move( 10, 40 );
*/
move : (function()
{
var isFixed;
return function( x, y, save )
{
// The dialog may be fixed positioned or absolute positioned. Ask the
// browser what is the current situation first.
var element = this._.element.getFirst(),
rtl = this._.editor.lang.dir == 'rtl';
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;
}
// Translate coordinate for RTL.
if ( rtl )
{
var dialogSize = this.getSize(),
viewPaneSize = CKEDITOR.document.getWindow().getViewPaneSize();
x = viewPaneSize.width - dialogSize.width - x;
}
var styles = { 'top' : ( y > 0 ? y : 0 ) + 'px' };
styles[ rtl ? 'right' : 'left' ] = ( x > 0 ? x : 0 ) + 'px';
element.setStyles( styles );
save && ( this._.moved = 1 );
};
})(),
/**
* 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()
{
// 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
element.setStyle( 'display', 'block' );
// 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( this._.contentSize && this._.contentSize.width || definition.width || definition.minWidth,
this._.contentSize && this._.contentSize.height || definition.height || definition.minHeight );
// Reset all inputs back to their default value.
this.reset();
// Select the first tab by default.
this.selectPage( this.definition.contents[0].id );
// 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.
if ( CKEDITOR.dialog._.currentTop === null )
{
CKEDITOR.dialog._.currentTop = this;
this._.parentDialog = null;
showCover( this._.editor );
}
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;
}
element.on( 'keydown', accessKeyDownHandler );
element.on( CKEDITOR.env.opera ? 'keypress' : 'keyup', accessKeyUpHandler );
// Reset the hasFocus state.
this._.hasFocus = false;
CKEDITOR.tools.setTimeout( function()
{
this.layout();
this.parts.dialog.setStyle( 'visibility', '' );
// Execute onLoad for the first show.
this.fireOnce( 'load', {} );
CKEDITOR.ui.fire( 'ready', this );
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 );
},
/**
* Rearrange the dialog to its previous position or the middle of the window.
* @since 3.5
*/
layout : function()
{
var viewSize = CKEDITOR.document.getWindow().getViewPaneSize(),
dialogSize = this.getSize();
this.move( this._.moved ? this._.position.x : ( viewSize.width - dialogSize.width ) / 2,
this._.moved ? this._.position.y : ( viewSize.height - dialogSize.height ) / 2 );
},
/**
* 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.call( this, 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( 1 ); };
return function(){ this.foreach( fn ); return this; };
})(),
/**
* Calls the {@link CKEDITOR.dialog.definition.uiElement#setup} method of each of the UI elements, with the arguments passed through it.
* It is usually being called when the dialog is opened, to put the initial value inside the field.
* @example
* dialogObj.setupContent();
* @example
* var timestamp = ( new Date() ).valueOf();
* dialogObj.setupContent( timestamp );
*/
setupContent : function()
{
var args = arguments;
this.foreach( function( widget )
{
if ( widget.setup )
widget.setup.apply( widget, args );
});
},
/**
* Calls the {@link CKEDITOR.dialog.definition.uiElement#commit} method of each of the UI elements, with the arguments passed through it.
* It is usually being called when the user confirms the dialog, to process the values.
* @example
* dialogObj.commitContent();
* @example
* var timestamp = ( new Date() ).valueOf();
* dialogObj.commitContent( timestamp );
*/
commitContent : function()
{
var args = arguments;
this.foreach( function( widget )
{
// Make sure IE triggers "change" event on last focused input before closing the dialog. (#7915)
if ( CKEDITOR.env.ie && this._.currentFocusIndex == widget.focusIndex )
widget.getInputElement().$.blur();
if ( widget.commit )
widget.commit.apply( widget, args );
});
},
/**
* Hides the dialog box.
* @example
* dialogObj.hide();
*/
hide : function()
{
if ( !this.parts.dialog.isVisible() )
return;
this.fire( 'hide', {} );
this._.editor.fire( 'dialogHide', this );
// Reset the tab page.
this.selectPage( this._.tabIdList[ 0 ] );
var element = this._.element;
element.setStyle( 'display', 'none' );
this.parts.dialog.setStyle( 'visibility', 'hidden' );
// Unregister all access keys associated with this dialog.
unregisterAccessKey( this );
// Close any child(top) dialogs first.
while( CKEDITOR.dialog._.currentTop != this )
CKEDITOR.dialog._.currentTop.hide();
// Maintain dialog ordering and remove cover if needed.
if ( !this._.parentDialog )
hideCover();
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 );
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;
delete this._.parentDialog;
// 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 = 'cke_' + contents.id + '_' + CKEDITOR.tools.getNextNumber(),
tab = CKEDITOR.dom.element.createFromHtml( [
'<a class="cke_dialog_tab"',
( this._.pageCount > 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,
'</a>'
].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 )
{
if ( this._.currentTabId == id )
return;
// Returning true means that the event has been canceled
if ( this.fire( 'selectPage', { page : id, currentPage : this._.currentTabId } ) === true )
return;
// 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' );
// [IE] an invisible input[type='text'] will enlarge it's width
// if it's value is long when it shows, so we clear it's value
// before it shows and then recover it (#5649)
if ( CKEDITOR.env.ie6Compat || CKEDITOR.env.ie7Compat )
{
clearOrRecoverTextInputValue( selected[ 1 ] );
selected[ 1 ].show();
setTimeout( function()
{
clearOrRecoverTextInputValue( selected[ 1 ], 1 );
}, 0 );
}
else
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 || !tab.isVisible() )
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
* dialogObj.getContentElement( 'tabId', 'elementId' ).setValue( '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
* alert( dialogObj.getValueOf( 'tabId', 'elementId' ) );
* @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
* dialogObj.setValueOf( 'tabId', 'elementId', '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.definition}.
* @see CKEDITOR.dialog.definition
* @example
* // Full sample plugin, which does not only register a dialog window but also adds an item to the context menu.
* // To open the dialog window, choose "Open dialog" in the context menu.
* CKEDITOR.plugins.add( 'myplugin',
* {
* init: function( editor )
* {
* editor.addCommand( 'mydialog',new CKEDITOR.dialogCommand( 'mydialog' ) );
*
* if ( editor.contextMenu )
* {
* editor.addMenuGroup( 'mygroup', 10 );
* editor.addMenuItem( 'My Dialog',
* {
* label : 'Open dialog',
* command : 'mydialog',
* group : 'mygroup'
* });
* editor.contextMenu.addListener( function( element )
* {
* return { 'My Dialog' : CKEDITOR.TRISTATE_OFF };
* });
* }
*
* <strong>CKEDITOR.dialog.add</strong>( 'mydialog', function( api )
* {
* // CKEDITOR.dialog.definition
* var <strong>dialogDefinition</strong> =
* {
* title : 'Sample dialog',
* minWidth : 390,
* minHeight : 130,
* contents : [
* {
* id : 'tab1',
* label : 'Label',
* title : 'Title',
* expand : true,
* padding : 0,
* elements :
* [
* {
* type : 'html',
* html : '<p>This is some sample HTML content.</p>'
* },
* {
* type : 'textarea',
* id : 'textareaId',
* rows : 4,
* cols : 40
* }
* ]
* }
* ],
* buttons : [ CKEDITOR.dialog.okButton, CKEDITOR.dialog.cancelButton ],
* onOk : function() {
* // "this" is now a CKEDITOR.dialog object.
* // Accessing dialog elements:
* var textareaObj = this.<strong>getContentElement</strong>( 'tab1', 'textareaId' );
* alert( "You have entered: " + textareaObj.getValue() );
* }
* };
*
* return dialogDefinition;
* } );
* }
* } );
*
* CKEDITOR.replace( 'editor1', { extraPlugins : 'myplugin' } );
*/
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 ]
};
// 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.definitionObject
* @extends CKEDITOR.dialog.definition
* @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 ] = content && new contentObject( dialog, content );
CKEDITOR.tools.extend( this, dialogDefinition );
};
definitionObject.prototype =
/** @lends CKEDITOR.dialog.definitionObject.prototype */
{
/**
* Gets a content definition.
* @param {String} id The id of the content definition.
* @returns {CKEDITOR.dialog.definition.content} 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.definition.button} 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.definition.content} 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.definition.content} 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.definition.button} 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.definition.button} 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.definition.content} 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.definition.button} 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.definitionObject.
* @constructor
* @name CKEDITOR.dialog.definition.contentObject
* @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.definition.contentObject.prototype */
{
/**
* Gets a UI element definition under the content definition.
* @param {String} id The id of the UI element definition.
* @returns {CKEDITOR.dialog.definition.uiElement}
*/
get : function( id )
{
return getById( this.elements, id, 'children' );
},
/**
* Adds a UI element definition to the content definition.
* @param {CKEDITOR.dialog.definition.uiElement} 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.definition.uiElement} 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.definition.uiElement} 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 + ( editor.lang.dir == 'rtl' ? 0 : 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, 1 );
evt.data.preventDefault();
}
function mouseUpHandler( evt )
{
CKEDITOR.document.removeListener( 'mousemove', mouseMoveHandler );
CKEDITOR.document.removeListener( 'mouseup', mouseUpHandler );
if ( CKEDITOR.env.ie6Compat )
{
var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
coverDoc.removeListener( 'mousemove', mouseMoveHandler );
coverDoc.removeListener( 'mouseup', mouseUpHandler );
}
}
dialog.parts.title.on( 'mousedown', function( evt )
{
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 = currentCover.getChild( 0 ).getFrameDocument();
coverDoc.on( 'mousemove', mouseMoveHandler );
coverDoc.on( 'mouseup', mouseUpHandler );
}
evt.data.preventDefault();
}, dialog );
}
function initResizeHandles( dialog )
{
var def = dialog.definition,
resizable = def.resizable;
if ( resizable == CKEDITOR.DIALOG_RESIZE_NONE )
return;
var editor = dialog.getParentEditor();
var wrapperWidth, wrapperHeight,
viewSize, origin, startSize,
dialogCover;
var mouseDownFn = CKEDITOR.tools.addFunction( function( $event )
{
startSize = dialog.getSize();
var content = dialog.parts.contents,
iframeDialog = content.$.getElementsByTagName( 'iframe' ).length;
// Shim to help capturing "mousemove" over iframe.
if ( iframeDialog )
{
dialogCover = CKEDITOR.dom.element.createFromHtml( '<div class="cke_dialog_resize_cover" style="height: 100%; position: absolute; width: 100%;"></div>' );
content.append( dialogCover );
}
// Calculate the offset between content and chrome size.
wrapperHeight = startSize.height - dialog.parts.contents.getSize( 'height', ! ( CKEDITOR.env.gecko || CKEDITOR.env.opera || CKEDITOR.env.ie && CKEDITOR.env.quirks ) );
wrapperWidth = startSize.width - dialog.parts.contents.getSize( 'width', 1 );
origin = { x : $event.screenX, y : $event.screenY };
viewSize = CKEDITOR.document.getWindow().getViewPaneSize();
CKEDITOR.document.on( 'mousemove', mouseMoveHandler );
CKEDITOR.document.on( 'mouseup', mouseUpHandler );
if ( CKEDITOR.env.ie6Compat )
{
var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
coverDoc.on( 'mousemove', mouseMoveHandler );
coverDoc.on( 'mouseup', mouseUpHandler );
}
$event.preventDefault && $event.preventDefault();
});
// Prepend the grip to the dialog.
dialog.on( 'load', function()
{
var direction = '';
if ( resizable == CKEDITOR.DIALOG_RESIZE_WIDTH )
direction = ' cke_resizer_horizontal';
else if ( resizable == CKEDITOR.DIALOG_RESIZE_HEIGHT )
direction = ' cke_resizer_vertical';
var resizer = CKEDITOR.dom.element.createFromHtml( '<div' +
' class="cke_resizer' + direction + ' cke_resizer_' + editor.lang.dir + '"' +
' title="' + CKEDITOR.tools.htmlEncode( editor.lang.resize ) + '"' +
' onmousedown="CKEDITOR.tools.callFunction(' + mouseDownFn + ', event )"></div>' );
dialog.parts.footer.append( resizer, 1 );
});
editor.on( 'destroy', function() { CKEDITOR.tools.removeFunction( mouseDownFn ); } );
function mouseMoveHandler( evt )
{
var rtl = editor.lang.dir == 'rtl',
dx = ( evt.data.$.screenX - origin.x ) * ( rtl ? -1 : 1 ),
dy = evt.data.$.screenY - origin.y,
width = startSize.width,
height = startSize.height,
internalWidth = width + dx * ( dialog._.moved ? 1 : 2 ),
internalHeight = height + dy * ( dialog._.moved ? 1 : 2 ),
element = dialog._.element.getFirst(),
right = rtl && element.getComputedStyle( 'right' ),
position = dialog.getPosition();
if ( position.y + internalHeight > viewSize.height )
internalHeight = viewSize.height - position.y;
if ( ( rtl ? right : position.x ) + internalWidth > viewSize.width )
internalWidth = viewSize.width - ( rtl ? right : position.x );
// Make sure the dialog will not be resized to the wrong side when it's in the leftmost position for RTL.
if ( ( resizable == CKEDITOR.DIALOG_RESIZE_WIDTH || resizable == CKEDITOR.DIALOG_RESIZE_BOTH ) )
width = Math.max( def.minWidth || 0, internalWidth - wrapperWidth );
if ( resizable == CKEDITOR.DIALOG_RESIZE_HEIGHT || resizable == CKEDITOR.DIALOG_RESIZE_BOTH )
height = Math.max( def.minHeight || 0, internalHeight - wrapperHeight );
dialog.resize( width, height );
if ( !dialog._.moved )
dialog.layout();
evt.data.preventDefault();
}
function mouseUpHandler()
{
CKEDITOR.document.removeListener( 'mouseup', mouseUpHandler );
CKEDITOR.document.removeListener( 'mousemove', mouseMoveHandler );
if ( dialogCover )
{
dialogCover.remove();
dialogCover = null;
}
if ( CKEDITOR.env.ie6Compat )
{
var coverDoc = currentCover.getChild( 0 ).getFrameDocument();
coverDoc.removeListener( 'mouseup', mouseUpHandler );
coverDoc.removeListener( 'mousemove', mouseMoveHandler );
}
}
}
var resizeCover;
// Caching resuable covers and allowing only one cover
// on screen.
var covers = {},
currentCover;
function cancelEvent( ev )
{
ev.data.preventDefault(1);
}
function showCover( editor )
{
var win = CKEDITOR.document.getWindow();
var config = editor.config,
backgroundColorStyle = config.dialog_backgroundCoverColor || 'white',
backgroundCoverOpacity = config.dialog_backgroundCoverOpacity,
baseFloatZIndex = config.baseFloatZIndex,
coverKey = CKEDITOR.tools.genKey(
backgroundColorStyle,
backgroundCoverOpacity,
baseFloatZIndex ),
coverElement = covers[ coverKey ];
if ( !coverElement )
{
var html = [
'<div tabIndex="-1" style="position: ', ( CKEDITOR.env.ie6Compat ? 'absolute' : 'fixed' ),
'; z-index: ', baseFloatZIndex,
'; top: 0px; left: 0px; ',
( !CKEDITOR.env.ie6Compat ? 'background-color: ' + backgroundColorStyle : '' ),
'" class="cke_dialog_background_cover">'
];
if ( CKEDITOR.env.ie6Compat )
{
// Support for custom document.domain in IE.
var isCustomDomain = CKEDITOR.env.isCustomDomain(),
iframeHtml = '<html><body style=\\\'background-color:' + backgroundColorStyle + ';\\\'></body></html>';
html.push(
'<iframe' +
' hidefocus="true"' +
' frameborder="0"' +
' id="cke_dialog_background_iframe"' +
' src="javascript:' );
html.push( 'void((function(){' +
'document.open();' +
( isCustomDomain ? 'document.domain=\'' + document.domain + '\';' : '' ) +
'document.write( \'' + iframeHtml + '\' );' +
'document.close();' +
'})())' );
html.push(
'"' +
' style="' +
'position:absolute;' +
'left:0;' +
'top:0;' +
'width:100%;' +
'height: 100%;' +
'progid:DXImageTransform.Microsoft.Alpha(opacity=0)">' +
'</iframe>' );
}
html.push( '</div>' );
coverElement = CKEDITOR.dom.element.createFromHtml( html.join( '' ) );
coverElement.setOpacity( backgroundCoverOpacity != undefined ? backgroundCoverOpacity : 0.5 );
coverElement.on( 'keydown', cancelEvent );
coverElement.on( 'keypress', cancelEvent );
coverElement.on( 'keyup', cancelEvent );
coverElement.appendTo( CKEDITOR.document.getBody() );
covers[ coverKey ] = coverElement;
}
else
coverElement. show();
currentCover = coverElement;
var resizeFunc = function()
{
var size = win.getViewPaneSize();
coverElement.setStyles(
{
width : size.width + 'px',
height : size.height + 'px'
} );
};
var scrollFunc = function()
{
var pos = win.getScrollPosition(),
cursor = CKEDITOR.dialog._.currentTop;
coverElement.setStyles(
{
left : pos.x + 'px',
top : pos.y + 'px'
});
if ( cursor )
{
do
{
var dialogPos = cursor.getPosition();
cursor.move( dialogPos.x, dialogPos.y );
} while ( ( cursor = cursor._.parentDialog ) );
}
};
resizeCover = resizeFunc;
win.on( 'resize', resizeFunc );
resizeFunc();
// Using Safari/Mac, focus must be kept where it is (#7027)
if ( !( CKEDITOR.env.mac && CKEDITOR.env.webkit ) )
coverElement.focus();
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();
}
}
function hideCover()
{
if ( !currentCover )
return;
var win = CKEDITOR.document.getWindow();
currentCover.hide();
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;
}
function removeCovers()
{
for ( var coverId in covers )
covers[ coverId ].remove();
covers = {};
}
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 )
{
};
(function()
{
CKEDITOR.ui.dialog =
{
/**
* The base class of all dialog UI elements.
* @constructor
* @param {CKEDITOR.dialog} dialog Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition Element
* definition. Accepted fields:
* <ul>
* <li><strong>id</strong> (Required) The id of the UI element. See {@link
* CKEDITOR.dialog#getContentElement}</li>
* <li><strong>type</strong> (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.</li>
* <li><strong>title</strong> (Optional) The popup tooltip for the UI
* element.</li>
* <li><strong>hidden</strong> (Optional) A flag that tells if the element
* should be initially visible.</li>
* <li><strong>className</strong> (Optional) Additional CSS class names
* to add to the UI element. Separated by space.</li>
* <li><strong>style</strong> (Optional) Additional CSS inline styles
* to add to the UI element. A semicolon (;) is required after the last
* style declaration.</li>
* <li><strong>accessKey</strong> (Optional) The alphanumeric access key
* for this element. Access keys are automatically prefixed by CTRL.</li>
* <li><strong>on*</strong> (Optional) Any UI element definition field that
* starts with <em>on</em> 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.</li>
* </ul>
* @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.getNextId() + '_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;
if ( elementDefinition.disabled )
classes[ 'cke_disabled' ] = 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( ';' );
// Element alignment support.
if ( elementDefinition.align )
{
var align = elementDefinition.align;
styles[ 'margin-left' ] = align == 'left' ? 0 : 'auto';
styles[ 'margin-right' ] = align == 'right' ? 0 : 'auto';
}
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, '</', nodeName, '>' );
// 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;
// Overload 'get(set)Value' on definition.
if ( typeof( elementDefinition.setValue ) == 'function' )
{
this.setValue = CKEDITOR.tools.override( this.setValue, function( org )
{
return function( val ){ org.call( this, elementDefinition.setValue.call( this, val ) ); };
} );
}
if ( typeof( elementDefinition.getValue ) == 'function' )
{
this.getValue = CKEDITOR.tools.override( this.getValue, function( org )
{
return function(){ return elementDefinition.getValue.call( this, org.call( this ) ); };
} );
}
// 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()
{
var input = me.getInputElement();
if ( input )
{
var focusClass = me.type in { 'checkbox' : 1, 'ratio' : 1 } && CKEDITOR.env.ie && CKEDITOR.env.version < 8 ? 'cke_dialog_ui_focused' : '';
input.on( 'focus', function()
{
dialog._.tabBarMode = false;
dialog._.hasFocus = true;
me.fire( 'focus' );
focusClass && this.addClass( focusClass );
});
input.on( 'blur', function()
{
me.fire( 'blur' );
focusClass && this.removeClass( focusClass );
});
}
} );
// 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.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>widths</strong> (Optional) The widths of child cells.</li>
* <li><strong>height</strong> (Optional) The height of the layout.</li>
* <li><strong>padding</strong> (Optional) The padding width inside child
* cells.</li>
* <li><strong>align</strong> (Optional) The alignment of the whole layout
* </li>
* </ul>
* @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 = [ '<tbody><tr class="cke_dialog_ui_hbox">' ];
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( '<td class="', className, '" role="presentation" ' );
if ( widths )
{
if ( widths[i] )
styles.push( 'width:' + cssLength( widths[i] ) );
}
else
styles.push( 'width:' + Math.floor( 100 / childHtmlList.length ) + '%' );
if ( height )
styles.push( 'height:' + cssLength( height ) );
if ( elementDefinition && elementDefinition.padding != undefined )
styles.push( 'padding:' + cssLength( elementDefinition.padding ) );
// In IE Quirks alignment has to be done on table cells. (#7324)
if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && children[ i ].align )
styles.push( 'text-align:' + children[ i ].align );
if ( styles.length > 0 )
html.push( 'style="' + styles.join('; ') + '" ' );
html.push( '>', childHtmlList[i], '</td>' );
}
html.push( '</tr></tbody>' );
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.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>width</strong> (Optional) The width of the layout.</li>
* <li><strong>heights</strong> (Optional) The heights of individual cells.
* </li>
* <li><strong>align</strong> (Optional) The alignment of the layout.</li>
* <li><strong>padding</strong> (Optional) The padding width inside child
* cells.</li>
* <li><strong>expand</strong> (Optional) Whether the layout should expand
* vertically to fill its container.</li>
* </ul>
* @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 = [ '<table role="presentation" cellspacing="0" border="0" ' ];
html.push( 'style="' );
if ( elementDefinition && elementDefinition.expand )
html.push( 'height:100%;' );
html.push( 'width:' + cssLength( width || '100%' ), ';' );
html.push( '"' );
html.push( 'align="', CKEDITOR.tools.htmlEncode(
( elementDefinition && elementDefinition.align ) || ( dialog.getParentEditor().lang.dir == 'ltr' ? 'left' : 'right' ) ), '" ' );
html.push( '><tbody>' );
for ( var i = 0 ; i < childHtmlList.length ; i++ )
{
var styles = [];
html.push( '<tr><td role="presentation" ' );
if ( width )
styles.push( 'width:' + cssLength( width || '100%' ) );
if ( heights )
styles.push( 'height:' + cssLength( heights[i] ) );
else if ( elementDefinition && elementDefinition.expand )
styles.push( 'height:' + Math.floor( 100 / childHtmlList.length ) + '%' );
if ( elementDefinition && elementDefinition.padding != undefined )
styles.push( 'padding:' + cssLength( elementDefinition.padding ) );
// In IE Quirks alignment has to be done on table cells. (#7324)
if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && children[ i ].align )
styles.push( 'text-align:' + children[ i ].align );
if ( styles.length > 0 )
html.push( 'style="', styles.join( '; ' ), '" ' );
html.push( ' class="cke_dialog_ui_vbox_child">', childHtmlList[i], '</td></tr>' );
}
html.push( '</tbody></table>' );
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.
* @param {Boolean} noChangeEvent Internal commit, to supress 'change' event on this element.
* @returns {CKEDITOR.dialog.uiElement} The current UI element.
* @example
* uiElement.setValue( 'Dingo' );
*/
setValue : function( value, noChangeEvent )
{
this.getInputElement().setValue( value );
!noChangeEvent && 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:
* <ol>
* <li>
* 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.
* </li>
* <li>
* 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}).
* </li>
* </ol>
* This function is only called at UI element instantiation, but can
* be overridded in child classes if they require more flexibility.
* @param {CKEDITOR.dialog.definition.uiElement} 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:
* <ol>
* <li>onLoad - Called when the element's parent dialog opens for the
* first time</li>
* <li>onShow - Called whenever the element's parent dialog opens.</li>
* <li>onHide - Called whenever the element's parent dialog closes.</li>
* </ol>
* @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.<br />
* 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.<br />
* 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.getElement(),
input = this.getInputElement();
input.setAttribute( 'disabled', 'true' );
element.addClass( 'cke_disabled' );
},
/**
* Enables a UI element.
* @example
*/
enable : function()
{
var element = this.getElement(),
input = this.getInputElement();
input.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.getElement().hasClass( 'cke_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', <b>new CKEDITOR.dialogCommand( 'link' )</b> );
*/
CKEDITOR.dialogCommand = function( dialogName )
{
this.dialogName = dialogName;
};
CKEDITOR.dialogCommand.prototype =
{
/** @ignore */
exec : function( editor )
{
// Special treatment for Opera. (#8031)
CKEDITOR.env.opera ?
CKEDITOR.tools.setTimeout( function() { editor.openDialog( this.dialogName ); }, 0, this )
: 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 || CKEDITOR.env.webkit
};
(function()
{
var notEmptyRegex = /^([a]|[^a])+$/,
integerRegex = /^\d*$/,
numberRegex = /^\d*(?:\.\d+)?$/,
htmlLengthRegex = /^(((\d*(\.\d+))|(\d*))(px|\%)?)?$/,
cssLengthRegex = /^(((\d*(\.\d+))|(\d*))(px|em|ex|in|cm|mm|pt|pc|\%)?)?$/i,
inlineStyleRegex = /^(\s*[\w-]+\s*:\s*[^:;]+(?:;|$))*$/;
CKEDITOR.VALIDATE_OR = 1;
CKEDITOR.VALIDATE_AND = 2;
CKEDITOR.dialog.validate =
{
functions : function()
{
var args = arguments;
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() : args[ 0 ];
var msg = undefined,
relation = CKEDITOR.VALIDATE_AND,
functions = [], i;
for ( i = 0 ; i < args.length ; i++ )
{
if ( typeof( args[i] ) == 'function' )
functions.push( args[i] );
else
break;
}
if ( i < args.length && typeof( args[i] ) == 'string' )
{
msg = args[i];
i++;
}
if ( i < args.length && typeof( args[i]) == 'number' )
relation = args[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 );
}
return !passed ? msg : 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];
return !regex.test( value ) ? msg : 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 );
},
'cssLength' : function( msg )
{
return this.functions( function( val ){ return cssLengthRegex.test( CKEDITOR.tools.trim( val ) ); }, msg );
},
'htmlLength' : function( msg )
{
return this.functions( function( val ){ return htmlLengthRegex.test( CKEDITOR.tools.trim( val ) ); }, msg );
},
'inlineStyle' : function( msg )
{
return this.functions( function( val ){ return inlineStyleRegex.test( CKEDITOR.tools.trim( val ) ); }, 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 );
}
};
CKEDITOR.on( 'instanceDestroyed', function( evt )
{
// Remove dialog cover on last instance destroy.
if ( CKEDITOR.tools.isEmpty( CKEDITOR.instances ) )
{
var currentTopDialog;
while ( ( currentTopDialog = CKEDITOR.dialog._.currentTop ) )
currentTopDialog.hide();
removeCovers();
}
var dialogs = evt.editor._.storedDialogs;
for ( var name in dialogs )
dialogs[ name ].destroy();
});
})();
// 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 )
{
if ( this.mode == 'wysiwyg' && CKEDITOR.env.ie )
{
var selection = this.getSelection();
selection && selection.lock();
}
var dialogDefinitions = CKEDITOR.dialog._.dialogDefinitions[ dialogName ],
dialogSkin = this.skin.dialog;
if ( CKEDITOR.dialog._.currentTop === null )
showCover( this );
// 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' )
{
hideCover();
throw new Error( '[CKEDITOR.dialog.openDialog] Dialog "' + dialogName + '" failed when loading definition.' );
}
var me = this;
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 );
}
if ( typeof dialogDefinitions == 'string' )
{
var loadDefinition = 1;
CKEDITOR.scriptLoader.load( CKEDITOR.getUrl( dialogDefinitions ), onDialogFileLoaded, null, 0, 1 );
}
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;
*/
/**
* The guideline to follow when generating the dialog buttons. There are 3 possible options:
* <ul>
* <li>'OS' - the buttons will be displayed in the default order of the user's OS;</li>
* <li>'ltr' - for Left-To-Right order;</li>
* <li>'rtl' - for Right-To-Left order.</li>
* </ul>
* @name CKEDITOR.config.dialog_buttonsOrder
* @type String
* @default 'OS'
* @since 3.5
* @example
* config.dialog_buttonsOrder = 'rtl';
*/
/**
* The dialog contents to removed. It's a string composed by dialog name and tab name with a colon between them.
* Separate each pair with semicolon (see example).
* <b>Note: All names are case-sensitive.</b>
* <b>Note: Be cautious when specifying dialog tabs that are mandatory, like "info", dialog functionality might be broken because of this!</b>
* @name CKEDITOR.config.removeDialogTabs
* @type String
* @since 3.5
* @default ''
* @example
* config.removeDialogTabs = 'flash:advanced;image:Link';
*/
/**
* 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.
* <p>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.</p>
* @name CKEDITOR#dialogDefinition
* @event
* @param {CKEDITOR.dialog.definition} data The dialog defination that
* is being loaded.
* @param {CKEDITOR.editor} editor The editor instance that will use the
* dialog.
*/
/**
* Fired when a tab is going to be selected in a dialog
* @name CKEDITOR.dialog#selectPage
* @event
* @param {String} page The id of the page that it's gonna be selected.
* @param {String} currentPage The id of the current page.
*/
/**
* Fired when the user tries to dismiss a dialog
* @name CKEDITOR.dialog#cancel
* @event
* @param {Boolean} hide Whether the event should proceed or not.
*/
/**
* Fired when the user tries to confirm a dialog
* @name CKEDITOR.dialog#ok
* @event
* @param {Boolean} hide Whether the event should proceed or not.
*/
/**
* Fired when a dialog is shown
* @name CKEDITOR.dialog#show
* @event
*/
/**
* Fired when a dialog is shown
* @name CKEDITOR.editor#dialogShow
* @event
*/
/**
* Fired when a dialog is hidden
* @name CKEDITOR.dialog#hide
* @event
*/
/**
* Fired when a dialog is hidden
* @name CKEDITOR.editor#dialogHide
* @event
*/
/**
* Fired when a dialog is being resized. The event is fired on
* both the 'CKEDITOR.dialog' object and the dialog instance
* since 3.5.3, previously it's available only in the global object.
* @name CKEDITOR.dialog#resize
* @since 3.5
* @event
* @param {CKEDITOR.dialog} dialog The dialog being resized (if
* it's fired on the dialog itself, this parameter isn't sent).
* @param {String} skin The skin name.
* @param {Number} width The new width.
* @param {Number} height The new height.
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview The "showblocks" plugin. Enable it will make all block level
* elements being decorated with a border and the element name
* displayed on the left-right corner.
*/
(function()
{
var cssTemplate = '.%2 p,'+
'.%2 div,'+
'.%2 pre,'+
'.%2 address,'+
'.%2 blockquote,'+
'.%2 h1,'+
'.%2 h2,'+
'.%2 h3,'+
'.%2 h4,'+
'.%2 h5,'+
'.%2 h6'+
'{'+
'background-repeat: no-repeat;'+
'background-position: top %3;'+
'border: 1px dotted gray;'+
'padding-top: 8px;'+
'padding-%3: 8px;'+
'}'+
'.%2 p'+
'{'+
'%1p.png);'+
'}'+
'.%2 div'+
'{'+
'%1div.png);'+
'}'+
'.%2 pre'+
'{'+
'%1pre.png);'+
'}'+
'.%2 address'+
'{'+
'%1address.png);'+
'}'+
'.%2 blockquote'+
'{'+
'%1blockquote.png);'+
'}'+
'.%2 h1'+
'{'+
'%1h1.png);'+
'}'+
'.%2 h2'+
'{'+
'%1h2.png);'+
'}'+
'.%2 h3'+
'{'+
'%1h3.png);'+
'}'+
'.%2 h4'+
'{'+
'%1h4.png);'+
'}'+
'.%2 h5'+
'{'+
'%1h5.png);'+
'}'+
'.%2 h6'+
'{'+
'%1h6.png);'+
'}';
var cssTemplateRegex = /%1/g, cssClassRegex = /%2/g, backgroundPositionRegex = /%3/g;
var commandDefinition =
{
readOnly : 1,
preserveState : true,
editorFocus : false,
exec : function ( editor )
{
this.toggleState();
this.refresh( editor );
},
refresh : function( editor )
{
if ( editor.document )
{
var funcName = ( this.state == CKEDITOR.TRISTATE_ON ) ? 'addClass' : 'removeClass';
editor.document.getBody()[ funcName ]( 'cke_show_blocks' );
}
}
};
CKEDITOR.plugins.add( 'showblocks',
{
requires : [ 'wysiwygarea' ],
init : function( editor )
{
var command = editor.addCommand( 'showblocks', commandDefinition );
command.canUndo = false;
if ( editor.config.startupOutlineBlocks )
command.setState( CKEDITOR.TRISTATE_ON );
editor.addCss( cssTemplate
.replace( cssTemplateRegex, 'background-image: url(' + CKEDITOR.getUrl( this.path ) + 'images/block_' )
.replace( cssClassRegex, 'cke_show_blocks ' )
.replace( backgroundPositionRegex, editor.lang.dir == 'rtl' ? 'right' : 'left' ) );
editor.ui.addButton( 'ShowBlocks',
{
label : editor.lang.showBlocks,
command : 'showblocks'
});
// Refresh the command on setData.
editor.on( 'mode', function()
{
if ( command.state != CKEDITOR.TRISTATE_DISABLED )
command.refresh( editor );
});
// Refresh the command on setData.
editor.on( 'contentDom', function()
{
if ( command.state != CKEDITOR.TRISTATE_DISABLED )
command.refresh( editor );
});
}
});
} )();
/**
* Whether to automaticaly enable the "show block" command when the editor
* loads. (StartupShowBlocks in FCKeditor)
* @name CKEDITOR.config.startupOutlineBlocks
* @type Boolean
* @default false
* @example
* config.startupOutlineBlocks = true;
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @stylesheetParser plugin.
*/
(function()
{
// We want to extract only the elements with classes defined in the stylesheets:
function parseClasses( aRules, skipSelectors, validSelectors )
{
// aRules are just the different rules in the style sheets
// We want to merge them and them split them by commas, so we end up with only
// the selectors
var s = aRules.join(' ');
// Remove selectors splitting the elements, leave only the class selector (.)
s = s.replace( /(,|>|\+|~)/g, ' ' );
// Remove attribute selectors: table[border="0"]
s = s.replace( /\[[^\]]*/g, '' );
// Remove Ids: div#main
s = s.replace( /#[^\s]*/g, '' );
// Remove pseudo-selectors and pseudo-elements: :hover :nth-child(2n+1) ::before
s = s.replace( /\:{1,2}[^\s]*/g, '' );
s = s.replace( /\s+/g, ' ' );
var aSelectors = s.split( ' ' ),
aClasses = [];
for ( var i = 0; i < aSelectors.length ; i++ )
{
var selector = aSelectors[ i ];
if ( validSelectors.test( selector ) && !skipSelectors.test( selector ) )
{
// If we still don't know about this one, add it
if ( CKEDITOR.tools.indexOf( aClasses, selector ) == -1 )
aClasses.push( selector );
}
}
return aClasses;
}
function LoadStylesCSS( theDoc, skipSelectors, validSelectors )
{
var styles = [],
// It will hold all the rules of the applied stylesheets (except those internal to CKEditor)
aRules = [],
i;
for ( i = 0; i < theDoc.styleSheets.length; i++ )
{
var sheet = theDoc.styleSheets[ i ],
node = sheet.ownerNode || sheet.owningElement;
// Skip the internal stylesheets
if ( node.getAttribute( 'data-cke-temp' ) )
continue;
// Exclude stylesheets injected by extensions
if ( sheet.href && sheet.href.substr(0, 9) == 'chrome://' )
continue;
var sheetRules = sheet.cssRules || sheet.rules;
for ( var j = 0; j < sheetRules.length; j++ )
aRules.push( sheetRules[ j ].selectorText );
}
var aClasses = parseClasses( aRules, skipSelectors, validSelectors );
// Add each style to our "Styles" collection.
for ( i = 0; i < aClasses.length; i++ )
{
var oElement = aClasses[ i ].split( '.' ),
element = oElement[ 0 ].toLowerCase(),
sClassName = oElement[ 1 ];
styles.push( {
name : element + '.' + sClassName,
element : element,
attributes : {'class' : sClassName}
});
}
return styles;
}
// Register a plugin named "stylesheetparser".
CKEDITOR.plugins.add( 'stylesheetparser',
{
requires: [ 'styles' ],
onLoad : function()
{
var obj = CKEDITOR.editor.prototype;
obj.getStylesSet = CKEDITOR.tools.override( obj.getStylesSet, function( org )
{
return function( callback )
{
var self = this;
org.call( this, function( definitions )
{
// Rules that must be skipped
var skipSelectors = self.config.stylesheetParser_skipSelectors || ( /(^body\.|^\.)/i ),
// Rules that are valid
validSelectors = self.config.stylesheetParser_validSelectors || ( /\w+\.\w+/ );
callback( ( self._.stylesDefinitions = definitions.concat( LoadStylesCSS( self.document.$, skipSelectors, validSelectors ) ) ) );
});
};
});
}
});
})();
/**
* A regular expression that defines whether a CSS rule will be
* skipped by the Stylesheet Parser plugin. A CSS rule matching
* the regular expression will be ignored and will not be available
* in the Styles drop-down list.
* @name CKEDITOR.config.stylesheetParser_skipSelectors
* @type RegExp
* @default /(^body\.|^\.)/i
* @since 3.6
* @see CKEDITOR.config.stylesheetParser_validSelectors
* @example
* // Ignore rules for body and caption elements, classes starting with "high", and any class defined for no specific element.
* config.stylesheetParser_skipSelectors = /(^body\.|^caption\.|\.high|^\.)/i;
*/
/**
* A regular expression that defines which CSS rules will be used
* by the Stylesheet Parser plugin. A CSS rule matching the regular
* expression will be available in the Styles drop-down list.
* @name CKEDITOR.config.stylesheetParser_validSelectors
* @type RegExp
* @default /\w+\.\w+/
* @since 3.6
* @see CKEDITOR.config.stylesheetParser_skipSelectors
* @example
* // Only add rules for p and span elements.
* config.stylesheetParser_validSelectors = /\^(p|span)\.\w+/;
*/
| JavaScript |
/*
Copyright (c) 2003-2012, 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( noChangeEvent )
{
this.setValue( this.getInitValue(), noChangeEvent );
},
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()
{
// Make sure 'onchange' doesn't get fired after dialog closed. (#5719)
if ( !dialog.parts.dialog.isVisible() )
return;
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.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>label</strong> (Required) The label string.</li>
* <li><strong>labelLayout</strong> (Optional) Put 'horizontal' here if the
* label element is to be layed out horizontally. Otherwise a vertical
* layout will be used.</li>
* <li><strong>widths</strong> (Optional) This applies only for horizontal
* layouts - an 2-element array of lengths to specify the widths of the
* label and the content element.</li>
* </ul>
* @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.getNextId() + '_label';
var children = this._.children = [];
/** @ignore */
var innerHTML = function()
{
var html = [],
requiredClass = elementDefinition.required ? ' cke_required' : '' ;
if ( elementDefinition.labelLayout != 'horizontal' )
html.push( '<label class="cke_dialog_ui_labeled_label' + requiredClass + '" ',
' id="'+ _.labelId + '"',
( _.inputId? ' for="' + _.inputId + '"' : '' ),
( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) +'>',
elementDefinition.label,
'</label>',
'<div class="cke_dialog_ui_labeled_content"' + ( elementDefinition.controlStyle ? ' style="' + elementDefinition.controlStyle + '"' : '' ) + ' role="presentation">',
contentHtml.call( this, dialog, elementDefinition ),
'</div>' );
else
{
var hboxDefinition = {
type : 'hbox',
widths : elementDefinition.widths,
padding : 0,
children :
[
{
type : 'html',
html : '<label class="cke_dialog_ui_labeled_label' + requiredClass + '"' +
' id="' + _.labelId + '"' +
' for="' + _.inputId + '"' +
( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) +'>' +
CKEDITOR.tools.htmlEncode( elementDefinition.label ) +
'</span>'
},
{
type : 'html',
html : '<span class="cke_dialog_ui_labeled_content"' + ( elementDefinition.controlStyle ? ' style="' + elementDefinition.controlStyle + '"' : '' ) + '>' +
contentHtml.call( this, dialog, elementDefinition ) +
'</span>'
}
]
};
CKEDITOR.dialog._.uiElementBuilders.hbox.build( dialog, hboxDefinition, html );
}
return html.join( '' );
};
CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'div', null, { role : 'presentation' }, innerHTML );
},
/**
* A text input with a label. This UI element class represents both the
* single-line text inputs and password inputs in dialog boxes.
* @constructor
* @example
* @extends CKEDITOR.ui.dialog.labeledElement
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>default</strong> (Optional) The default value.</li>
* <li><strong>validate</strong> (Optional) The validation function. </li>
* <li><strong>maxLength</strong> (Optional) The maximum length of text box
* contents.</li>
* <li><strong>size</strong> (Optional) The size of the text box. This is
* usually overridden by the size defined by the skin, however.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
textInput : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
initPrivateObject.call( this, elementDefinition );
var domId = this._.inputId = CKEDITOR.tools.getNextId() + '_textInput',
attributes = { 'class' : 'cke_dialog_ui_input_' + elementDefinition.type, id : domId, type : elementDefinition.type },
i;
// Set the validator, if any.
if ( elementDefinition.validate )
this.validate = elementDefinition.validate;
// Set the max length and size.
if ( elementDefinition.maxLength )
attributes.maxlength = elementDefinition.maxLength;
if ( elementDefinition.size )
attributes.size = elementDefinition.size;
if ( elementDefinition.inputStyle )
attributes.style = elementDefinition.inputStyle;
/** @ignore */
var innerHTML = function()
{
// IE BUG: Text input fields in IE at 100% would exceed a <td> or inline
// container's width, so need to wrap it inside a <div>.
var html = [ '<div class="cke_dialog_ui_input_', elementDefinition.type, '" role="presentation"' ];
if ( elementDefinition.width )
html.push( 'style="width:'+ elementDefinition.width +'" ' );
html.push( '><input ' );
attributes[ 'aria-labelledby' ] = this._.labelId;
this._.required && ( attributes[ 'aria-required' ] = this._.required );
for ( var i in attributes )
html.push( i + '="' + attributes[i] + '" ' );
html.push( ' /></div>' );
return html.join( '' );
};
CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
},
/**
* A text area with a label on the top or left.
* @constructor
* @extends CKEDITOR.ui.dialog.labeledElement
* @example
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>rows</strong> (Optional) The number of rows displayed.
* Defaults to 5 if not defined.</li>
* <li><strong>cols</strong> (Optional) The number of cols displayed.
* Defaults to 20 if not defined. Usually overridden by skins.</li>
* <li><strong>default</strong> (Optional) The default value.</li>
* <li><strong>validate</strong> (Optional) The validation function. </li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
textarea : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
initPrivateObject.call( this, elementDefinition );
var me = this,
domId = this._.inputId = CKEDITOR.tools.getNextId() + '_textarea',
attributes = {};
if ( elementDefinition.validate )
this.validate = elementDefinition.validate;
// Generates the essential attributes for the textarea tag.
attributes.rows = elementDefinition.rows || 5;
attributes.cols = elementDefinition.cols || 20;
if ( typeof elementDefinition.inputStyle != 'undefined' )
attributes.style = elementDefinition.inputStyle;
/** @ignore */
var innerHTML = function()
{
attributes[ 'aria-labelledby' ] = this._.labelId;
this._.required && ( attributes[ 'aria-required' ] = this._.required );
var html = [ '<div class="cke_dialog_ui_input_textarea" role="presentation"><textarea class="cke_dialog_ui_input_textarea" id="', domId, '" ' ];
for ( var i in attributes )
html.push( i + '="' + CKEDITOR.tools.htmlEncode( attributes[i] ) + '" ' );
html.push( '>', CKEDITOR.tools.htmlEncode( me._['default'] ), '</textarea></div>' );
return html.join( '' );
};
CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
},
/**
* A single checkbox with a label on the right.
* @constructor
* @extends CKEDITOR.ui.dialog.uiElement
* @example
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>checked</strong> (Optional) Whether the checkbox is checked
* on instantiation. Defaults to false.</li>
* <li><strong>validate</strong> (Optional) The validation function.</li>
* <li><strong>label</strong> (Optional) The checkbox label.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
checkbox : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
var _ = initPrivateObject.call( this, elementDefinition, { 'default' : !!elementDefinition[ 'default' ] } );
if ( elementDefinition.validate )
this.validate = elementDefinition.validate;
/** @ignore */
var innerHTML = function()
{
var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition,
{
id : elementDefinition.id ? elementDefinition.id + '_checkbox' : CKEDITOR.tools.getNextId() + '_checkbox'
}, true ),
html = [];
var labelId = CKEDITOR.tools.getNextId() + '_label';
var attributes = { 'class' : 'cke_dialog_ui_checkbox_input', type : 'checkbox', 'aria-labelledby' : labelId };
cleanInnerDefinition( myDefinition );
if ( elementDefinition[ 'default' ] )
attributes.checked = 'checked';
if ( typeof myDefinition.inputStyle != 'undefined' )
myDefinition.style = myDefinition.inputStyle;
_.checkbox = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'input', null, attributes );
html.push( ' <label id="', labelId, '" for="', attributes.id, '"' + ( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) + '>',
CKEDITOR.tools.htmlEncode( elementDefinition.label ),
'</label>' );
return html.join( '' );
};
CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'span', null, null, innerHTML );
},
/**
* A group of radio buttons.
* @constructor
* @example
* @extends CKEDITOR.ui.dialog.labeledElement
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>default</strong> (Required) The default value.</li>
* <li><strong>validate</strong> (Optional) The validation function.</li>
* <li><strong>items</strong> (Required) An array of options. Each option
* is a 1- or 2-item array of format [ 'Description', 'Value' ]. If 'Value'
* is missing, then the value would be assumed to be the same as the
* description.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
radio : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3)
return;
initPrivateObject.call( this, elementDefinition );
if ( !this._['default'] )
this._['default'] = this._.initValue = elementDefinition.items[0][1];
if ( elementDefinition.validate )
this.validate = elementDefinition.valdiate;
var children = [], me = this;
/** @ignore */
var innerHTML = function()
{
var inputHtmlList = [], html = [],
commonAttributes = { 'class' : 'cke_dialog_ui_radio_item', 'aria-labelledby' : this._.labelId },
commonName = elementDefinition.id ? elementDefinition.id + '_radio' : CKEDITOR.tools.getNextId() + '_radio';
for ( var i = 0 ; i < elementDefinition.items.length ; i++ )
{
var item = elementDefinition.items[i],
title = item[2] !== undefined ? item[2] : item[0],
value = item[1] !== undefined ? item[1] : item[0],
inputId = CKEDITOR.tools.getNextId() + '_radio_input',
labelId = inputId + '_label',
inputDefinition = CKEDITOR.tools.extend( {}, elementDefinition,
{
id : inputId,
title : null,
type : null
}, true ),
labelDefinition = CKEDITOR.tools.extend( {}, inputDefinition,
{
title : title
}, true ),
inputAttributes =
{
type : 'radio',
'class' : 'cke_dialog_ui_radio_input',
name : commonName,
value : value,
'aria-labelledby' : labelId
},
inputHtml = [];
if ( me._['default'] == value )
inputAttributes.checked = 'checked';
cleanInnerDefinition( inputDefinition );
cleanInnerDefinition( labelDefinition );
if ( typeof inputDefinition.inputStyle != 'undefined' )
inputDefinition.style = inputDefinition.inputStyle;
children.push( new CKEDITOR.ui.dialog.uiElement( dialog, inputDefinition, inputHtml, 'input', null, inputAttributes ) );
inputHtml.push( ' ' );
new CKEDITOR.ui.dialog.uiElement( dialog, labelDefinition, inputHtml, 'label', null, { id : labelId, 'for' : inputAttributes.id },
item[0] );
inputHtmlList.push( inputHtml.join( '' ) );
}
new CKEDITOR.ui.dialog.hbox( dialog, children, inputHtmlList, html );
return html.join( '' );
};
CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
this._.children = children;
},
/**
* A button with a label inside.
* @constructor
* @example
* @extends CKEDITOR.ui.dialog.uiElement
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>label</strong> (Required) The button label.</li>
* <li><strong>disabled</strong> (Optional) Set to true if you want the
* button to appear in disabled state.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
button : function( dialog, elementDefinition, htmlList )
{
if ( !arguments.length )
return;
if ( typeof elementDefinition == 'function' )
elementDefinition = elementDefinition( dialog.getParentEditor() );
initPrivateObject.call( this, elementDefinition, { disabled : elementDefinition.disabled || false } );
// Add OnClick event to this input.
CKEDITOR.event.implementOn( this );
var me = this;
// Register an event handler for processing button clicks.
dialog.on( 'load', function( eventInfo )
{
var element = this.getElement();
(function()
{
element.on( 'click', function( evt )
{
me.fire( 'click', { dialog : me.getDialog() } );
evt.data.preventDefault();
} );
element.on( 'keydown', function( evt )
{
if ( evt.data.getKeystroke() in { 32:1 } )
{
me.click();
evt.data.preventDefault();
}
} );
})();
element.unselectable();
}, this );
var outerDefinition = CKEDITOR.tools.extend( {}, elementDefinition );
delete outerDefinition.style;
var labelId = CKEDITOR.tools.getNextId() + '_label';
CKEDITOR.ui.dialog.uiElement.call(
this,
dialog,
outerDefinition,
htmlList,
'a',
null,
{
style : elementDefinition.style,
href : 'javascript:void(0)',
title : elementDefinition.label,
hidefocus : 'true',
'class' : elementDefinition['class'],
role : 'button',
'aria-labelledby' : labelId
},
'<span id="' + labelId + '" class="cke_dialog_ui_button">' +
CKEDITOR.tools.htmlEncode( elementDefinition.label ) +
'</span>' );
},
/**
* A select box.
* @extends CKEDITOR.ui.dialog.uiElement
* @example
* @constructor
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>default</strong> (Required) The default value.</li>
* <li><strong>validate</strong> (Optional) The validation function.</li>
* <li><strong>items</strong> (Required) An array of options. Each option
* is a 1- or 2-item array of format [ 'Description', 'Value' ]. If 'Value'
* is missing, then the value would be assumed to be the same as the
* description.</li>
* <li><strong>multiple</strong> (Optional) Set this to true if you'd like
* to have a multiple-choice select box.</li>
* <li><strong>size</strong> (Optional) The number of items to display in
* the select box.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
select : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
var _ = initPrivateObject.call( this, elementDefinition );
if ( elementDefinition.validate )
this.validate = elementDefinition.validate;
_.inputId = CKEDITOR.tools.getNextId() + '_select';
/** @ignore */
var innerHTML = function()
{
var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition,
{
id : elementDefinition.id ? elementDefinition.id + '_select' : CKEDITOR.tools.getNextId() + '_select'
}, true ),
html = [],
innerHTML = [],
attributes = { 'id' : _.inputId, 'class' : 'cke_dialog_ui_input_select', 'aria-labelledby' : this._.labelId };
// Add multiple and size attributes from element definition.
if ( elementDefinition.size != undefined )
attributes.size = elementDefinition.size;
if ( elementDefinition.multiple != undefined )
attributes.multiple = elementDefinition.multiple;
cleanInnerDefinition( myDefinition );
for ( var i = 0, item ; i < elementDefinition.items.length && ( item = elementDefinition.items[i] ) ; i++ )
{
innerHTML.push( '<option value="',
CKEDITOR.tools.htmlEncode( item[1] !== undefined ? item[1] : item[0] ).replace( /"/g, '"' ), '" /> ',
CKEDITOR.tools.htmlEncode( item[0] ) );
}
if ( typeof myDefinition.inputStyle != 'undefined' )
myDefinition.style = myDefinition.inputStyle;
_.select = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'select', null, attributes, innerHTML.join( '' ) );
return html.join( '' );
};
CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
},
/**
* A file upload input.
* @extends CKEDITOR.ui.dialog.labeledElement
* @example
* @constructor
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>validate</strong> (Optional) The validation function.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
file : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
if ( elementDefinition['default'] === undefined )
elementDefinition['default'] = '';
var _ = CKEDITOR.tools.extend( initPrivateObject.call( this, elementDefinition ), { definition : elementDefinition, buttons : [] } );
if ( elementDefinition.validate )
this.validate = elementDefinition.validate;
/** @ignore */
var innerHTML = function()
{
_.frameId = CKEDITOR.tools.getNextId() + '_fileInput';
// Support for custom document.domain in IE.
var isCustomDomain = CKEDITOR.env.isCustomDomain();
var html = [
'<iframe' +
' frameborder="0"' +
' allowtransparency="0"' +
' class="cke_dialog_ui_input_file"' +
' role="presentation"' +
' id="', _.frameId, '"' +
' title="', elementDefinition.label, '"' +
' src="javascript:void(' ];
html.push(
isCustomDomain ?
'(function(){' +
'document.open();' +
'document.domain=\'' + document.domain + '\';' +
'document.close();' +
'})()'
:
'0' );
html.push(
')">' +
'</iframe>' );
return html.join( '' );
};
// IE BUG: Parent container does not resize to contain the iframe automatically.
dialog.on( 'load', function()
{
var iframe = CKEDITOR.document.getById( _.frameId ),
contentDiv = iframe.getParent();
contentDiv.addClass( 'cke_dialog_ui_input_file' );
} );
CKEDITOR.ui.dialog.labeledElement.call( this, dialog, elementDefinition, htmlList, innerHTML );
},
/**
* A button for submitting the file in a file upload input.
* @extends CKEDITOR.ui.dialog.button
* @example
* @constructor
* @param {CKEDITOR.dialog} dialog
* Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>for</strong> (Required) The file input's page and element Id
* to associate to, in a 2-item array format: [ 'page_id', 'element_id' ].
* </li>
* <li><strong>validate</strong> (Optional) The validation function.</li>
* </ul>
* @param {Array} htmlList
* List of HTML code to output to.
*/
fileButton : function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
var _ = initPrivateObject.call( this, elementDefinition ),
me = this;
if ( elementDefinition.validate )
this.validate = elementDefinition.validate;
var myDefinition = CKEDITOR.tools.extend( {}, elementDefinition );
var onClick = myDefinition.onClick;
myDefinition.className = ( myDefinition.className ? myDefinition.className + ' ' : '' ) + 'cke_dialog_ui_button';
myDefinition.onClick = function( evt )
{
var target = elementDefinition[ 'for' ]; // [ pageId, elementId ]
if ( !onClick || onClick.call( this, evt ) !== false )
{
dialog.getContentElement( target[0], target[1] ).submit();
this.disable();
}
};
dialog.on( 'load', function()
{
dialog.getContentElement( elementDefinition[ 'for' ][0], elementDefinition[ 'for' ][1] )._.buttons.push( me );
} );
CKEDITOR.ui.dialog.button.call( this, dialog, myDefinition, htmlList );
},
html : (function()
{
var myHtmlRe = /^\s*<[\w:]+\s+([^>]*)?>/,
theirHtmlRe = /^(\s*<[\w:]+(?:\s+[^>]*)?)((?:.|\r|\n)+)$/,
emptyTagRe = /\/$/;
/**
* A dialog element made from raw HTML code.
* @extends CKEDITOR.ui.dialog.uiElement
* @name CKEDITOR.ui.dialog.html
* @param {CKEDITOR.dialog} dialog Parent dialog object.
* @param {CKEDITOR.dialog.definition.uiElement} elementDefinition Element definition.
* Accepted fields:
* <ul>
* <li><strong>html</strong> (Required) HTML code of this element.</li>
* </ul>
* @param {Array} htmlList List of HTML code to be added to the dialog's content area.
* @example
* @constructor
*/
return function( dialog, elementDefinition, htmlList )
{
if ( arguments.length < 3 )
return;
var myHtmlList = [],
myHtml,
theirHtml = elementDefinition.html,
myMatch, theirMatch;
// If the HTML input doesn't contain any tags at the beginning, add a <span> tag around it.
if ( theirHtml.charAt( 0 ) != '<' )
theirHtml = '<span>' + theirHtml + '</span>';
// Look for focus function in definition.
var focus = elementDefinition.focus;
if ( focus )
{
var oldFocus = this.focus;
this.focus = function()
{
oldFocus.call( this );
typeof focus == 'function' && focus.call( this );
this.fire( 'focus' );
};
if ( elementDefinition.isFocusable )
{
var oldIsFocusable = this.isFocusable;
this.isFocusable = oldIsFocusable;
}
this.keyboardFocusable = true;
}
CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, myHtmlList, 'span', null, null, '' );
// Append the attributes created by the uiElement call to the real HTML.
myHtml = myHtmlList.join( '' );
myMatch = myHtml.match( myHtmlRe );
theirMatch = theirHtml.match( theirHtmlRe ) || [ '', '', '' ];
if ( emptyTagRe.test( theirMatch[1] ) )
{
theirMatch[1] = theirMatch[1].slice( 0, -1 );
theirMatch[2] = '/' + theirMatch[2];
}
htmlList.push( [ theirMatch[1], ' ', myMatch[1] || '', theirMatch[2] ].join( '' ) );
};
})(),
/**
* Form fieldset for grouping dialog UI elements.
* @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.definition.uiElement} elementDefinition
* The element definition. Accepted fields:
* <ul>
* <li><strong>label</strong> (Optional) The legend of the this fieldset.</li>
* <li><strong>children</strong> (Required) An array of dialog field definitions which will be grouped inside this fieldset. </li>
* </ul>
*/
fieldset : function( dialog, childObjList, childHtmlList, htmlList, elementDefinition )
{
var legendLabel = elementDefinition.label;
/** @ignore */
var innerHTML = function()
{
var html = [];
legendLabel && html.push( '<legend' +
( elementDefinition.labelStyle ? ' style="' + elementDefinition.labelStyle + '"' : '' ) +
'>' + legendLabel + '</legend>' );
for ( var i = 0; i < childHtmlList.length; i++ )
html.push( childHtmlList[ i ] );
return html.join( '' );
};
this._ = { children : childObjList };
CKEDITOR.ui.dialog.uiElement.call( this, dialog, elementDefinition, htmlList, 'fieldset', null, null, innerHTML );
}
}, true );
CKEDITOR.ui.dialog.html.prototype = new CKEDITOR.ui.dialog.uiElement;
CKEDITOR.ui.dialog.labeledElement.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
/** @lends CKEDITOR.ui.dialog.labeledElement.prototype */
{
/**
* Sets the label text of the element.
* @param {String} label The new label text.
* @returns {CKEDITOR.ui.dialog.labeledElement} The current labeled element.
* @example
*/
setLabel : function( label )
{
var node = CKEDITOR.document.getById( this._.labelId );
if ( node.getChildCount() < 1 )
( new CKEDITOR.dom.text( label, CKEDITOR.document ) ).appendTo( node );
else
node.getChild( 0 ).$.nodeValue = label;
return this;
},
/**
* Retrieves the current label text of the elment.
* @returns {String} The current label text.
* @example
*/
getLabel : function()
{
var node = CKEDITOR.document.getById( this._.labelId );
if ( !node || node.getChildCount() < 1 )
return '';
else
return node.getChild( 0 ).getText();
},
/**
* Defines the onChange event for UI element definitions.
* @field
* @type Object
* @example
*/
eventProcessors : commonEventProcessors
}, true );
CKEDITOR.ui.dialog.button.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
/** @lends CKEDITOR.ui.dialog.button.prototype */
{
/**
* Simulates a click to the button.
* @example
* @returns {Object} Return value of the 'click' event.
*/
click : function()
{
if ( !this._.disabled )
return this.fire( 'click', { dialog : this._.dialog } );
this.getElement().$.blur();
return false;
},
/**
* Enables the button.
* @example
*/
enable : function()
{
this._.disabled = false;
var element = this.getElement();
element && element.removeClass( 'cke_disabled' );
},
/**
* Disables the button.
* @example
*/
disable : function()
{
this._.disabled = true;
this.getElement().addClass( 'cke_disabled' );
},
isVisible : function()
{
return this.getElement().getFirst().isVisible();
},
isEnabled : function()
{
return !this._.disabled;
},
/**
* Defines the onChange event and onClick for button element definitions.
* @field
* @type Object
* @example
*/
eventProcessors : CKEDITOR.tools.extend( {}, CKEDITOR.ui.dialog.uiElement.prototype.eventProcessors,
{
/** @ignore */
onClick : function( dialog, func )
{
this.on( 'click', function()
{
// Some browsers (Chrome, IE8, IE7 compat mode) don't move
// focus to clicked button. Force this.
this.getElement().focus();
func.apply( this, arguments );
});
}
}, true ),
/**
* Handler for the element's access key up event. Simulates a click to
* the button.
* @example
*/
accessKeyUp : function()
{
this.click();
},
/**
* Handler for the element's access key down event. Simulates a mouse
* down to the button.
* @example
*/
accessKeyDown : function()
{
this.focus();
},
keyboardFocusable : true
}, true );
CKEDITOR.ui.dialog.textInput.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement,
/** @lends CKEDITOR.ui.dialog.textInput.prototype */
{
/**
* Gets the text input DOM element under this UI object.
* @example
* @returns {CKEDITOR.dom.element} The DOM element of the text input.
*/
getInputElement : function()
{
return CKEDITOR.document.getById( this._.inputId );
},
/**
* Puts focus into the text input.
* @example
*/
focus : function()
{
var me = this.selectParentTab();
// GECKO BUG: setTimeout() is needed to workaround invisible selections.
setTimeout( function()
{
var element = me.getInputElement();
element && element.$.focus();
}, 0 );
},
/**
* Selects all the text in the text input.
* @example
*/
select : function()
{
var me = this.selectParentTab();
// GECKO BUG: setTimeout() is needed to workaround invisible selections.
setTimeout( function()
{
var e = me.getInputElement();
if ( e )
{
e.$.focus();
e.$.select();
}
}, 0 );
},
/**
* Handler for the text input's access key up event. Makes a select()
* call to the text input.
* @example
*/
accessKeyUp : function()
{
this.select();
},
/**
* Sets the value of this text input object.
* @param {Object} value The new value.
* @returns {CKEDITOR.ui.dialog.textInput} The current UI element.
* @example
* uiElement.setValue( 'Blamo' );
*/
setValue : function( value )
{
!value && ( value = '' );
return CKEDITOR.ui.dialog.uiElement.prototype.setValue.apply( this, arguments );
},
keyboardFocusable : true
}, commonPrototype, true );
CKEDITOR.ui.dialog.textarea.prototype = new CKEDITOR.ui.dialog.textInput();
CKEDITOR.ui.dialog.select.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement,
/** @lends CKEDITOR.ui.dialog.select.prototype */
{
/**
* Gets the DOM element of the select box.
* @returns {CKEDITOR.dom.element} The <select> element of this UI
* element.
* @example
*/
getInputElement : function()
{
return this._.select.getElement();
},
/**
* Adds an option to the select box.
* @param {String} label Option label.
* @param {String} value (Optional) Option value, if not defined it'll be
* assumed to be the same as the label.
* @param {Number} index (Optional) Position of the option to be inserted
* to. If not defined the new option will be inserted to the end of list.
* @example
* @returns {CKEDITOR.ui.dialog.select} The current select UI element.
*/
add : function( label, value, index )
{
var option = new CKEDITOR.dom.element( 'option', this.getDialog().getParentEditor().document ),
selectElement = this.getInputElement().$;
option.$.text = label;
option.$.value = ( value === undefined || value === null ) ? label : value;
if ( index === undefined || index === null )
{
if ( CKEDITOR.env.ie )
selectElement.add( option.$ );
else
selectElement.add( option.$, null );
}
else
selectElement.add( option.$, index );
return this;
},
/**
* Removes an option from the selection list.
* @param {Number} index Index of the option to be removed.
* @example
* @returns {CKEDITOR.ui.dialog.select} The current select UI element.
*/
remove : function( index )
{
var selectElement = this.getInputElement().$;
selectElement.remove( index );
return this;
},
/**
* Clears all options out of the selection list.
* @returns {CKEDITOR.ui.dialog.select} The current select UI element.
*/
clear : function()
{
var selectElement = this.getInputElement().$;
while ( selectElement.length > 0 )
selectElement.remove( 0 );
return this;
},
keyboardFocusable : true
}, commonPrototype, true );
CKEDITOR.ui.dialog.checkbox.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
/** @lends CKEDITOR.ui.dialog.checkbox.prototype */
{
/**
* Gets the checkbox DOM element.
* @example
* @returns {CKEDITOR.dom.element} The DOM element of the checkbox.
*/
getInputElement : function()
{
return this._.checkbox.getElement();
},
/**
* Sets the state of the checkbox.
* @example
* @param {Boolean} true to tick the checkbox, false to untick it.
* @param {Boolean} noChangeEvent Internal commit, to supress 'change' event on this element.
*/
setValue : function( checked, noChangeEvent )
{
this.getInputElement().$.checked = checked;
!noChangeEvent && this.fire( 'change', { value : checked } );
},
/**
* Gets the state of the checkbox.
* @example
* @returns {Boolean} true means the checkbox is ticked, false means it's not ticked.
*/
getValue : function()
{
return this.getInputElement().$.checked;
},
/**
* Handler for the access key up event. Toggles the checkbox.
* @example
*/
accessKeyUp : function()
{
this.setValue( !this.getValue() );
},
/**
* Defines the onChange event for UI element definitions.
* @field
* @type Object
* @example
*/
eventProcessors :
{
onChange : function( dialog, func )
{
if ( !CKEDITOR.env.ie )
return commonEventProcessors.onChange.apply( this, arguments );
else
{
dialog.on( 'load', function()
{
var element = this._.checkbox.getElement();
element.on( 'propertychange', function( evt )
{
evt = evt.data.$;
if ( evt.propertyName == 'checked' )
this.fire( 'change', { value : element.$.checked } );
}, this );
}, this );
this.on( 'change', func );
}
return null;
}
},
keyboardFocusable : true
}, commonPrototype, true );
CKEDITOR.ui.dialog.radio.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.uiElement,
/** @lends CKEDITOR.ui.dialog.radio.prototype */
{
/**
* Checks one of the radio buttons in this button group.
* @example
* @param {String} value The value of the button to be chcked.
* @param {Boolean} noChangeEvent Internal commit, to supress 'change' event on this element.
*/
setValue : function( value, noChangeEvent )
{
var children = this._.children,
item;
for ( var i = 0 ; ( i < children.length ) && ( item = children[i] ) ; i++ )
item.getElement().$.checked = ( item.getValue() == value );
!noChangeEvent && this.fire( 'change', { value : value } );
},
/**
* Gets the value of the currently checked radio button.
* @example
* @returns {String} The currently checked button's value.
*/
getValue : function()
{
var children = this._.children;
for ( var i = 0 ; i < children.length ; i++ )
{
if ( children[i].getElement().$.checked )
return children[i].getValue();
}
return null;
},
/**
* Handler for the access key up event. Focuses the currently
* selected radio button, or the first radio button if none is
* selected.
* @example
*/
accessKeyUp : function()
{
var children = this._.children, i;
for ( i = 0 ; i < children.length ; i++ )
{
if ( children[i].getElement().$.checked )
{
children[i].getElement().focus();
return;
}
}
children[0].getElement().focus();
},
/**
* Defines the onChange event for UI element definitions.
* @field
* @type Object
* @example
*/
eventProcessors :
{
onChange : function( dialog, func )
{
if ( !CKEDITOR.env.ie )
return commonEventProcessors.onChange.apply( this, arguments );
else
{
dialog.on( 'load', function()
{
var children = this._.children, me = this;
for ( var i = 0 ; i < children.length ; i++ )
{
var element = children[i].getElement();
element.on( 'propertychange', function( evt )
{
evt = evt.data.$;
if ( evt.propertyName == 'checked' && this.$.checked )
me.fire( 'change', { value : this.getAttribute( 'value' ) } );
} );
}
}, this );
this.on( 'change', func );
}
return null;
}
},
keyboardFocusable : true
}, commonPrototype, true );
CKEDITOR.ui.dialog.file.prototype = CKEDITOR.tools.extend( new CKEDITOR.ui.dialog.labeledElement,
commonPrototype,
/** @lends CKEDITOR.ui.dialog.file.prototype */
{
/**
* Gets the <input> element of this file input.
* @returns {CKEDITOR.dom.element} The file input element.
* @example
*/
getInputElement : function()
{
var frameDocument = CKEDITOR.document.getById( this._.frameId ).getFrameDocument();
return frameDocument.$.forms.length > 0 ?
new CKEDITOR.dom.element( frameDocument.$.forms[0].elements[0] ) :
this.getElement();
},
/**
* Uploads the file in the file input.
* @returns {CKEDITOR.ui.dialog.file} This object.
* @example
*/
submit : function()
{
this.getInputElement().getParent().$.submit();
return this;
},
/**
* Get the action assigned to the form.
* @returns {String} The value of the action.
* @example
*/
getAction : function()
{
return this.getInputElement().getParent().$.action;
},
/**
* The events must be applied on the inner input element, and
* that must be done when the iframe & form has been loaded
*/
registerEvents : function( definition )
{
var regex = /^on([A-Z]\w+)/,
match;
var registerDomEvent = function( uiElement, dialog, eventName, func )
{
uiElement.on( 'formLoaded', 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;
},
/**
* Redraws the file input and resets the file path in the file input.
* The redraw logic is necessary because non-IE browsers tend to clear
* the <iframe> containing the file input after closing the dialog.
* @example
*/
reset : function()
{
var _ = this._,
frameElement = CKEDITOR.document.getById( _.frameId ),
frameDocument = frameElement.getFrameDocument(),
elementDefinition = _.definition,
buttons = _.buttons,
callNumber = this.formLoadedNumber,
unloadNumber = this.formUnloadNumber,
langDir = _.dialog._.editor.lang.dir,
langCode = _.dialog._.editor.langCode;
// The callback function for the iframe, but we must call tools.addFunction only once
// so we store the function number in this.formLoadedNumber
if ( !callNumber )
{
callNumber = this.formLoadedNumber = CKEDITOR.tools.addFunction(
function()
{
// Now we can apply the events to the input type=file
this.fire( 'formLoaded' ) ;
}, this ) ;
// Remove listeners attached to the content of the iframe (the file input)
unloadNumber = this.formUnloadNumber = CKEDITOR.tools.addFunction(
function()
{
this.getInputElement().clearCustomData();
}, this ) ;
this.getDialog()._.editor.on( 'destroy', function()
{
CKEDITOR.tools.removeFunction( callNumber );
CKEDITOR.tools.removeFunction( unloadNumber );
} );
}
function generateFormField()
{
frameDocument.$.open();
// Support for custom document.domain in IE.
if ( CKEDITOR.env.isCustomDomain() )
frameDocument.$.domain = document.domain;
var size = '';
if ( elementDefinition.size )
size = elementDefinition.size - ( CKEDITOR.env.ie ? 7 : 0 ); // "Browse" button is bigger in IE.
var inputId = _.frameId + '_input';
frameDocument.$.write( [ '<html dir="' + langDir + '" lang="' + langCode + '"><head><title></title></head><body style="margin: 0; overflow: hidden; background: transparent;">',
'<form enctype="multipart/form-data" method="POST" dir="' + langDir + '" lang="' + langCode + '" action="',
CKEDITOR.tools.htmlEncode( elementDefinition.action ),
'">',
// Replicate the field label inside of iframe.
'<label id="', _.labelId, '" for="', inputId, '" style="display:none">',
CKEDITOR.tools.htmlEncode( elementDefinition.label ),
'</label>',
'<input id="', inputId, '" aria-labelledby="', _.labelId,'" type="file" name="',
CKEDITOR.tools.htmlEncode( elementDefinition.id || 'cke_upload' ),
'" size="',
CKEDITOR.tools.htmlEncode( size > 0 ? size : "" ),
'" />',
'</form>',
'</body></html>',
'<script>window.parent.CKEDITOR.tools.callFunction(' + callNumber + ');',
'window.onbeforeunload = function() {window.parent.CKEDITOR.tools.callFunction(' + unloadNumber + ')}</script>' ].join( '' ) );
frameDocument.$.close();
for ( var i = 0 ; i < buttons.length ; i++ )
buttons[i].enable();
}
// #3465: Wait for the browser to finish rendering the dialog first.
if ( CKEDITOR.env.gecko )
setTimeout( generateFormField, 500 );
else
generateFormField();
},
getValue : function()
{
return this.getInputElement().$.value || '';
},
/***
* The default value of input type="file" is an empty string, but during initialization
* of this UI element, the iframe still isn't ready so it can't be read from that object
* Setting it manually prevents later issues about the current value ("") being different
* of the initial value (undefined as it asked for .value of a div)
*/
setInitValue : function()
{
this._.initValue = '';
},
/**
* Defines the onChange event for UI element definitions.
* @field
* @type Object
* @example
*/
eventProcessors :
{
onChange : function( dialog, func )
{
// If this method is called several times (I'm not sure about how this can happen but the default
// onChange processor includes this protection)
// In order to reapply to the new element, the property is deleted at the beggining of the registerEvents method
if ( !this._.domOnChangeRegistered )
{
// By listening for the formLoaded event, this handler will get reapplied when a new
// form is created
this.on( 'formLoaded', function()
{
this.getInputElement().on( 'change', function(){ this.fire( 'change', { value : this.getValue() } ); }, this );
}, this );
this._.domOnChangeRegistered = true;
}
this.on( 'change', func );
}
},
keyboardFocusable : true
}, true );
CKEDITOR.ui.dialog.fileButton.prototype = new CKEDITOR.ui.dialog.button;
CKEDITOR.ui.dialog.fieldset.prototype = CKEDITOR.tools.clone( CKEDITOR.ui.dialog.hbox.prototype );
CKEDITOR.dialog.addUIElement( 'text', textBuilder );
CKEDITOR.dialog.addUIElement( 'password', textBuilder );
CKEDITOR.dialog.addUIElement( 'textarea', commonBuilder );
CKEDITOR.dialog.addUIElement( 'checkbox', commonBuilder );
CKEDITOR.dialog.addUIElement( 'radio', commonBuilder );
CKEDITOR.dialog.addUIElement( 'button', commonBuilder );
CKEDITOR.dialog.addUIElement( 'select', commonBuilder );
CKEDITOR.dialog.addUIElement( 'file', commonBuilder );
CKEDITOR.dialog.addUIElement( 'fileButton', commonBuilder );
CKEDITOR.dialog.addUIElement( 'html', commonBuilder );
CKEDITOR.dialog.addUIElement( 'fieldset', containerBuilder );
})();
/**
* Fired when the value of the uiElement is changed
* @name CKEDITOR.ui.dialog.uiElement#change
* @event
*/
/**
* Fired when the inner frame created by the element is ready.
* Each time the button is used or the dialog is loaded a new
* form might be created.
* @name CKEDITOR.ui.dialog.fileButton#formLoaded
* @event
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var cssStyle = CKEDITOR.htmlParser.cssStyle,
cssLength = CKEDITOR.tools.cssLength;
var cssLengthRegex = /^((?:\d*(?:\.\d+))|(?:\d+))(.*)?$/i;
/*
* Replacing the former CSS length value with the later one, with
* adjustment to the length unit.
*/
function replaceCssLength( length1, length2 )
{
var parts1 = cssLengthRegex.exec( length1 ),
parts2 = cssLengthRegex.exec( length2 );
// Omit pixel length unit when necessary,
// e.g. replaceCssLength( 10, '20px' ) -> 20
if ( parts1 )
{
if ( !parts1[ 2 ] && parts2[ 2 ] == 'px' )
return parts2[ 1 ];
if ( parts1[ 2 ] == 'px' && !parts2[ 2 ] )
return parts2[ 1 ] + 'px';
}
return length2;
}
var htmlFilterRules =
{
elements :
{
$ : function( element )
{
var attributes = element.attributes,
realHtml = attributes && attributes[ 'data-cke-realelement' ],
realFragment = realHtml && new CKEDITOR.htmlParser.fragment.fromHtml( decodeURIComponent( realHtml ) ),
realElement = realFragment && realFragment.children[ 0 ];
// Width/height in the fake object are subjected to clone into the real element.
if ( realElement && element.attributes[ 'data-cke-resizable' ] )
{
var styles = new cssStyle( element ).rules,
realAttrs = realElement.attributes,
width = styles.width,
height = styles.height;
width && ( realAttrs.width = replaceCssLength( realAttrs.width, width ) );
height && ( realAttrs.height = replaceCssLength( realAttrs.height, height ) );
}
return realElement;
}
}
};
CKEDITOR.plugins.add( 'fakeobjects',
{
requires : [ 'htmlwriter' ],
afterInit : function( editor )
{
var dataProcessor = editor.dataProcessor,
htmlFilter = dataProcessor && dataProcessor.htmlFilter;
if ( htmlFilter )
htmlFilter.addRules( htmlFilterRules );
}
});
CKEDITOR.editor.prototype.createFakeElement = function( realElement, className, realElementType, isResizable )
{
var lang = this.lang.fakeobjects,
label = lang[ realElementType ] || lang.unknown;
var attributes =
{
'class' : className,
'data-cke-realelement' : encodeURIComponent( realElement.getOuterHtml() ),
'data-cke-real-node-type' : realElement.type,
alt : label,
title : label,
align : realElement.getAttribute( 'align' ) || ''
};
// Do not set "src" on high-contrast so the alt text is displayed. (#8945)
if ( !CKEDITOR.env.hc )
attributes.src = CKEDITOR.getUrl( 'images/spacer.gif' );
if ( realElementType )
attributes[ 'data-cke-real-element-type' ] = realElementType;
if ( isResizable )
{
attributes[ 'data-cke-resizable' ] = isResizable;
var fakeStyle = new cssStyle();
var width = realElement.getAttribute( 'width' ),
height = realElement.getAttribute( 'height' );
width && ( fakeStyle.rules.width = cssLength( width ) );
height && ( fakeStyle.rules.height = cssLength( height ) );
fakeStyle.populate( attributes );
}
return this.document.createElement( 'img', { attributes : attributes } );
};
CKEDITOR.editor.prototype.createFakeParserElement = function( realElement, className, realElementType, isResizable )
{
var lang = this.lang.fakeobjects,
label = lang[ realElementType ] || lang.unknown,
html;
var writer = new CKEDITOR.htmlParser.basicWriter();
realElement.writeHtml( writer );
html = writer.getHtml();
var attributes =
{
'class' : className,
'data-cke-realelement' : encodeURIComponent( html ),
'data-cke-real-node-type' : realElement.type,
alt : label,
title : label,
align : realElement.attributes.align || ''
};
// Do not set "src" on high-contrast so the alt text is displayed. (#8945)
if ( !CKEDITOR.env.hc )
attributes.src = CKEDITOR.getUrl( 'images/spacer.gif' );
if ( realElementType )
attributes[ 'data-cke-real-element-type' ] = realElementType;
if ( isResizable )
{
attributes[ 'data-cke-resizable' ] = isResizable;
var realAttrs = realElement.attributes,
fakeStyle = new cssStyle();
var width = realAttrs.width,
height = realAttrs.height;
width != undefined && ( fakeStyle.rules.width = cssLength( width ) );
height != undefined && ( fakeStyle.rules.height = cssLength ( height ) );
fakeStyle.populate( attributes );
}
return new CKEDITOR.htmlParser.element( 'img', attributes );
};
CKEDITOR.editor.prototype.restoreRealElement = function( fakeElement )
{
if ( fakeElement.data( 'cke-real-node-type' ) != CKEDITOR.NODE_ELEMENT )
return null;
var element = CKEDITOR.dom.element.createFromHtml(
decodeURIComponent( fakeElement.data( 'cke-realelement' ) ),
this.document );
if ( fakeElement.data( 'cke-resizable') )
{
var width = fakeElement.getStyle( 'width' ),
height = fakeElement.getStyle( 'height' );
width && element.setAttribute( 'width', replaceCssLength( element.getAttribute( 'width' ), width ) );
height && element.setAttribute( 'height', replaceCssLength( element.getAttribute( 'height' ), height ) );
}
return element;
};
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'floatpanel',
{
requires : [ 'panel' ]
});
(function()
{
var panels = {};
var isShowing = false;
function getPanel( editor, doc, parentElement, definition, level )
{
// Generates the panel key: docId-eleId-skinName-langDir[-uiColor][-CSSs][-level]
var key = CKEDITOR.tools.genKey( doc.getUniqueId(), parentElement.getUniqueId(), editor.skinName, editor.lang.dir,
editor.uiColor || '', definition.css || '', level || '' );
var panel = panels[ key ];
if ( !panel )
{
panel = panels[ key ] = new CKEDITOR.ui.panel( doc, definition );
panel.element = parentElement.append( CKEDITOR.dom.element.createFromHtml( panel.renderHtml( editor ), doc ) );
panel.element.setStyles(
{
display : 'none',
position : 'absolute'
});
}
return panel;
}
CKEDITOR.ui.floatPanel = CKEDITOR.tools.createClass(
{
$ : function( editor, parentElement, definition, level )
{
definition.forceIFrame = 1;
var doc = parentElement.getDocument(),
panel = getPanel( editor, doc, parentElement, definition, level || 0 ),
element = panel.element,
iframe = element.getFirst().getFirst();
// Disable native browser menu. (#4825)
element.disableContextMenu();
this.element = element;
this._ =
{
editor : editor,
// The panel that will be floating.
panel : panel,
parentElement : parentElement,
definition : definition,
document : doc,
iframe : iframe,
children : [],
dir : editor.lang.dir
};
editor.on( 'mode', function(){ this.hide(); }, this );
},
proto :
{
addBlock : function( name, block )
{
return this._.panel.addBlock( name, block );
},
addListBlock : function( name, multiSelect )
{
return this._.panel.addListBlock( name, multiSelect );
},
getBlock : function( name )
{
return this._.panel.getBlock( name );
},
/*
corner (LTR):
1 = top-left
2 = top-right
3 = bottom-right
4 = bottom-left
corner (RTL):
1 = top-right
2 = top-left
3 = bottom-left
4 = bottom-right
*/
showBlock : function( name, offsetParent, corner, offsetX, offsetY )
{
var panel = this._.panel,
block = panel.showBlock( name );
this.allowBlur( false );
isShowing = 1;
// Record from where the focus is when open panel.
this._.returnFocus = this._.editor.focusManager.hasFocus ? this._.editor : new CKEDITOR.dom.element( CKEDITOR.document.$.activeElement );
var element = this.element,
iframe = this._.iframe,
definition = this._.definition,
position = offsetParent.getDocumentPosition( element.getDocument() ),
rtl = this._.dir == 'rtl';
var left = position.x + ( offsetX || 0 ),
top = position.y + ( offsetY || 0 );
// Floating panels are off by (-1px, 0px) in RTL mode. (#3438)
if ( rtl && ( corner == 1 || corner == 4 ) )
left += offsetParent.$.offsetWidth;
else if ( !rtl && ( corner == 2 || corner == 3 ) )
left += offsetParent.$.offsetWidth - 1;
if ( corner == 3 || corner == 4 )
top += offsetParent.$.offsetHeight - 1;
// Memorize offsetParent by it's ID.
this._.panel._.offsetParentId = offsetParent.getId();
element.setStyles(
{
top : top + 'px',
left: 0,
display : ''
});
// Don't use display or visibility style because we need to
// calculate the rendering layout later and focus the element.
element.setOpacity( 0 );
// To allow the context menu to decrease back their width
element.getFirst().removeStyle( 'width' );
// Configure the IFrame blur event. Do that only once.
if ( !this._.blurSet )
{
// Non IE prefer the event into a window object.
var focused = CKEDITOR.env.ie ? iframe : new CKEDITOR.dom.window( iframe.$.contentWindow );
// With addEventListener compatible browsers, we must
// useCapture when registering the focus/blur events to
// guarantee they will be firing in all situations. (#3068, #3222 )
CKEDITOR.event.useCapture = true;
focused.on( 'blur', function( ev )
{
if ( !this.allowBlur() )
return;
// As we are using capture to register the listener,
// the blur event may get fired even when focusing
// inside the window itself, so we must ensure the
// target is out of it.
var target = ev.data.getTarget() ;
if ( target.getName && target.getName() != 'iframe' )
return;
if ( this.visible && !this._.activeChild && !isShowing )
{
// Panel close is caused by user's navigating away the focus, e.g. click outside the panel.
// DO NOT restore focus in this case.
delete this._.returnFocus;
this.hide();
}
},
this );
focused.on( 'focus', function()
{
this._.focused = true;
this.hideChild();
this.allowBlur( true );
},
this );
CKEDITOR.event.useCapture = false;
this._.blurSet = 1;
}
panel.onEscape = CKEDITOR.tools.bind( function( keystroke )
{
if ( this.onEscape && this.onEscape( keystroke ) === false )
return false;
},
this );
CKEDITOR.tools.setTimeout( function()
{
var panelLoad = CKEDITOR.tools.bind( function ()
{
var target = element.getFirst();
if ( block.autoSize )
{
// We must adjust first the width or IE6 could include extra lines in the height computation
var widthNode = block.element.$;
if ( CKEDITOR.env.gecko || CKEDITOR.env.opera )
widthNode = widthNode.parentNode;
if ( CKEDITOR.env.ie )
widthNode = widthNode.document.body;
var width = widthNode.scrollWidth;
// Account for extra height needed due to IE quirks box model bug:
// http://en.wikipedia.org/wiki/Internet_Explorer_box_model_bug
// (#3426)
if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && width > 0 )
width += ( target.$.offsetWidth || 0 ) - ( target.$.clientWidth || 0 ) + 3;
// A little extra at the end.
// If not present, IE6 might break into the next line, but also it looks better this way
width += 4 ;
target.setStyle( 'width', width + 'px' );
// IE doesn't compute the scrollWidth if a filter is applied previously
block.element.addClass( 'cke_frameLoaded' );
var height = block.element.$.scrollHeight;
// Account for extra height needed due to IE quirks box model bug:
// http://en.wikipedia.org/wiki/Internet_Explorer_box_model_bug
// (#3426)
if ( CKEDITOR.env.ie && CKEDITOR.env.quirks && height > 0 )
height += ( target.$.offsetHeight || 0 ) - ( target.$.clientHeight || 0 ) + 3;
target.setStyle( 'height', height + 'px' );
// Fix IE < 8 visibility.
panel._.currentBlock.element.setStyle( 'display', 'none' ).removeStyle( 'display' );
}
else
target.removeStyle( 'height' );
// Flip panel layout horizontally in RTL with known width.
if ( rtl )
left -= element.$.offsetWidth;
// Pop the style now for measurement.
element.setStyle( 'left', left + 'px' );
/* panel layout smartly fit the viewport size. */
var panelElement = panel.element,
panelWindow = panelElement.getWindow(),
rect = element.$.getBoundingClientRect(),
viewportSize = panelWindow.getViewPaneSize();
// Compensation for browsers that dont support "width" and "height".
var rectWidth = rect.width || rect.right - rect.left,
rectHeight = rect.height || rect.bottom - rect.top;
// Check if default horizontal layout is impossible.
var spaceAfter = rtl ? rect.right : viewportSize.width - rect.left,
spaceBefore = rtl ? viewportSize.width - rect.right : rect.left;
if ( rtl )
{
if ( spaceAfter < rectWidth )
{
// Flip to show on right.
if ( spaceBefore > rectWidth )
left += rectWidth;
// Align to window left.
else if ( viewportSize.width > rectWidth )
left = left - rect.left;
// Align to window right, never cutting the panel at right.
else
left = left - rect.right + viewportSize.width;
}
}
else if ( spaceAfter < rectWidth )
{
// Flip to show on left.
if ( spaceBefore > rectWidth )
left -= rectWidth;
// Align to window right.
else if ( viewportSize.width > rectWidth )
left = left - rect.right + viewportSize.width;
// Align to window left, never cutting the panel at left.
else
left = left - rect.left;
}
// Check if the default vertical layout is possible.
var spaceBelow = viewportSize.height - rect.top,
spaceAbove = rect.top;
if ( spaceBelow < rectHeight )
{
// Flip to show above.
if ( spaceAbove > rectHeight )
top -= rectHeight;
// Align to window bottom.
else if ( viewportSize.height > rectHeight )
top = top - rect.bottom + viewportSize.height;
// Align to top, never cutting the panel at top.
else
top = top - rect.top;
}
// If IE is in RTL, we have troubles with absolute
// position and horizontal scrolls. Here we have a
// series of hacks to workaround it. (#6146)
if ( CKEDITOR.env.ie )
{
var offsetParent = new CKEDITOR.dom.element( element.$.offsetParent ),
scrollParent = offsetParent;
// Quirks returns <body>, but standards returns <html>.
if ( scrollParent.getName() == 'html' )
scrollParent = scrollParent.getDocument().getBody();
if ( scrollParent.getComputedStyle( 'direction' ) == 'rtl' )
{
// For IE8, there is not much logic on this, but it works.
if ( CKEDITOR.env.ie8Compat )
left -= element.getDocument().getDocumentElement().$.scrollLeft * 2;
else
left -= ( offsetParent.$.scrollWidth - offsetParent.$.clientWidth );
}
}
// Trigger the onHide event of the previously active panel to prevent
// incorrect styles from being applied (#6170)
var innerElement = element.getFirst(),
activePanel;
if ( ( activePanel = innerElement.getCustomData( 'activePanel' ) ) )
activePanel.onHide && activePanel.onHide.call( this, 1 );
innerElement.setCustomData( 'activePanel', this );
element.setStyles(
{
top : top + 'px',
left : left + 'px'
} );
element.setOpacity( 1 );
} , this );
panel.isLoaded ? panelLoad() : panel.onLoad = panelLoad;
// Set the panel frame focus, so the blur event gets fired.
CKEDITOR.tools.setTimeout( function()
{
iframe.$.contentWindow.focus();
// We need this get fired manually because of unfired focus() function.
this.allowBlur( true );
}, 0, this);
}, CKEDITOR.env.air ? 200 : 0, this);
this.visible = 1;
if ( this.onShow )
this.onShow.call( this );
isShowing = 0;
},
hide : function( returnFocus )
{
if ( this.visible && ( !this.onHide || this.onHide.call( this ) !== true ) )
{
this.hideChild();
// Blur previously focused element. (#6671)
CKEDITOR.env.gecko && this._.iframe.getFrameDocument().$.activeElement.blur();
this.element.setStyle( 'display', 'none' );
this.visible = 0;
this.element.getFirst().removeCustomData( 'activePanel' );
// Return focus properly. (#6247)
var focusReturn = returnFocus !== false && this._.returnFocus;
if ( focusReturn )
{
// Webkit requires focus moved out panel iframe first.
if ( CKEDITOR.env.webkit && focusReturn.type )
focusReturn.getWindow().$.focus();
focusReturn.focus();
}
}
},
allowBlur : function( allow ) // Prevent editor from hiding the panel. #3222.
{
var panel = this._.panel;
if ( allow != undefined )
panel.allowBlur = allow;
return panel.allowBlur;
},
showAsChild : function( panel, blockName, offsetParent, corner, offsetX, offsetY )
{
// Skip reshowing of child which is already visible.
if ( this._.activeChild == panel && panel._.panel._.offsetParentId == offsetParent.getId() )
return;
this.hideChild();
panel.onHide = CKEDITOR.tools.bind( function()
{
// Use a timeout, so we give time for this menu to get
// potentially focused.
CKEDITOR.tools.setTimeout( function()
{
if ( !this._.focused )
this.hide();
},
0, this );
},
this );
this._.activeChild = panel;
this._.focused = false;
panel.showBlock( blockName, offsetParent, corner, offsetX, offsetY );
/* #3767 IE: Second level menu may not have borders */
if ( CKEDITOR.env.ie7Compat || ( CKEDITOR.env.ie8 && CKEDITOR.env.ie6Compat ) )
{
setTimeout(function()
{
panel.element.getChild( 0 ).$.style.cssText += '';
}, 100);
}
},
hideChild : function()
{
var activeChild = this._.activeChild;
if ( activeChild )
{
delete activeChild.onHide;
// Sub panels don't manage focus. (#7881)
delete activeChild._.returnFocus;
delete this._.activeChild;
activeChild.hide();
}
}
}
});
CKEDITOR.on( 'instanceDestroyed', function()
{
var isLastInstance = CKEDITOR.tools.isEmpty( CKEDITOR.instances );
for ( var i in panels )
{
var panel = panels[ i ];
// Safe to destroy it since there're no more instances.(#4241)
if ( isLastInstance )
panel.destroy();
// Panel might be used by other instances, just hide them.(#4552)
else
panel.element.hide();
}
// Remove the registration.
isLastInstance && ( panels = {} );
} );
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
function forceHtmlMode( evt ) { evt.data.mode = 'html'; }
CKEDITOR.plugins.add( 'pastefromword',
{
init : function( editor )
{
// Flag indicate this command is actually been asked instead of a generic
// pasting.
var forceFromWord = 0;
var resetFromWord = function( evt )
{
evt && evt.removeListener();
editor.removeListener( 'beforePaste', forceHtmlMode );
forceFromWord && setTimeout( function() { forceFromWord = 0; }, 0 );
};
// Features bring by this command beside the normal process:
// 1. No more bothering of user about the clean-up.
// 2. Perform the clean-up even if content is not from MS-Word.
// (e.g. from a MS-Word similar application.)
editor.addCommand( 'pastefromword',
{
canUndo : false,
exec : function()
{
// Ensure the received data format is HTML and apply content filtering. (#6718)
forceFromWord = 1;
editor.on( 'beforePaste', forceHtmlMode );
if ( editor.execCommand( 'paste', 'html' ) === false )
{
editor.on( 'dialogShow', function ( evt )
{
evt.removeListener();
evt.data.on( 'cancel', resetFromWord );
});
editor.on( 'dialogHide', function( evt )
{
evt.data.removeListener( 'cancel', resetFromWord );
} );
}
editor.on( 'afterPaste', resetFromWord );
}
});
// Register the toolbar button.
editor.ui.addButton( 'PasteFromWord',
{
label : editor.lang.pastefromword.toolbar,
command : 'pastefromword'
});
editor.on( 'pasteState', function( evt )
{
editor.getCommand( 'pastefromword' ).setState( evt.data );
});
editor.on( 'paste', function( evt )
{
var data = evt.data,
mswordHtml;
// MS-WORD format sniffing.
if ( ( mswordHtml = data[ 'html' ] )
&& ( forceFromWord || ( /(class=\"?Mso|style=\"[^\"]*\bmso\-|w:WordDocument)/ ).test( mswordHtml ) ) )
{
var isLazyLoad = this.loadFilterRules( function()
{
// Event continuation with the original data.
if ( isLazyLoad )
editor.fire( 'paste', data );
else if ( !editor.config.pasteFromWordPromptCleanup
|| ( forceFromWord || confirm( editor.lang.pastefromword.confirmCleanup ) ) )
{
data[ 'html' ] = CKEDITOR.cleanWord( mswordHtml, editor );
}
});
// The cleanup rules are to be loaded, we should just cancel
// this event.
isLazyLoad && evt.cancel();
}
}, this );
},
loadFilterRules : function( callback )
{
var isLoaded = CKEDITOR.cleanWord;
if ( isLoaded )
callback();
else
{
var filterFilePath = CKEDITOR.getUrl(
CKEDITOR.config.pasteFromWordCleanupFile
|| ( this.path + 'filter/default.js' ) );
// Load with busy indicator.
CKEDITOR.scriptLoader.load( filterFilePath, callback, null, true );
}
return !isLoaded;
},
requires : [ 'clipboard' ]
});
})();
/**
* Whether to prompt the user about the clean up of content being pasted from
* MS Word.
* @name CKEDITOR.config.pasteFromWordPromptCleanup
* @since 3.1
* @type Boolean
* @default undefined
* @example
* config.pasteFromWordPromptCleanup = true;
*/
/**
* The file that provides the MS Word cleanup function for pasting operations.
* Note: This is a global configuration shared by all editor instances present
* in the page.
* @name CKEDITOR.config.pasteFromWordCleanupFile
* @since 3.1
* @type String
* @default 'default'
* @example
* // Load from 'pastefromword' plugin 'filter' sub folder (custom.js file).
* CKEDITOR.config.pasteFromWordCleanupFile = 'custom';
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var fragmentPrototype = CKEDITOR.htmlParser.fragment.prototype,
elementPrototype = CKEDITOR.htmlParser.element.prototype;
fragmentPrototype.onlyChild = elementPrototype.onlyChild = function()
{
var children = this.children,
count = children.length,
firstChild = ( count == 1 ) && children[ 0 ];
return firstChild || null;
};
elementPrototype.removeAnyChildWithName = function( tagName )
{
var children = this.children,
childs = [],
child;
for ( var i = 0; i < children.length; i++ )
{
child = children[ i ];
if ( !child.name )
continue;
if ( child.name == tagName )
{
childs.push( child );
children.splice( i--, 1 );
}
childs = childs.concat( child.removeAnyChildWithName( tagName ) );
}
return childs;
};
elementPrototype.getAncestor = function( tagNameRegex )
{
var parent = this.parent;
while ( parent && !( parent.name && parent.name.match( tagNameRegex ) ) )
parent = parent.parent;
return parent;
};
fragmentPrototype.firstChild = elementPrototype.firstChild = function( evaluator )
{
var child;
for ( var i = 0 ; i < this.children.length ; i++ )
{
child = this.children[ i ];
if ( evaluator( child ) )
return child;
else if ( child.name )
{
child = child.firstChild( evaluator );
if ( child )
return child;
}
}
return null;
};
// Adding a (set) of styles to the element's 'style' attributes.
elementPrototype.addStyle = function( name, value, isPrepend )
{
var styleText, addingStyleText = '';
// name/value pair.
if ( typeof value == 'string' )
addingStyleText += name + ':' + value + ';';
else
{
// style literal.
if ( typeof name == 'object' )
{
for ( var style in name )
{
if ( name.hasOwnProperty( style ) )
addingStyleText += style + ':' + name[ style ] + ';';
}
}
// raw style text form.
else
addingStyleText += name;
isPrepend = value;
}
if ( !this.attributes )
this.attributes = {};
styleText = this.attributes.style || '';
styleText = ( isPrepend ?
[ addingStyleText, styleText ]
: [ styleText, addingStyleText ] ).join( ';' );
this.attributes.style = styleText.replace( /^;|;(?=;)/, '' );
};
/**
* Return the DTD-valid parent tag names of the specified one.
* @param tagName
*/
CKEDITOR.dtd.parentOf = function( tagName )
{
var result = {};
for ( var tag in this )
{
if ( tag.indexOf( '$' ) == -1 && this[ tag ][ tagName ] )
result[ tag ] = 1;
}
return result;
};
// 1. move consistent list item styles up to list root.
// 2. clear out unnecessary list item numbering.
function postProcessList( list )
{
var children = list.children,
child,
attrs,
count = list.children.length,
match,
mergeStyle,
styleTypeRegexp = /list-style-type:(.*?)(?:;|$)/,
stylesFilter = CKEDITOR.plugins.pastefromword.filters.stylesFilter;
attrs = list.attributes;
if ( styleTypeRegexp.exec( attrs.style ) )
return;
for ( var i = 0; i < count; i++ )
{
child = children[ i ];
if ( child.attributes.value && Number( child.attributes.value ) == i + 1 )
delete child.attributes.value;
match = styleTypeRegexp.exec( child.attributes.style );
if ( match )
{
if ( match[ 1 ] == mergeStyle || !mergeStyle )
mergeStyle = match[ 1 ];
else
{
mergeStyle = null;
break;
}
}
}
if ( mergeStyle )
{
for ( i = 0; i < count; i++ )
{
attrs = children[ i ].attributes;
attrs.style && ( attrs.style = stylesFilter( [ [ 'list-style-type'] ] )( attrs.style ) || '' );
}
list.addStyle( 'list-style-type', mergeStyle );
}
}
var cssLengthRelativeUnit = /^([.\d]*)+(em|ex|px|gd|rem|vw|vh|vm|ch|mm|cm|in|pt|pc|deg|rad|ms|s|hz|khz){1}?/i;
var emptyMarginRegex = /^(?:\b0[^\s]*\s*){1,4}$/; // e.g. 0px 0pt 0px
var romanLiternalPattern = '^m{0,4}(cm|cd|d?c{0,3})(xc|xl|l?x{0,3})(ix|iv|v?i{0,3})$',
lowerRomanLiteralRegex = new RegExp( romanLiternalPattern ),
upperRomanLiteralRegex = new RegExp( romanLiternalPattern.toUpperCase() );
var orderedPatterns = { 'decimal' : /\d+/, 'lower-roman': lowerRomanLiteralRegex, 'upper-roman': upperRomanLiteralRegex, 'lower-alpha' : /^[a-z]+$/, 'upper-alpha': /^[A-Z]+$/ },
unorderedPatterns = { 'disc' : /[l\u00B7\u2002]/, 'circle' : /[\u006F\u00D8]/,'square' : /[\u006E\u25C6]/},
listMarkerPatterns = { 'ol' : orderedPatterns, 'ul' : unorderedPatterns },
romans = [ [1000, 'M'], [900, 'CM'], [500, 'D'], [400, 'CD'], [100, 'C'], [90, 'XC'], [50, 'L'], [40, 'XL'], [10, 'X'], [9, 'IX'], [5, 'V'], [4, 'IV'], [1, 'I'] ],
alpahbets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// Convert roman numbering back to decimal.
function fromRoman( str )
{
str = str.toUpperCase();
var l = romans.length, retVal = 0;
for ( var i = 0; i < l; ++i )
{
for ( var j = romans[i], k = j[1].length; str.substr( 0, k ) == j[1]; str = str.substr( k ) )
retVal += j[ 0 ];
}
return retVal;
}
// Convert alphabet numbering back to decimal.
function fromAlphabet( str )
{
str = str.toUpperCase();
var l = alpahbets.length, retVal = 1;
for ( var x = 1; str.length > 0; x *= l )
{
retVal += alpahbets.indexOf( str.charAt( str.length - 1 ) ) * x;
str = str.substr( 0, str.length - 1 );
}
return retVal;
}
var listBaseIndent = 0,
previousListItemMargin = null,
previousListId;
var plugin = ( CKEDITOR.plugins.pastefromword =
{
utils :
{
// Create a <cke:listbullet> which indicate an list item type.
createListBulletMarker : function ( bullet, bulletText )
{
var marker = new CKEDITOR.htmlParser.element( 'cke:listbullet' );
marker.attributes = { 'cke:listsymbol' : bullet[ 0 ] };
marker.add( new CKEDITOR.htmlParser.text( bulletText ) );
return marker;
},
isListBulletIndicator : function( element )
{
var styleText = element.attributes && element.attributes.style;
if ( /mso-list\s*:\s*Ignore/i.test( styleText ) )
return true;
},
isContainingOnlySpaces : function( element )
{
var text;
return ( ( text = element.onlyChild() )
&& ( /^(:?\s| )+$/ ).test( text.value ) );
},
resolveList : function( element )
{
// <cke:listbullet> indicate a list item.
var attrs = element.attributes,
listMarker;
if ( ( listMarker = element.removeAnyChildWithName( 'cke:listbullet' ) )
&& listMarker.length
&& ( listMarker = listMarker[ 0 ] ) )
{
element.name = 'cke:li';
if ( attrs.style )
{
attrs.style = plugin.filters.stylesFilter(
[
// Text-indent is not representing list item level any more.
[ 'text-indent' ],
[ 'line-height' ],
// First attempt is to resolve indent level from on a constant margin increment.
[ ( /^margin(:?-left)?$/ ), null, function( margin )
{
// Deal with component/short-hand form.
var values = margin.split( ' ' );
margin = CKEDITOR.tools.convertToPx( values[ 3 ] || values[ 1 ] || values [ 0 ] );
// Figure out the indent unit by checking the first time of incrementation.
if ( !listBaseIndent && previousListItemMargin !== null && margin > previousListItemMargin )
listBaseIndent = margin - previousListItemMargin;
previousListItemMargin = margin;
attrs[ 'cke:indent' ] = listBaseIndent && ( Math.ceil( margin / listBaseIndent ) + 1 ) || 1;
} ],
// The best situation: "mso-list:l0 level1 lfo2" tells the belonged list root, list item indentation, etc.
[ ( /^mso-list$/ ), null, function( val )
{
val = val.split( ' ' );
var listId = Number( val[ 0 ].match( /\d+/ ) ),
indent = Number( val[ 1 ].match( /\d+/ ) );
if ( indent == 1 )
{
listId !== previousListId && ( attrs[ 'cke:reset' ] = 1 );
previousListId = listId;
}
attrs[ 'cke:indent' ] = indent;
} ]
] )( attrs.style, element ) || '';
}
// First level list item might be presented without a margin.
// In case all above doesn't apply.
if ( !attrs[ 'cke:indent' ] )
{
previousListItemMargin = 0;
attrs[ 'cke:indent' ] = 1;
}
// Inherit attributes from bullet.
CKEDITOR.tools.extend( attrs, listMarker.attributes );
return true;
}
// Current list disconnected.
else
previousListId = previousListItemMargin = listBaseIndent = null;
return false;
},
// Providing a shorthand style then retrieve one or more style component values.
getStyleComponents : ( function()
{
var calculator = CKEDITOR.dom.element.createFromHtml(
'<div style="position:absolute;left:-9999px;top:-9999px;"></div>',
CKEDITOR.document );
CKEDITOR.document.getBody().append( calculator );
return function( name, styleValue, fetchList )
{
calculator.setStyle( name, styleValue );
var styles = {},
count = fetchList.length;
for ( var i = 0; i < count; i++ )
styles[ fetchList[ i ] ] = calculator.getStyle( fetchList[ i ] );
return styles;
};
} )(),
listDtdParents : CKEDITOR.dtd.parentOf( 'ol' )
},
filters :
{
// Transform a normal list into flat list items only presentation.
// E.g. <ul><li>level1<ol><li>level2</li></ol></li> =>
// <cke:li cke:listtype="ul" cke:indent="1">level1</cke:li>
// <cke:li cke:listtype="ol" cke:indent="2">level2</cke:li>
flattenList : function( element, level )
{
level = typeof level == 'number' ? level : 1;
var attrs = element.attributes,
listStyleType;
// All list items are of the same type.
switch ( attrs.type )
{
case 'a' :
listStyleType = 'lower-alpha';
break;
case '1' :
listStyleType = 'decimal';
break;
// TODO: Support more list style type from MS-Word.
}
var children = element.children,
child;
for ( var i = 0; i < children.length; i++ )
{
child = children[ i ];
if ( child.name in CKEDITOR.dtd.$listItem )
{
var attributes = child.attributes,
listItemChildren = child.children,
count = listItemChildren.length,
last = listItemChildren[ count - 1 ];
// Move out nested list.
if ( last.name in CKEDITOR.dtd.$list )
{
element.add( last, i + 1 );
// Remove the parent list item if it's just a holder.
if ( !--listItemChildren.length )
children.splice( i--, 1 );
}
child.name = 'cke:li';
// Inherit numbering from list root on the first list item.
attrs.start && !i && ( attributes.value = attrs.start );
plugin.filters.stylesFilter(
[
[ 'tab-stops', null, function( val )
{
var margin = val.split( ' ' )[ 1 ].match( cssLengthRelativeUnit );
margin && ( previousListItemMargin = CKEDITOR.tools.convertToPx( margin[ 0 ] ) );
} ],
( level == 1 ? [ 'mso-list', null, function( val )
{
val = val.split( ' ' );
var listId = Number( val[ 0 ].match( /\d+/ ) );
listId !== previousListId && ( attributes[ 'cke:reset' ] = 1 );
previousListId = listId;
} ] : null )
] )( attributes.style );
attributes[ 'cke:indent' ] = level;
attributes[ 'cke:listtype' ] = element.name;
attributes[ 'cke:list-style-type' ] = listStyleType;
}
// Flatten sub list.
else if ( child.name in CKEDITOR.dtd.$list )
{
// Absorb sub list children.
arguments.callee.apply( this, [ child, level + 1 ] );
children = children.slice( 0, i ).concat( child.children ).concat( children.slice( i + 1 ) );
element.children = [];
for ( var j = 0, num = children.length; j < num ; j++ )
element.add( children[ j ] );
}
}
delete element.name;
// We're loosing tag name here, signalize this element as a list.
attrs[ 'cke:list' ] = 1;
},
/**
* Try to collect all list items among the children and establish one
* or more HTML list structures for them.
* @param element
*/
assembleList : function( element )
{
var children = element.children, child,
listItem, // The current processing cke:li element.
listItemAttrs,
listItemIndent, // Indent level of current list item.
lastIndent,
lastListItem, // The previous one just been added to the list.
list, // Current staging list and it's parent list if any.
openedLists = [],
previousListStyleType,
previousListType;
// Properties of the list item are to be resolved from the list bullet.
var bullet,
listType,
listStyleType,
itemNumeric;
for ( var i = 0; i < children.length; i++ )
{
child = children[ i ];
if ( 'cke:li' == child.name )
{
child.name = 'li';
listItem = child;
listItemAttrs = listItem.attributes;
bullet = listItemAttrs[ 'cke:listsymbol' ];
bullet = bullet && bullet.match( /^(?:[(]?)([^\s]+?)([.)]?)$/ );
listType = listStyleType = itemNumeric = null;
if ( listItemAttrs[ 'cke:ignored' ] )
{
children.splice( i--, 1 );
continue;
}
// This's from a new list root.
listItemAttrs[ 'cke:reset' ] && ( list = lastIndent = lastListItem = null );
// List item indent level might come from a real list indentation or
// been resolved from a pseudo list item's margin value, even get
// no indentation at all.
listItemIndent = Number( listItemAttrs[ 'cke:indent' ] );
// We're moving out of the current list, cleaning up.
if ( listItemIndent != lastIndent )
previousListType = previousListStyleType = null;
// List type and item style are already resolved.
if ( !bullet )
{
listType = listItemAttrs[ 'cke:listtype' ] || 'ol';
listStyleType = listItemAttrs[ 'cke:list-style-type' ];
}
else
{
// Probably share the same list style type with previous list item,
// give it priority to avoid ambiguous between C(Alpha) and C.(Roman).
if ( previousListType && listMarkerPatterns[ previousListType ] [ previousListStyleType ].test( bullet[ 1 ] ) )
{
listType = previousListType;
listStyleType = previousListStyleType;
}
else
{
for ( var type in listMarkerPatterns )
{
for ( var style in listMarkerPatterns[ type ] )
{
if ( listMarkerPatterns[ type ][ style ].test( bullet[ 1 ] ) )
{
// Small numbering has higher priority, when dealing with ambiguous
// between C(Alpha) and C.(Roman).
if ( type == 'ol' && ( /alpha|roman/ ).test( style ) )
{
var num = /roman/.test( style ) ? fromRoman( bullet[ 1 ] ) : fromAlphabet( bullet[ 1 ] );
if ( !itemNumeric || num < itemNumeric )
{
itemNumeric = num;
listType = type;
listStyleType = style;
}
}
else
{
listType = type;
listStyleType = style;
break;
}
}
}
}
}
// Simply use decimal/disc for the rest forms of unrepresentable
// numerals, e.g. Chinese..., but as long as there a second part
// included, it has a bigger chance of being a order list ;)
!listType && ( listType = bullet[ 2 ] ? 'ol' : 'ul' );
}
previousListType = listType;
previousListStyleType = listStyleType || ( listType == 'ol' ? 'decimal' : 'disc' );
if ( listStyleType && listStyleType != ( listType == 'ol' ? 'decimal' : 'disc' ) )
listItem.addStyle( 'list-style-type', listStyleType );
// Figure out start numbering.
if ( listType == 'ol' && bullet )
{
switch ( listStyleType )
{
case 'decimal' :
itemNumeric = Number( bullet[ 1 ] );
break;
case 'lower-roman':
case 'upper-roman':
itemNumeric = fromRoman( bullet[ 1 ] );
break;
case 'lower-alpha':
case 'upper-alpha':
itemNumeric = fromAlphabet( bullet[ 1 ] );
break;
}
// Always create the numbering, swipe out unnecessary ones later.
listItem.attributes.value = itemNumeric;
}
// Start the list construction.
if ( !list )
{
openedLists.push( list = new CKEDITOR.htmlParser.element( listType ) );
list.add( listItem );
children[ i ] = list;
}
else
{
if ( listItemIndent > lastIndent )
{
openedLists.push( list = new CKEDITOR.htmlParser.element( listType ) );
list.add( listItem );
lastListItem.add( list );
}
else if ( listItemIndent < lastIndent )
{
// There might be a negative gap between two list levels. (#4944)
var diff = lastIndent - listItemIndent,
parent;
while ( diff-- && ( parent = list.parent ) )
list = parent.parent;
list.add( listItem );
}
else
list.add( listItem );
children.splice( i--, 1 );
}
lastListItem = listItem;
lastIndent = listItemIndent;
}
else if ( list )
list = lastIndent = lastListItem = null;
}
for ( i = 0; i < openedLists.length; i++ )
postProcessList( openedLists[ i ] );
list = lastIndent = lastListItem = previousListId = previousListItemMargin = listBaseIndent = null;
},
/**
* A simple filter which always rejecting.
*/
falsyFilter : function( value )
{
return false;
},
/**
* A filter dedicated on the 'style' attribute filtering, e.g. dropping/replacing style properties.
* @param styles {Array} in form of [ styleNameRegexp, styleValueRegexp,
* newStyleValue/newStyleGenerator, newStyleName ] where only the first
* parameter is mandatory.
* @param whitelist {Boolean} Whether the {@param styles} will be considered as a white-list.
*/
stylesFilter : function( styles, whitelist )
{
return function( styleText, element )
{
var rules = [];
// html-encoded quote might be introduced by 'font-family'
// from MS-Word which confused the following regexp. e.g.
//'font-family: "Lucida, Console"'
( styleText || '' )
.replace( /"/g, '"' )
.replace( /\s*([^ :;]+)\s*:\s*([^;]+)\s*(?=;|$)/g,
function( match, name, value )
{
name = name.toLowerCase();
name == 'font-family' && ( value = value.replace( /["']/g, '' ) );
var namePattern,
valuePattern,
newValue,
newName;
for ( var i = 0 ; i < styles.length; i++ )
{
if ( styles[ i ] )
{
namePattern = styles[ i ][ 0 ];
valuePattern = styles[ i ][ 1 ];
newValue = styles[ i ][ 2 ];
newName = styles[ i ][ 3 ];
if ( name.match( namePattern )
&& ( !valuePattern || value.match( valuePattern ) ) )
{
name = newName || name;
whitelist && ( newValue = newValue || value );
if ( typeof newValue == 'function' )
newValue = newValue( value, element, name );
// Return an couple indicate both name and value
// changed.
if ( newValue && newValue.push )
name = newValue[ 0 ], newValue = newValue[ 1 ];
if ( typeof newValue == 'string' )
rules.push( [ name, newValue ] );
return;
}
}
}
!whitelist && rules.push( [ name, value ] );
});
for ( var i = 0 ; i < rules.length ; i++ )
rules[ i ] = rules[ i ].join( ':' );
return rules.length ?
( rules.join( ';' ) + ';' ) : false;
};
},
/**
* Migrate the element by decorate styles on it.
* @param styleDefiniton
* @param variables
*/
elementMigrateFilter : function ( styleDefiniton, variables )
{
return function( element )
{
var styleDef =
variables ?
new CKEDITOR.style( styleDefiniton, variables )._.definition
: styleDefiniton;
element.name = styleDef.element;
CKEDITOR.tools.extend( element.attributes, CKEDITOR.tools.clone( styleDef.attributes ) );
element.addStyle( CKEDITOR.style.getStyleText( styleDef ) );
};
},
/**
* Migrate styles by creating a new nested stylish element.
* @param styleDefinition
*/
styleMigrateFilter : function( styleDefinition, variableName )
{
var elementMigrateFilter = this.elementMigrateFilter;
return function( value, element )
{
// Build an stylish element first.
var styleElement = new CKEDITOR.htmlParser.element( null ),
variables = {};
variables[ variableName ] = value;
elementMigrateFilter( styleDefinition, variables )( styleElement );
// Place the new element inside the existing span.
styleElement.children = element.children;
element.children = [ styleElement ];
};
},
/**
* A filter which remove cke-namespaced-attribute on
* all none-cke-namespaced elements.
* @param value
* @param element
*/
bogusAttrFilter : function( value, element )
{
if ( element.name.indexOf( 'cke:' ) == -1 )
return false;
},
/**
* A filter which will be used to apply inline css style according the stylesheet
* definition rules, is generated lazily when filtering.
*/
applyStyleFilter : null
},
getRules : function( editor )
{
var dtd = CKEDITOR.dtd,
blockLike = CKEDITOR.tools.extend( {}, dtd.$block, dtd.$listItem, dtd.$tableContent ),
config = editor.config,
filters = this.filters,
falsyFilter = filters.falsyFilter,
stylesFilter = filters.stylesFilter,
elementMigrateFilter = filters.elementMigrateFilter,
styleMigrateFilter = CKEDITOR.tools.bind( this.filters.styleMigrateFilter, this.filters ),
createListBulletMarker = this.utils.createListBulletMarker,
flattenList = filters.flattenList,
assembleList = filters.assembleList,
isListBulletIndicator = this.utils.isListBulletIndicator,
containsNothingButSpaces = this.utils.isContainingOnlySpaces,
resolveListItem = this.utils.resolveList,
convertToPx = function( value )
{
value = CKEDITOR.tools.convertToPx( value );
return isNaN( value ) ? value : value + 'px';
},
getStyleComponents = this.utils.getStyleComponents,
listDtdParents = this.utils.listDtdParents,
removeFontStyles = config.pasteFromWordRemoveFontStyles !== false,
removeStyles = config.pasteFromWordRemoveStyles !== false;
return {
elementNames :
[
// Remove script, meta and link elements.
[ ( /meta|link|script/ ), '' ]
],
root : function( element )
{
element.filterChildren();
assembleList( element );
},
elements :
{
'^' : function( element )
{
// Transform CSS style declaration to inline style.
var applyStyleFilter;
if ( CKEDITOR.env.gecko && ( applyStyleFilter = filters.applyStyleFilter ) )
applyStyleFilter( element );
},
$ : function( element )
{
var tagName = element.name || '',
attrs = element.attributes;
// Convert length unit of width/height on blocks to
// a more editor-friendly way (px).
if ( tagName in blockLike
&& attrs.style )
{
attrs.style = stylesFilter(
[ [ ( /^(:?width|height)$/ ), null, convertToPx ] ] )( attrs.style ) || '';
}
// Processing headings.
if ( tagName.match( /h\d/ ) )
{
element.filterChildren();
// Is the heading actually a list item?
if ( resolveListItem( element ) )
return;
// Adapt heading styles to editor's convention.
elementMigrateFilter( config[ 'format_' + tagName ] )( element );
}
// Remove inline elements which contain only empty spaces.
else if ( tagName in dtd.$inline )
{
element.filterChildren();
if ( containsNothingButSpaces( element ) )
delete element.name;
}
// Remove element with ms-office namespace,
// with it's content preserved, e.g. 'o:p'.
else if ( tagName.indexOf( ':' ) != -1
&& tagName.indexOf( 'cke' ) == -1 )
{
element.filterChildren();
// Restore image real link from vml.
if ( tagName == 'v:imagedata' )
{
var href = element.attributes[ 'o:href' ];
if ( href )
element.attributes.src = href;
element.name = 'img';
return;
}
delete element.name;
}
// Assembling list items into a whole list.
if ( tagName in listDtdParents )
{
element.filterChildren();
assembleList( element );
}
},
// We'll drop any style sheet, but Firefox conclude
// certain styles in a single style element, which are
// required to be changed into inline ones.
'style' : function( element )
{
if ( CKEDITOR.env.gecko )
{
// Grab only the style definition section.
var styleDefSection = element.onlyChild().value.match( /\/\* Style Definitions \*\/([\s\S]*?)\/\*/ ),
styleDefText = styleDefSection && styleDefSection[ 1 ],
rules = {}; // Storing the parsed result.
if ( styleDefText )
{
styleDefText
// Remove line-breaks.
.replace(/[\n\r]/g,'')
// Extract selectors and style properties.
.replace( /(.+?)\{(.+?)\}/g,
function( rule, selectors, styleBlock )
{
selectors = selectors.split( ',' );
var length = selectors.length, selector;
for ( var i = 0; i < length; i++ )
{
// Assume MS-Word mostly generate only simple
// selector( [Type selector][Class selector]).
CKEDITOR.tools.trim( selectors[ i ] )
.replace( /^(\w+)(\.[\w-]+)?$/g,
function( match, tagName, className )
{
tagName = tagName || '*';
className = className.substring( 1, className.length );
// Reject MS-Word Normal styles.
if ( className.match( /MsoNormal/ ) )
return;
if ( !rules[ tagName ] )
rules[ tagName ] = {};
if ( className )
rules[ tagName ][ className ] = styleBlock;
else
rules[ tagName ] = styleBlock;
} );
}
});
filters.applyStyleFilter = function( element )
{
var name = rules[ '*' ] ? '*' : element.name,
className = element.attributes && element.attributes[ 'class' ],
style;
if ( name in rules )
{
style = rules[ name ];
if ( typeof style == 'object' )
style = style[ className ];
// Maintain style rules priorities.
style && element.addStyle( style, true );
}
};
}
}
return false;
},
'p' : function( element )
{
// This's a fall-back approach to recognize list item in FF3.6,
// as it's not perfect as not all list style (e.g. "heading list") is shipped
// with this pattern. (#6662)
if ( /MsoListParagraph/.exec( element.attributes[ 'class' ] ) )
{
var bulletText = element.firstChild( function( node )
{
return node.type == CKEDITOR.NODE_TEXT && !containsNothingButSpaces( node.parent );
});
var bullet = bulletText && bulletText.parent,
bulletAttrs = bullet && bullet.attributes;
bulletAttrs && !bulletAttrs.style && ( bulletAttrs.style = 'mso-list: Ignore;' );
}
element.filterChildren();
// Is the paragraph actually a list item?
if ( resolveListItem( element ) )
return;
// Adapt paragraph formatting to editor's convention
// according to enter-mode.
if ( config.enterMode == CKEDITOR.ENTER_BR )
{
// We suffer from attribute/style lost in this situation.
delete element.name;
element.add( new CKEDITOR.htmlParser.element( 'br' ) );
}
else
elementMigrateFilter( config[ 'format_' + ( config.enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ] )( element );
},
'div' : function( element )
{
// Aligned table with no text surrounded is represented by a wrapper div, from which
// table cells inherit as text-align styles, which is wrong.
// Instead we use a clear-float div after the table to properly achieve the same layout.
var singleChild = element.onlyChild();
if ( singleChild && singleChild.name == 'table' )
{
var attrs = element.attributes;
singleChild.attributes = CKEDITOR.tools.extend( singleChild.attributes, attrs );
attrs.style && singleChild.addStyle( attrs.style );
var clearFloatDiv = new CKEDITOR.htmlParser.element( 'div' );
clearFloatDiv.addStyle( 'clear' ,'both' );
element.add( clearFloatDiv );
delete element.name;
}
},
'td' : function ( element )
{
// 'td' in 'thead' is actually <th>.
if ( element.getAncestor( 'thead') )
element.name = 'th';
},
// MS-Word sometimes present list as a mixing of normal list
// and pseudo-list, normalize the previous ones into pseudo form.
'ol' : flattenList,
'ul' : flattenList,
'dl' : flattenList,
'font' : function( element )
{
// Drop the font tag if it comes from list bullet text.
if ( isListBulletIndicator( element.parent ) )
{
delete element.name;
return;
}
element.filterChildren();
var attrs = element.attributes,
styleText = attrs.style,
parent = element.parent;
if ( 'font' == parent.name ) // Merge nested <font> tags.
{
CKEDITOR.tools.extend( parent.attributes,
element.attributes );
styleText && parent.addStyle( styleText );
delete element.name;
}
// Convert the merged into a span with all attributes preserved.
else
{
styleText = styleText || '';
// IE's having those deprecated attributes, normalize them.
if ( attrs.color )
{
attrs.color != '#000000' && ( styleText += 'color:' + attrs.color + ';' );
delete attrs.color;
}
if ( attrs.face )
{
styleText += 'font-family:' + attrs.face + ';';
delete attrs.face;
}
// TODO: Mapping size in ranges of xx-small,
// x-small, small, medium, large, x-large, xx-large.
if ( attrs.size )
{
styleText += 'font-size:' +
( attrs.size > 3 ? 'large'
: ( attrs.size < 3 ? 'small' : 'medium' ) ) + ';';
delete attrs.size;
}
element.name = 'span';
element.addStyle( styleText );
}
},
'span' : function( element )
{
// Remove the span if it comes from list bullet text.
if ( isListBulletIndicator( element.parent ) )
return false;
element.filterChildren();
if ( containsNothingButSpaces( element ) )
{
delete element.name;
return null;
}
// List item bullet type is supposed to be indicated by
// the text of a span with style 'mso-list : Ignore' or an image.
if ( isListBulletIndicator( element ) )
{
var listSymbolNode = element.firstChild( function( node )
{
return node.value || node.name == 'img';
});
var listSymbol = listSymbolNode && ( listSymbolNode.value || 'l.' ),
listType = listSymbol && listSymbol.match( /^(?:[(]?)([^\s]+?)([.)]?)$/ );
if ( listType )
{
var marker = createListBulletMarker( listType, listSymbol );
// Some non-existed list items might be carried by an inconsequential list, indicate by "mso-hide:all/display:none",
// those are to be removed later, now mark it with "cke:ignored".
var ancestor = element.getAncestor( 'span' );
if ( ancestor && (/ mso-hide:\s*all|display:\s*none /).test( ancestor.attributes.style ) )
marker.attributes[ 'cke:ignored' ] = 1;
return marker;
}
}
// Update the src attribute of image element with href.
var children = element.children,
attrs = element.attributes,
styleText = attrs && attrs.style,
firstChild = children && children[ 0 ];
// Assume MS-Word mostly carry font related styles on <span>,
// adapting them to editor's convention.
if ( styleText )
{
attrs.style = stylesFilter(
[
// Drop 'inline-height' style which make lines overlapping.
[ 'line-height' ],
[ ( /^font-family$/ ), null, !removeFontStyles ? styleMigrateFilter( config[ 'font_style' ], 'family' ) : null ] ,
[ ( /^font-size$/ ), null, !removeFontStyles ? styleMigrateFilter( config[ 'fontSize_style' ], 'size' ) : null ] ,
[ ( /^color$/ ), null, !removeFontStyles ? styleMigrateFilter( config[ 'colorButton_foreStyle' ], 'color' ) : null ] ,
[ ( /^background-color$/ ), null, !removeFontStyles ? styleMigrateFilter( config[ 'colorButton_backStyle' ], 'color' ) : null ]
] )( styleText, element ) || '';
}
return null;
},
// Migrate basic style formats to editor configured ones.
'b' : elementMigrateFilter( config[ 'coreStyles_bold' ] ),
'i' : elementMigrateFilter( config[ 'coreStyles_italic' ] ),
'u' : elementMigrateFilter( config[ 'coreStyles_underline' ] ),
's' : elementMigrateFilter( config[ 'coreStyles_strike' ] ),
'sup' : elementMigrateFilter( config[ 'coreStyles_superscript' ] ),
'sub' : elementMigrateFilter( config[ 'coreStyles_subscript' ] ),
// Editor doesn't support anchor with content currently (#3582),
// drop such anchors with content preserved.
'a' : function( element )
{
var attrs = element.attributes;
if ( attrs && !attrs.href && attrs.name )
delete element.name;
else if ( CKEDITOR.env.webkit && attrs.href && attrs.href.match( /file:\/\/\/[\S]+#/i ) )
attrs.href = attrs.href.replace( /file:\/\/\/[^#]+/i,'' );
},
'cke:listbullet' : function( element )
{
if ( element.getAncestor( /h\d/ ) && !config.pasteFromWordNumberedHeadingToList )
delete element.name;
}
},
attributeNames :
[
// Remove onmouseover and onmouseout events (from MS Word comments effect)
[ ( /^onmouse(:?out|over)/ ), '' ],
// Onload on image element.
[ ( /^onload$/ ), '' ],
// Remove office and vml attribute from elements.
[ ( /(?:v|o):\w+/ ), '' ],
// Remove lang/language attributes.
[ ( /^lang/ ), '' ]
],
attributes :
{
'style' : stylesFilter(
removeStyles ?
// Provide a white-list of styles that we preserve, those should
// be the ones that could later be altered with editor tools.
[
// Leave list-style-type
[ ( /^list-style-type$/ ), null ],
// Preserve margin-left/right which used as default indent style in the editor.
[ ( /^margin$|^margin-(?!bottom|top)/ ), null, function( value, element, name )
{
if ( element.name in { p : 1, div : 1 } )
{
var indentStyleName = config.contentsLangDirection == 'ltr' ?
'margin-left' : 'margin-right';
// Extract component value from 'margin' shorthand.
if ( name == 'margin' )
{
value = getStyleComponents( name, value,
[ indentStyleName ] )[ indentStyleName ];
}
else if ( name != indentStyleName )
return null;
if ( value && !emptyMarginRegex.test( value ) )
return [ indentStyleName, value ];
}
return null;
} ],
// Preserve clear float style.
[ ( /^clear$/ ) ],
[ ( /^border.*|margin.*|vertical-align|float$/ ), null,
function( value, element )
{
if ( element.name == 'img' )
return value;
} ],
[ (/^width|height$/ ), null,
function( value, element )
{
if ( element.name in { table : 1, td : 1, th : 1, img : 1 } )
return value;
} ]
] :
// Otherwise provide a black-list of styles that we remove.
[
[ ( /^mso-/ ) ],
// Fixing color values.
[ ( /-color$/ ), null, function( value )
{
if ( value == 'transparent' )
return false;
if ( CKEDITOR.env.gecko )
return value.replace( /-moz-use-text-color/g, 'transparent' );
} ],
// Remove empty margin values, e.g. 0.00001pt 0em 0pt
[ ( /^margin$/ ), emptyMarginRegex ],
[ 'text-indent', '0cm' ],
[ 'page-break-before' ],
[ 'tab-stops' ],
[ 'display', 'none' ],
removeFontStyles ? [ ( /font-?/ ) ] : null
], removeStyles ),
// Prefer width styles over 'width' attributes.
'width' : function( value, element )
{
if ( element.name in dtd.$tableContent )
return false;
},
// Prefer border styles over table 'border' attributes.
'border' : function( value, element )
{
if ( element.name in dtd.$tableContent )
return false;
},
// Only Firefox carry style sheet from MS-Word, which
// will be applied by us manually. For other browsers
// the css className is useless.
'class' : falsyFilter,
// MS-Word always generate 'background-color' along with 'bgcolor',
// simply drop the deprecated attributes.
'bgcolor' : falsyFilter,
// Deprecate 'valign' attribute in favor of 'vertical-align'.
'valign' : removeStyles ? falsyFilter : function( value, element )
{
element.addStyle( 'vertical-align', value );
return false;
}
},
// Fore none-IE, some useful data might be buried under these IE-conditional
// comments where RegExp were the right approach to dig them out where usual approach
// is transform it into a fake element node which hold the desired data.
comment :
!CKEDITOR.env.ie ?
function( value, node )
{
var imageInfo = value.match( /<img.*?>/ ),
listInfo = value.match( /^\[if !supportLists\]([\s\S]*?)\[endif\]$/ );
// Seek for list bullet indicator.
if ( listInfo )
{
// Bullet symbol could be either text or an image.
var listSymbol = listInfo[ 1 ] || ( imageInfo && 'l.' ),
listType = listSymbol && listSymbol.match( />(?:[(]?)([^\s]+?)([.)]?)</ );
return createListBulletMarker( listType, listSymbol );
}
// Reveal the <img> element in conditional comments for Firefox.
if ( CKEDITOR.env.gecko && imageInfo )
{
var img = CKEDITOR.htmlParser.fragment.fromHtml( imageInfo[ 0 ] ).children[ 0 ],
previousComment = node.previous,
// Try to dig the real image link from vml markup from previous comment text.
imgSrcInfo = previousComment && previousComment.value.match( /<v:imagedata[^>]*o:href=['"](.*?)['"]/ ),
imgSrc = imgSrcInfo && imgSrcInfo[ 1 ];
// Is there a real 'src' url to be used?
imgSrc && ( img.attributes.src = imgSrc );
return img;
}
return false;
}
: falsyFilter
};
}
});
// The paste processor here is just a reduced copy of html data processor.
var pasteProcessor = function()
{
this.dataFilter = new CKEDITOR.htmlParser.filter();
};
pasteProcessor.prototype =
{
toHtml : function( data )
{
var fragment = CKEDITOR.htmlParser.fragment.fromHtml( data, false ),
writer = new CKEDITOR.htmlParser.basicWriter();
fragment.writeHtml( writer, this.dataFilter );
return writer.getHtml( true );
}
};
CKEDITOR.cleanWord = function( data, editor )
{
// Firefox will be confused by those downlevel-revealed IE conditional
// comments, fixing them first( convert it to upperlevel-revealed one ).
// e.g. <![if !vml]>...<![endif]>
if ( CKEDITOR.env.gecko )
data = data.replace( /(<!--\[if[^<]*?\])-->([\S\s]*?)<!--(\[endif\]-->)/gi, '$1$2$3' );
var dataProcessor = new pasteProcessor(),
dataFilter = dataProcessor.dataFilter;
// These rules will have higher priorities than default ones.
dataFilter.addRules( CKEDITOR.plugins.pastefromword.getRules( editor ) );
// Allow extending data filter rules.
editor.fire( 'beforeCleanWord', { filter : dataFilter } );
try
{
data = dataProcessor.toHtml( data, false );
}
catch ( e )
{
alert( editor.lang.pastefromword.error );
}
/* Below post processing those things that are unable to delivered by filter rules. */
// Remove 'cke' namespaced attribute used in filter rules as marker.
data = data.replace( /cke:.*?".*?"/g, '' );
// Remove empty style attribute.
data = data.replace( /style=""/g, '' );
// Remove the dummy spans ( having no inline style ).
data = data.replace( /<span>/g, '' );
return data;
};
})();
/**
* Whether to ignore all font related formatting styles, including:
* <ul> <li>font size;</li>
* <li>font family;</li>
* <li>font foreground/background color.</li></ul>
* @name CKEDITOR.config.pasteFromWordRemoveFontStyles
* @since 3.1
* @type Boolean
* @default true
* @example
* config.pasteFromWordRemoveFontStyles = false;
*/
/**
* Whether to transform MS Word outline numbered headings into lists.
* @name CKEDITOR.config.pasteFromWordNumberedHeadingToList
* @since 3.1
* @type Boolean
* @default false
* @example
* config.pasteFromWordNumberedHeadingToList = true;
*/
/**
* Whether to remove element styles that can't be managed with the editor. Note
* that this doesn't handle the font specific styles, which depends on the
* {@link CKEDITOR.config.pasteFromWordRemoveFontStyles} setting instead.
* @name CKEDITOR.config.pasteFromWordRemoveStyles
* @since 3.1
* @type Boolean
* @default true
* @example
* config.pasteFromWordRemoveStyles = false;
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview The "wysiwygarea" plugin. It registers the "wysiwyg" editing
* mode, which handles the main editing area space.
*/
(function()
{
// Matching an empty paragraph at the end of document.
var emptyParagraphRegexp = /(^|<body\b[^>]*>)\s*<(p|div|address|h\d|center|pre)[^>]*>\s*(?:<br[^>]*>| |\u00A0| )?\s*(:?<\/\2>)?\s*(?=$|<\/body>)/gi;
var notWhitespaceEval = CKEDITOR.dom.walker.whitespaces( true ),
notBogus = CKEDITOR.dom.walker.bogus( true ),
notEmpty = function( node ) { return notWhitespaceEval( node ) && notBogus( node ); };
// Elements that could blink the cursor anchoring beside it, like hr, page-break. (#6554)
function nonEditable( element )
{
return element.isBlockBoundary() && CKEDITOR.dtd.$empty[ element.getName() ];
}
function onInsert( insertFunc )
{
return function( evt )
{
if ( this.mode == 'wysiwyg' )
{
this.focus();
// Since the insertion might happen from within dialog or menu
// where the editor selection might be locked at the moment,
// update the locked selection.
var selection = this.getSelection(),
selIsLocked = selection.isLocked;
selIsLocked && selection.unlock();
this.fire( 'saveSnapshot' );
insertFunc.call( this, evt.data );
selIsLocked && this.getSelection().lock();
// Save snaps after the whole execution completed.
// This's a workaround for make DOM modification's happened after
// 'insertElement' to be included either, e.g. Form-based dialogs' 'commitContents'
// call.
CKEDITOR.tools.setTimeout( function()
{
this.fire( 'saveSnapshot' );
}, 0, this );
}
};
}
function doInsertHtml( data )
{
if ( this.dataProcessor )
data = this.dataProcessor.toHtml( data );
if ( !data )
return;
// HTML insertion only considers the first range.
var selection = this.getSelection(),
range = selection.getRanges()[ 0 ];
if ( range.checkReadOnly() )
return;
// Opera: force block splitting when pasted content contains block. (#7801)
if ( CKEDITOR.env.opera )
{
var path = new CKEDITOR.dom.elementPath( range.startContainer );
if ( path.block )
{
var nodes = CKEDITOR.htmlParser.fragment.fromHtml( data, false ).children;
for ( var i = 0, count = nodes.length; i < count; i++ )
{
if ( nodes[ i ]._.isBlockLike )
{
range.splitBlock( this.enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
range.insertNode( range.document.createText( '' ) );
range.select();
break;
}
}
}
}
if ( CKEDITOR.env.ie )
{
var $sel = selection.getNative();
// Delete control selections to avoid IE bugs on pasteHTML.
if ( $sel.type == 'Control' )
$sel.clear();
else if ( selection.getType() == CKEDITOR.SELECTION_TEXT )
{
// Due to IE bugs on handling contenteditable=false blocks
// (#6005), we need to make some checks and eventually
// delete the selection first.
range = selection.getRanges()[ 0 ];
var endContainer = range && range.endContainer;
if ( endContainer &&
endContainer.type == CKEDITOR.NODE_ELEMENT &&
endContainer.getAttribute( 'contenteditable' ) == 'false' &&
range.checkBoundaryOfElement( endContainer, CKEDITOR.END ) )
{
range.setEndAfter( range.endContainer );
range.deleteContents();
}
}
$sel.createRange().pasteHTML( data );
}
else
this.document.$.execCommand( 'inserthtml', false, data );
// Webkit does not scroll to the cursor position after pasting (#5558)
if ( CKEDITOR.env.webkit )
{
selection = this.getSelection();
selection.scrollIntoView();
}
}
function doInsertText( text )
{
var selection = this.getSelection(),
mode = selection.getStartElement().hasAscendant( 'pre', true ) ?
CKEDITOR.ENTER_BR : this.config.enterMode,
isEnterBrMode = mode == CKEDITOR.ENTER_BR;
var html = CKEDITOR.tools.htmlEncode( text.replace( /\r\n|\r/g, '\n' ) );
// Convert leading and trailing whitespaces into
html = html.replace( /^[ \t]+|[ \t]+$/g, function( match, offset, s )
{
if ( match.length == 1 ) // one space, preserve it
return ' ';
else if ( !offset ) // beginning of block
return CKEDITOR.tools.repeat( ' ', match.length - 1 ) + ' ';
else // end of block
return ' ' + CKEDITOR.tools.repeat( ' ', match.length - 1 );
} );
// Convert subsequent whitespaces into
html = html.replace( /[ \t]{2,}/g, function ( match )
{
return CKEDITOR.tools.repeat( ' ', match.length - 1 ) + ' ';
} );
var paragraphTag = mode == CKEDITOR.ENTER_P ? 'p' : 'div';
// Two line-breaks create one paragraph.
if ( !isEnterBrMode )
{
html = html.replace( /(\n{2})([\s\S]*?)(?:$|\1)/g,
function( match, group1, text )
{
return '<'+paragraphTag + '>' + text + '</' + paragraphTag + '>';
});
}
// One <br> per line-break.
html = html.replace( /\n/g, '<br>' );
// Compensate padding <br> for non-IE.
if ( !( isEnterBrMode || CKEDITOR.env.ie ) )
{
html = html.replace( new RegExp( '<br>(?=</' + paragraphTag + '>)' ), function( match )
{
return CKEDITOR.tools.repeat( match, 2 );
} );
}
// Inline styles have to be inherited in Firefox.
if ( CKEDITOR.env.gecko || CKEDITOR.env.webkit )
{
var path = new CKEDITOR.dom.elementPath( selection.getStartElement() ),
context = [];
for ( var i = 0; i < path.elements.length; i++ )
{
var tag = path.elements[ i ].getName();
if ( tag in CKEDITOR.dtd.$inline )
context.unshift( path.elements[ i ].getOuterHtml().match( /^<.*?>/) );
else if ( tag in CKEDITOR.dtd.$block )
break;
}
// Reproduce the context by preceding the pasted HTML with opening inline tags.
html = context.join( '' ) + html;
}
doInsertHtml.call( this, html );
}
function doInsertElement( element )
{
var selection = this.getSelection(),
ranges = selection.getRanges(),
elementName = element.getName(),
isBlock = CKEDITOR.dtd.$block[ elementName ];
var selIsLocked = selection.isLocked;
if ( selIsLocked )
selection.unlock();
var range, clone, lastElement, bookmark;
for ( var i = ranges.length - 1 ; i >= 0 ; i-- )
{
range = ranges[ i ];
if ( !range.checkReadOnly() )
{
// Remove the original contents, merge splitted nodes.
range.deleteContents( 1 );
clone = !i && element || element.clone( 1 );
// If we're inserting a block at dtd-violated position, split
// the parent blocks until we reach blockLimit.
var current, dtd;
if ( isBlock )
{
while ( ( current = range.getCommonAncestor( 0, 1 ) )
&& ( dtd = CKEDITOR.dtd[ current.getName() ] )
&& !( dtd && dtd [ elementName ] ) )
{
// Split up inline elements.
if ( current.getName() in CKEDITOR.dtd.span )
range.splitElement( current );
// If we're in an empty block which indicate a new paragraph,
// simply replace it with the inserting block.(#3664)
else if ( range.checkStartOfBlock()
&& range.checkEndOfBlock() )
{
range.setStartBefore( current );
range.collapse( true );
current.remove();
}
else
range.splitBlock();
}
}
// Insert the new node.
range.insertNode( clone );
// Save the last element reference so we can make the
// selection later.
if ( !lastElement )
lastElement = clone;
}
}
if ( lastElement )
{
range.moveToPosition( lastElement, CKEDITOR.POSITION_AFTER_END );
// If we're inserting a block element immediately followed by
// another block element, the selection must be optimized. (#3100,#5436,#8950)
if ( isBlock )
{
var next = lastElement.getNext( notEmpty ),
nextName = next && next.type == CKEDITOR.NODE_ELEMENT && next.getName();
// If the next one is a text block, move cursor to the start of it's content.
if ( nextName && CKEDITOR.dtd.$block[ nextName ] )
{
if ( CKEDITOR.dtd[ nextName ][ '#' ] )
range.moveToElementEditStart( next );
// Otherwise move cursor to the before end of the last element.
else
range.moveToElementEditEnd( lastElement );
}
// Open a new line if the block is inserted at the end of parent.
else if ( !next )
{
next = range.fixBlock( true, this.config.enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
range.moveToElementEditStart( next );
}
}
}
selection.selectRanges( [ range ] );
if ( selIsLocked )
this.getSelection().lock();
}
// DOM modification here should not bother dirty flag.(#4385)
function restoreDirty( editor )
{
if ( !editor.checkDirty() )
setTimeout( function(){ editor.resetDirty(); }, 0 );
}
var isNotWhitespace = CKEDITOR.dom.walker.whitespaces( true ),
isNotBookmark = CKEDITOR.dom.walker.bookmark( false, true );
function isNotEmpty( node )
{
return isNotWhitespace( node ) && isNotBookmark( node );
}
function isNbsp( node )
{
return node.type == CKEDITOR.NODE_TEXT
&& CKEDITOR.tools.trim( node.getText() ).match( /^(?: |\xa0)$/ );
}
function restoreSelection( selection )
{
if ( selection.isLocked )
{
selection.unlock();
setTimeout( function() { selection.lock(); }, 0 );
}
}
function isBlankParagraph( block )
{
return block.getOuterHtml().match( emptyParagraphRegexp );
}
isNotWhitespace = CKEDITOR.dom.walker.whitespaces( true );
// Gecko need a key event to 'wake up' the editing
// ability when document is empty.(#3864, #5781)
function activateEditing( editor )
{
var win = editor.window,
doc = editor.document,
body = editor.document.getBody(),
bodyFirstChild = body.getFirst(),
bodyChildsNum = body.getChildren().count();
if ( !bodyChildsNum
|| bodyChildsNum == 1
&& bodyFirstChild.type == CKEDITOR.NODE_ELEMENT
&& bodyFirstChild.hasAttribute( '_moz_editor_bogus_node' ) )
{
restoreDirty( editor );
// Memorize scroll position to restore it later (#4472).
var hostDocument = editor.element.getDocument();
var hostDocumentElement = hostDocument.getDocumentElement();
var scrollTop = hostDocumentElement.$.scrollTop;
var scrollLeft = hostDocumentElement.$.scrollLeft;
// Simulating keyboard character input by dispatching a keydown of white-space text.
var keyEventSimulate = doc.$.createEvent( "KeyEvents" );
keyEventSimulate.initKeyEvent( 'keypress', true, true, win.$, false,
false, false, false, 0, 32 );
doc.$.dispatchEvent( keyEventSimulate );
if ( scrollTop != hostDocumentElement.$.scrollTop || scrollLeft != hostDocumentElement.$.scrollLeft )
hostDocument.getWindow().$.scrollTo( scrollLeft, scrollTop );
// Restore the original document status by placing the cursor before a bogus br created (#5021).
bodyChildsNum && body.getFirst().remove();
doc.getBody().appendBogus();
var nativeRange = new CKEDITOR.dom.range( doc );
nativeRange.setStartAt( body , CKEDITOR.POSITION_AFTER_START );
nativeRange.select();
}
}
/**
* Auto-fixing block-less content by wrapping paragraph (#3190), prevent
* non-exitable-block by padding extra br.(#3189)
*/
function onSelectionChangeFixBody( evt )
{
var editor = evt.editor,
path = evt.data.path,
blockLimit = path.blockLimit,
selection = evt.data.selection,
range = selection.getRanges()[0],
body = editor.document.getBody(),
enterMode = editor.config.enterMode;
if ( CKEDITOR.env.gecko )
{
activateEditing( editor );
// Ensure bogus br could help to move cursor (out of styles) to the end of block. (#7041)
var pathBlock = path.block || path.blockLimit,
lastNode = pathBlock && pathBlock.getLast( isNotEmpty );
// Check some specialities of the current path block:
// 1. It is really displayed as block; (#7221)
// 2. It doesn't end with one inner block; (#7467)
// 3. It doesn't have bogus br yet.
if ( pathBlock
&& pathBlock.isBlockBoundary()
&& !( lastNode && lastNode.type == CKEDITOR.NODE_ELEMENT && lastNode.isBlockBoundary() )
&& !pathBlock.is( 'pre' )
&& !pathBlock.getBogus() )
{
pathBlock.appendBogus();
}
}
// When we're in block enter mode, a new paragraph will be established
// to encapsulate inline contents right under body. (#3657)
if ( editor.config.autoParagraph !== false
&& enterMode != CKEDITOR.ENTER_BR
&& range.collapsed
&& blockLimit.getName() == 'body'
&& !path.block )
{
var fixedBlock = range.fixBlock( true,
editor.config.enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p' );
// For IE, we should remove any filler node which was introduced before.
if ( CKEDITOR.env.ie )
{
var first = fixedBlock.getFirst( isNotEmpty );
first && isNbsp( first ) && first.remove();
}
// If the fixed block is actually blank and is already followed by an exitable blank
// block, we should revert the fix and move into the existed one. (#3684)
if ( isBlankParagraph( fixedBlock ) )
{
var element = fixedBlock.getNext( isNotWhitespace );
if ( element &&
element.type == CKEDITOR.NODE_ELEMENT &&
!nonEditable( element ) )
{
range.moveToElementEditStart( element );
fixedBlock.remove();
}
else
{
element = fixedBlock.getPrevious( isNotWhitespace );
if ( element &&
element.type == CKEDITOR.NODE_ELEMENT &&
!nonEditable( element ) )
{
range.moveToElementEditEnd( element );
fixedBlock.remove();
}
}
}
range.select();
// Cancel this selection change in favor of the next (correct). (#6811)
evt.cancel();
}
// Browsers are incapable of moving cursor out of certain block elements (e.g. table, div, pre)
// at the end of document, makes it unable to continue adding content, we have to make this
// easier by opening an new empty paragraph.
var testRange = new CKEDITOR.dom.range( editor.document );
testRange.moveToElementEditEnd( editor.document.getBody() );
var testPath = new CKEDITOR.dom.elementPath( testRange.startContainer );
if ( !testPath.blockLimit.is( 'body') )
{
var paddingBlock;
if ( enterMode != CKEDITOR.ENTER_BR )
paddingBlock = body.append( editor.document.createElement( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) );
else
paddingBlock = body;
if ( !CKEDITOR.env.ie )
paddingBlock.appendBogus();
}
}
CKEDITOR.plugins.add( 'wysiwygarea',
{
requires : [ 'editingblock' ],
init : function( editor )
{
var fixForBody = ( editor.config.enterMode != CKEDITOR.ENTER_BR && editor.config.autoParagraph !== false )
? editor.config.enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p' : false;
var frameLabel = editor.lang.editorTitle.replace( '%1', editor.name ),
frameDesc = editor.lang.editorHelp;
if ( CKEDITOR.env.ie )
frameLabel += ', ' + frameDesc;
var win = CKEDITOR.document.getWindow();
var contentDomReadyHandler;
editor.on( 'editingBlockReady', function()
{
var mainElement,
iframe,
isLoadingData,
isPendingFocus,
frameLoaded,
fireMode,
onResize;
// Support for custom document.domain in IE.
var isCustomDomain = CKEDITOR.env.isCustomDomain();
// Creates the iframe that holds the editable document.
var createIFrame = function( data )
{
if ( iframe )
iframe.remove();
var src =
'document.open();' +
// The document domain must be set any time we
// call document.open().
( isCustomDomain ? ( 'document.domain="' + document.domain + '";' ) : '' ) +
'document.close();';
// With IE, the custom domain has to be taken care at first,
// for other browers, the 'src' attribute should be left empty to
// trigger iframe's 'load' event.
src =
CKEDITOR.env.air ?
'javascript:void(0)' :
CKEDITOR.env.ie ?
'javascript:void(function(){' + encodeURIComponent( src ) + '}())'
:
'';
var labelId = CKEDITOR.tools.getNextId();
iframe = CKEDITOR.dom.element.createFromHtml( '<iframe' +
' style="width:100%;height:100%"' +
' frameBorder="0"' +
' aria-describedby="' + labelId + '"' +
' title="' + frameLabel + '"' +
' src="' + src + '"' +
' tabIndex="' + ( CKEDITOR.env.webkit? -1 : editor.tabIndex ) + '"' +
' allowTransparency="true"' +
'></iframe>' );
// Running inside of Firefox chrome the load event doesn't bubble like in a normal page (#5689)
if ( document.location.protocol == 'chrome:' )
CKEDITOR.event.useCapture = true;
// With FF, it's better to load the data on iframe.load. (#3894,#4058)
iframe.on( 'load', function( ev )
{
frameLoaded = 1;
ev.removeListener();
var doc = iframe.getFrameDocument();
doc.write( data );
CKEDITOR.env.air && contentDomReady( doc.getWindow().$ );
});
// Reset adjustment back to default (#5689)
if ( document.location.protocol == 'chrome:' )
CKEDITOR.event.useCapture = false;
mainElement.append( CKEDITOR.dom.element.createFromHtml(
'<span id="' + labelId + '" class="cke_voice_label">' + frameDesc + '</span>'));
mainElement.append( iframe );
// Webkit: iframe size doesn't auto fit well. (#7360)
if ( CKEDITOR.env.webkit )
{
onResize = function()
{
// Hide the iframe to get real size of the holder. (#8941)
mainElement.setStyle( 'width', '100%' );
iframe.hide();
iframe.setSize( 'width', mainElement.getSize( 'width' ) );
mainElement.removeStyle( 'width' );
iframe.show();
};
win.on( 'resize', onResize );
}
};
// The script that launches the bootstrap logic on 'domReady', so the document
// is fully editable even before the editing iframe is fully loaded (#4455).
contentDomReadyHandler = CKEDITOR.tools.addFunction( contentDomReady );
var activationScript =
'<script id="cke_actscrpt" type="text/javascript" data-cke-temp="1">' +
( isCustomDomain ? ( 'document.domain="' + document.domain + '";' ) : '' ) +
'window.parent.CKEDITOR.tools.callFunction( ' + contentDomReadyHandler + ', window );' +
'</script>';
// Editing area bootstrap code.
function contentDomReady( domWindow )
{
if ( !frameLoaded )
return;
frameLoaded = 0;
editor.fire( 'ariaWidget', iframe );
var domDocument = domWindow.document,
body = domDocument.body;
// Remove this script from the DOM.
var script = domDocument.getElementById( "cke_actscrpt" );
script && script.parentNode.removeChild( script );
body.spellcheck = !editor.config.disableNativeSpellChecker;
var editable = !editor.readOnly;
if ( CKEDITOR.env.ie )
{
// Don't display the focus border.
body.hideFocus = true;
// Disable and re-enable the body to avoid IE from
// taking the editing focus at startup. (#141 / #523)
body.disabled = true;
body.contentEditable = editable;
body.removeAttribute( 'disabled' );
}
else
{
// Avoid opening design mode in a frame window thread,
// which will cause host page scrolling.(#4397)
setTimeout( function()
{
// Prefer 'contentEditable' instead of 'designMode'. (#3593)
if ( CKEDITOR.env.gecko && CKEDITOR.env.version >= 10900
|| CKEDITOR.env.opera )
domDocument.$.body.contentEditable = editable;
else if ( CKEDITOR.env.webkit )
domDocument.$.body.parentNode.contentEditable = editable;
else
domDocument.$.designMode = editable? 'off' : 'on';
}, 0 );
}
editable && CKEDITOR.env.gecko && CKEDITOR.tools.setTimeout( activateEditing, 0, null, editor );
domWindow = editor.window = new CKEDITOR.dom.window( domWindow );
domDocument = editor.document = new CKEDITOR.dom.document( domDocument );
editable && domDocument.on( 'dblclick', function( evt )
{
var element = evt.data.getTarget(),
data = { element : element, dialog : '' };
editor.fire( 'doubleclick', data );
data.dialog && editor.openDialog( data.dialog );
});
// Prevent automatic submission in IE #6336
CKEDITOR.env.ie && domDocument.on( 'click', function( evt )
{
var element = evt.data.getTarget();
if ( element.is( 'input' ) )
{
var type = element.getAttribute( 'type' );
if ( type == 'submit' || type == 'reset' )
evt.data.preventDefault();
}
});
// Gecko/Webkit need some help when selecting control type elements. (#3448)
if ( !( CKEDITOR.env.ie || CKEDITOR.env.opera ) )
{
domDocument.on( 'mousedown', function( ev )
{
var control = ev.data.getTarget();
if ( control.is( 'img', 'hr', 'input', 'textarea', 'select' ) )
editor.getSelection().selectElement( control );
} );
}
if ( CKEDITOR.env.gecko )
{
domDocument.on( 'mouseup', function( ev )
{
if ( ev.data.$.button == 2 )
{
var target = ev.data.getTarget();
// Prevent right click from selecting an empty block even
// when selection is anchored inside it. (#5845)
if ( !target.getOuterHtml().replace( emptyParagraphRegexp, '' ) )
{
var range = new CKEDITOR.dom.range( domDocument );
range.moveToElementEditStart( target );
range.select( true );
}
}
} );
}
// Prevent the browser opening links in read-only blocks. (#6032)
domDocument.on( 'click', function( ev )
{
ev = ev.data;
if ( ev.getTarget().is( 'a' ) && ev.$.button != 2 )
ev.preventDefault();
});
// Webkit: avoid from editing form control elements content.
if ( CKEDITOR.env.webkit )
{
// Mark that cursor will right blinking (#7113).
domDocument.on( 'mousedown', function() { wasFocused = 1; } );
// Prevent from tick checkbox/radiobox/select
domDocument.on( 'click', function( ev )
{
if ( ev.data.getTarget().is( 'input', 'select' ) )
ev.data.preventDefault();
} );
// Prevent from editig textfield/textarea value.
domDocument.on( 'mouseup', function( ev )
{
if ( ev.data.getTarget().is( 'input', 'textarea' ) )
ev.data.preventDefault();
} );
}
var focusTarget = CKEDITOR.env.ie ? iframe : domWindow;
focusTarget.on( 'blur', function()
{
editor.focusManager.blur();
});
var wasFocused;
focusTarget.on( 'focus', function()
{
var doc = editor.document;
if ( CKEDITOR.env.gecko || CKEDITOR.env.opera )
doc.getBody().focus();
// Webkit needs focus for the first time on the HTML element. (#6153)
else if ( CKEDITOR.env.webkit )
{
if ( !wasFocused )
{
editor.document.getDocumentElement().focus();
wasFocused = 1;
}
}
editor.focusManager.focus();
});
var keystrokeHandler = editor.keystrokeHandler;
// Prevent backspace from navigating off the page.
keystrokeHandler.blockedKeystrokes[ 8 ] = !editable;
keystrokeHandler.attach( domDocument );
domDocument.getDocumentElement().addClass( domDocument.$.compatMode );
// Override keystroke behaviors.
editable && domDocument.on( 'keydown', function( evt )
{
var keyCode = evt.data.getKeystroke();
// Backspace OR Delete.
if ( keyCode in { 8 : 1, 46 : 1 } )
{
var sel = editor.getSelection(),
selected = sel.getSelectedElement(),
range = sel.getRanges()[ 0 ],
path = new CKEDITOR.dom.elementPath( range.startContainer ),
block,
parent,
next,
rtl = keyCode == 8;
// Override keystrokes which should have deletion behavior
// on fully selected element . (#4047) (#7645)
if ( selected )
{
// Make undo snapshot.
editor.fire( 'saveSnapshot' );
// Delete any element that 'hasLayout' (e.g. hr,table) in IE8 will
// break up the selection, safely manage it here. (#4795)
range.moveToPosition( selected, CKEDITOR.POSITION_BEFORE_START );
// Remove the control manually.
selected.remove();
range.select();
editor.fire( 'saveSnapshot' );
evt.data.preventDefault();
}
else
{
// Handle the following special cases: (#6217)
// 1. Del/Backspace key before/after table;
// 2. Backspace Key after start of table.
if ( ( block = path.block ) &&
range[ rtl ? 'checkStartOfBlock' : 'checkEndOfBlock' ]() &&
( next = block[ rtl ? 'getPrevious' : 'getNext' ]( notWhitespaceEval ) ) &&
next.is( 'table' ) )
{
editor.fire( 'saveSnapshot' );
// Remove the current empty block.
if ( range[ rtl ? 'checkEndOfBlock' : 'checkStartOfBlock' ]() )
block.remove();
// Move cursor to the beginning/end of table cell.
range[ 'moveToElementEdit' + ( rtl ? 'End' : 'Start' ) ]( next );
range.select();
editor.fire( 'saveSnapshot' );
evt.data.preventDefault();
}
else if ( path.blockLimit.is( 'td' ) &&
( parent = path.blockLimit.getAscendant( 'table' ) ) &&
range.checkBoundaryOfElement( parent, rtl ? CKEDITOR.START : CKEDITOR.END ) &&
( next = parent[ rtl ? 'getPrevious' : 'getNext' ]( notWhitespaceEval ) ) )
{
editor.fire( 'saveSnapshot' );
// Move cursor to the end of previous block.
range[ 'moveToElementEdit' + ( rtl ? 'End' : 'Start' ) ]( next );
// Remove any previous empty block.
if ( range.checkStartOfBlock() && range.checkEndOfBlock() )
next.remove();
else
range.select();
editor.fire( 'saveSnapshot' );
evt.data.preventDefault();
}
}
}
// PageUp OR PageDown
if ( keyCode == 33 || keyCode == 34 )
{
if ( CKEDITOR.env.gecko )
{
var body = domDocument.getBody();
// Page up/down cause editor selection to leak
// outside of editable thus we try to intercept
// the behavior, while it affects only happen
// when editor contents are not overflowed. (#7955)
if ( domWindow.$.innerHeight > body.$.offsetHeight )
{
range = new CKEDITOR.dom.range( domDocument );
range[ keyCode == 33 ? 'moveToElementEditStart' : 'moveToElementEditEnd']( body );
range.select();
evt.data.preventDefault();
}
}
}
} );
// PageUp/PageDown scrolling is broken in document
// with standard doctype, manually fix it. (#4736)
if ( CKEDITOR.env.ie && domDocument.$.compatMode == 'CSS1Compat' )
{
var pageUpDownKeys = { 33 : 1, 34 : 1 };
domDocument.on( 'keydown', function( evt )
{
if ( evt.data.getKeystroke() in pageUpDownKeys )
{
setTimeout( function ()
{
editor.getSelection().scrollIntoView();
}, 0 );
}
} );
}
// Prevent IE from leaving new paragraph after deleting all contents in body. (#6966)
if ( CKEDITOR.env.ie && editor.config.enterMode != CKEDITOR.ENTER_P )
{
domDocument.on( 'selectionchange', function()
{
var body = domDocument.getBody(),
sel = editor.getSelection(),
range = sel && sel.getRanges()[ 0 ];
if ( range && body.getHtml().match( /^<p> <\/p>$/i )
&& range.startContainer.equals( body ) )
{
// Avoid the ambiguity from a real user cursor position.
setTimeout( function ()
{
range = editor.getSelection().getRanges()[ 0 ];
if ( !range.startContainer.equals ( 'body' ) )
{
body.getFirst().remove( 1 );
range.moveToElementEditEnd( body );
range.select( 1 );
}
}, 0 );
}
});
}
// Adds the document body as a context menu target.
if ( editor.contextMenu )
editor.contextMenu.addTarget( domDocument, editor.config.browserContextMenuOnCtrl !== false );
setTimeout( function()
{
editor.fire( 'contentDom' );
if ( fireMode )
{
editor.mode = 'wysiwyg';
editor.fire( 'mode', { previousMode : editor._.previousMode } );
fireMode = false;
}
isLoadingData = false;
if ( isPendingFocus )
{
editor.focus();
isPendingFocus = false;
}
setTimeout( function()
{
editor.fire( 'dataReady' );
}, 0 );
// Enable dragging of position:absolute elements in IE.
try { editor.document.$.execCommand ( '2D-position', false, true); } catch(e) {}
// IE, Opera and Safari may not support it and throw errors.
try { editor.document.$.execCommand( 'enableInlineTableEditing', false, !editor.config.disableNativeTableHandles ); } catch(e) {}
if ( editor.config.disableObjectResizing )
{
try
{
editor.document.$.execCommand( 'enableObjectResizing', false, false );
}
catch(e)
{
// For browsers in which the above method failed, we can cancel the resizing on the fly (#4208)
editor.document.getBody().on( CKEDITOR.env.ie ? 'resizestart' : 'resize', function( evt )
{
evt.data.preventDefault();
});
}
}
/*
* IE BUG: IE might have rendered the iframe with invisible contents.
* (#3623). Push some inconsequential CSS style changes to force IE to
* refresh it.
*
* Also, for some unknown reasons, short timeouts (e.g. 100ms) do not
* fix the problem. :(
*/
if ( CKEDITOR.env.ie )
{
setTimeout( function()
{
if ( editor.document )
{
var $body = editor.document.$.body;
$body.runtimeStyle.marginBottom = '0px';
$body.runtimeStyle.marginBottom = '';
}
}, 1000 );
}
},
0 );
}
editor.addMode( 'wysiwyg',
{
load : function( holderElement, data, isSnapshot )
{
mainElement = holderElement;
if ( CKEDITOR.env.ie && CKEDITOR.env.quirks )
holderElement.setStyle( 'position', 'relative' );
// The editor data "may be dirty" after this
// point.
editor.mayBeDirty = true;
fireMode = true;
if ( isSnapshot )
this.loadSnapshotData( data );
else
this.loadData( data );
},
loadData : function( data )
{
isLoadingData = true;
editor._.dataStore = { id : 1 };
var config = editor.config,
fullPage = config.fullPage,
docType = config.docType;
// Build the additional stuff to be included into <head>.
var headExtra =
'<style type="text/css" data-cke-temp="1">' +
editor._.styles.join( '\n' ) +
'</style>';
!fullPage && ( headExtra =
CKEDITOR.tools.buildStyleHtml( editor.config.contentsCss ) +
headExtra );
var baseTag = config.baseHref ? '<base href="' + config.baseHref + '" data-cke-temp="1" />' : '';
if ( fullPage )
{
// Search and sweep out the doctype declaration.
data = data.replace( /<!DOCTYPE[^>]*>/i, function( match )
{
editor.docType = docType = match;
return '';
}).replace( /<\?xml\s[^\?]*\?>/i, function( match )
{
editor.xmlDeclaration = match;
return '';
});
}
// Get the HTML version of the data.
if ( editor.dataProcessor )
data = editor.dataProcessor.toHtml( data, fixForBody );
if ( fullPage )
{
// Check if the <body> tag is available.
if ( !(/<body[\s|>]/).test( data ) )
data = '<body>' + data;
// Check if the <html> tag is available.
if ( !(/<html[\s|>]/).test( data ) )
data = '<html>' + data + '</html>';
// Check if the <head> tag is available.
if ( !(/<head[\s|>]/).test( data ) )
data = data.replace( /<html[^>]*>/, '$&<head><title></title></head>' ) ;
else if ( !(/<title[\s|>]/).test( data ) )
data = data.replace( /<head[^>]*>/, '$&<title></title>' ) ;
// The base must be the first tag in the HEAD, e.g. to get relative
// links on styles.
baseTag && ( data = data.replace( /<head>/, '$&' + baseTag ) );
// Inject the extra stuff into <head>.
// Attention: do not change it before testing it well. (V2)
// This is tricky... if the head ends with <meta ... content type>,
// Firefox will break. But, it works if we place our extra stuff as
// the last elements in the HEAD.
data = data.replace( /<\/head\s*>/, headExtra + '$&' );
// Add the DOCTYPE back to it.
data = docType + data;
}
else
{
data =
config.docType +
'<html dir="' + config.contentsLangDirection + '"' +
' lang="' + ( config.contentsLanguage || editor.langCode ) + '">' +
'<head>' +
'<title>' + frameLabel + '</title>' +
baseTag +
headExtra +
'</head>' +
'<body' + ( config.bodyId ? ' id="' + config.bodyId + '"' : '' ) +
( config.bodyClass ? ' class="' + config.bodyClass + '"' : '' ) +
'>' +
data +
'</html>';
}
// Distinguish bogus to normal BR at the end of document for Mozilla. (#5293).
if ( CKEDITOR.env.gecko )
data = data.replace( /<br \/>(?=\s*<\/(:?html|body)>)/, '$&<br type="_moz" />' );
data += activationScript;
// The iframe is recreated on each call of setData, so we need to clear DOM objects
this.onDispose();
createIFrame( data );
},
getData : function()
{
var config = editor.config,
fullPage = config.fullPage,
docType = fullPage && editor.docType,
xmlDeclaration = fullPage && editor.xmlDeclaration,
doc = iframe.getFrameDocument();
var data = fullPage
? doc.getDocumentElement().getOuterHtml()
: doc.getBody().getHtml();
// BR at the end of document is bogus node for Mozilla. (#5293).
if ( CKEDITOR.env.gecko )
data = data.replace( /<br>(?=\s*(:?$|<\/body>))/, '' );
if ( editor.dataProcessor )
data = editor.dataProcessor.toDataFormat( data, fixForBody );
// Reset empty if the document contains only one empty paragraph.
if ( config.ignoreEmptyParagraph )
data = data.replace( emptyParagraphRegexp, function( match, lookback ) { return lookback; } );
if ( xmlDeclaration )
data = xmlDeclaration + '\n' + data;
if ( docType )
data = docType + '\n' + data;
return data;
},
getSnapshotData : function()
{
return iframe.getFrameDocument().getBody().getHtml();
},
loadSnapshotData : function( data )
{
iframe.getFrameDocument().getBody().setHtml( data );
},
onDispose : function()
{
if ( !editor.document )
return;
editor.document.getDocumentElement().clearCustomData();
editor.document.getBody().clearCustomData();
editor.window.clearCustomData();
editor.document.clearCustomData();
iframe.clearCustomData();
/*
* IE BUG: When destroying editor DOM with the selection remains inside
* editing area would break IE7/8's selection system, we have to put the editing
* iframe offline first. (#3812 and #5441)
*/
iframe.remove();
},
unload : function( holderElement )
{
this.onDispose();
if ( onResize )
win.removeListener( 'resize', onResize );
editor.window = editor.document = iframe = mainElement = isPendingFocus = null;
editor.fire( 'contentDomUnload' );
},
focus : function()
{
var win = editor.window;
if ( isLoadingData )
isPendingFocus = true;
else if ( win )
{
var sel = editor.getSelection(),
ieSel = sel && sel.getNative();
// IE considers control-type element as separate
// focus host when selected, avoid destroying the
// selection in such case. (#5812) (#8949)
if ( ieSel && ieSel.type == 'Control' )
return;
// AIR needs a while to focus when moving from a link.
CKEDITOR.env.air ? setTimeout( function () { win.focus(); }, 0 ) : win.focus();
editor.selectionChange();
}
}
});
editor.on( 'insertHtml', onInsert( doInsertHtml ) , null, null, 20 );
editor.on( 'insertElement', onInsert( doInsertElement ), null, null, 20 );
editor.on( 'insertText', onInsert( doInsertText ), null, null, 20 );
// Auto fixing on some document structure weakness to enhance usabilities. (#3190 and #3189)
editor.on( 'selectionChange', function( evt )
{
if ( editor.readOnly )
return;
var sel = editor.getSelection();
// Do it only when selection is not locked. (#8222)
if ( sel && !sel.isLocked )
{
var isDirty = editor.checkDirty();
editor.fire( 'saveSnapshot', { contentOnly : 1 } );
onSelectionChangeFixBody.call( this, evt );
editor.fire( 'updateSnapshot' );
!isDirty && editor.resetDirty();
}
}, null, null, 1 );
});
editor.on( 'contentDom', function()
{
var title = editor.document.getElementsByTag( 'title' ).getItem( 0 );
title.data( 'cke-title', editor.document.$.title );
// [IE] JAWS will not recognize the aria label we used on the iframe
// unless the frame window title string is used as the voice label,
// backup the original one and restore it on output.
CKEDITOR.env.ie && ( editor.document.$.title = frameLabel );
});
editor.on( 'readOnly', function()
{
if ( editor.mode == 'wysiwyg' )
{
// Symply reload the wysiwyg area. It'll take care of read-only.
var wysiwyg = editor.getMode();
wysiwyg.loadData( wysiwyg.getData() );
}
});
// IE>=8 stricts mode doesn't have 'contentEditable' in effect
// on element unless it has layout. (#5562)
if ( CKEDITOR.document.$.documentMode >= 8 )
{
editor.addCss( 'html.CSS1Compat [contenteditable=false]{ min-height:0 !important;}' );
var selectors = [];
for ( var tag in CKEDITOR.dtd.$removeEmpty )
selectors.push( 'html.CSS1Compat ' + tag + '[contenteditable=false]' );
editor.addCss( selectors.join( ',' ) + '{ display:inline-block;}' );
}
// Set the HTML style to 100% to have the text cursor in affect (#6341)
else if ( CKEDITOR.env.gecko )
{
editor.addCss( 'html { height: 100% !important; }' );
editor.addCss( 'img:-moz-broken { -moz-force-broken-image-icon : 1; min-width : 24px; min-height : 24px; }' );
}
// Remove the margin to avoid mouse confusion. (#8835)
else if ( CKEDITOR.env.ie && CKEDITOR.env.version < 8 && editor.config.contentsLangDirection == 'ltr' )
editor.addCss( 'body{margin-right:0;}' );
/* #3658: [IE6] Editor document has horizontal scrollbar on long lines
To prevent this misbehavior, we show the scrollbar always */
/* #6341: The text cursor must be set on the editor area. */
/* #6632: Avoid having "text" shape of cursor in IE7 scrollbars.*/
editor.addCss( 'html { _overflow-y: scroll; cursor: text; *cursor:auto;}' );
// Use correct cursor for these elements
editor.addCss( 'img, input, textarea { cursor: default;}' );
// Disable form elements editing mode provided by some browers. (#5746)
editor.on( 'insertElement', function ( evt )
{
var element = evt.data;
if ( element.type == CKEDITOR.NODE_ELEMENT
&& ( element.is( 'input' ) || element.is( 'textarea' ) ) )
{
// We should flag that the element was locked by our code so
// it'll be editable by the editor functions (#6046).
var readonly = element.getAttribute( 'contenteditable' ) == 'false';
if ( !readonly )
{
element.data( 'cke-editable', element.hasAttribute( 'contenteditable' ) ? 'true' : '1' );
element.setAttribute( 'contenteditable', false );
}
}
});
}
});
// Fixing Firefox 'Back-Forward Cache' break design mode. (#4514)
if ( CKEDITOR.env.gecko )
{
(function()
{
var body = document.body;
if ( !body )
window.addEventListener( 'load', arguments.callee, false );
else
{
var currentHandler = body.getAttribute( 'onpageshow' );
body.setAttribute( 'onpageshow', ( currentHandler ? currentHandler + ';' : '') +
'event.persisted && (function(){' +
'var allInstances = CKEDITOR.instances, editor, doc;' +
'for ( var i in allInstances )' +
'{' +
' editor = allInstances[ i ];' +
' doc = editor.document;' +
' if ( doc )' +
' {' +
' doc.$.designMode = "off";' +
' doc.$.designMode = "on";' +
' }' +
'}' +
'})();' );
}
} )();
}
})();
/**
* Disables the ability of resize objects (image and tables) in the editing
* area.
* @type Boolean
* @default false
* @example
* config.disableObjectResizing = true;
*/
CKEDITOR.config.disableObjectResizing = false;
/**
* Disables the "table tools" offered natively by the browser (currently
* Firefox only) to make quick table editing operations, like adding or
* deleting rows and columns.
* @type Boolean
* @default true
* @example
* config.disableNativeTableHandles = false;
*/
CKEDITOR.config.disableNativeTableHandles = true;
/**
* Disables the built-in words spell checker if browser provides one.<br /><br />
*
* <strong>Note:</strong> Although word suggestions provided by browsers (natively) will not appear in CKEditor's default context menu,
* users can always reach the native context menu by holding the <em>Ctrl</em> key when right-clicking if {@link CKEDITOR.config.browserContextMenuOnCtrl}
* is enabled or you're simply not using the context menu plugin.
*
* @type Boolean
* @default true
* @example
* config.disableNativeSpellChecker = false;
*/
CKEDITOR.config.disableNativeSpellChecker = true;
/**
* Whether the editor must output an empty value ("") if it's contents is made
* by an empty paragraph only.
* @type Boolean
* @default true
* @example
* config.ignoreEmptyParagraph = false;
*/
CKEDITOR.config.ignoreEmptyParagraph = true;
/**
* Fired when data is loaded and ready for retrieval in an editor instance.
* @name CKEDITOR.editor#dataReady
* @event
*/
/**
* Whether automatically create wrapping blocks around inline contents inside document body,
* this helps to ensure the integrality of the block enter mode.
* <strong>Note:</strong> Changing the default value might introduce unpredictable usability issues.
* @name CKEDITOR.config.autoParagraph
* @since 3.6
* @type Boolean
* @default true
* @example
* config.autoParagraph = false;
*/
/**
* Fired when some elements are added to the document
* @name CKEDITOR.editor#ariaWidget
* @event
* @param {Object} element The element being added
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
CKEDITOR.plugins.add( 'stylescombo',
{
requires : [ 'richcombo', 'styles' ],
init : function( editor )
{
var config = editor.config,
lang = editor.lang.stylesCombo,
styles = {},
stylesList = [],
combo;
function loadStylesSet( callback )
{
editor.getStylesSet( function( stylesDefinitions )
{
if ( !stylesList.length )
{
var style,
styleName;
// Put all styles into an Array.
for ( var i = 0, count = stylesDefinitions.length ; i < count ; i++ )
{
var styleDefinition = stylesDefinitions[ i ];
styleName = styleDefinition.name;
style = styles[ styleName ] = new CKEDITOR.style( styleDefinition );
style._name = styleName;
style._.enterMode = config.enterMode;
stylesList.push( style );
}
// Sorts the Array, so the styles get grouped by type.
stylesList.sort( sortStyles );
}
callback && callback();
});
}
editor.ui.addRichCombo( 'Styles',
{
label : lang.label,
title : lang.panelTitle,
className : 'cke_styles',
panel :
{
css : editor.skin.editor.css.concat( config.contentsCss ),
multiSelect : true,
attributes : { 'aria-label' : lang.panelTitle }
},
init : function()
{
combo = this;
loadStylesSet( function()
{
var style,
styleName,
lastType,
type,
i,
count;
// Loop over the Array, adding all items to the
// combo.
for ( i = 0, count = stylesList.length ; i < count ; i++ )
{
style = stylesList[ i ];
styleName = style._name;
type = style.type;
if ( type != lastType )
{
combo.startGroup( lang[ 'panelTitle' + String( type ) ] );
lastType = type;
}
combo.add(
styleName,
style.type == CKEDITOR.STYLE_OBJECT ? styleName : style.buildPreview(),
styleName );
}
combo.commit();
});
},
onClick : function( value )
{
editor.focus();
editor.fire( 'saveSnapshot' );
var style = styles[ value ],
selection = editor.getSelection(),
elementPath = new CKEDITOR.dom.elementPath( selection.getStartElement() );
style[ style.checkActive( elementPath ) ? 'remove' : 'apply' ]( editor.document );
editor.fire( 'saveSnapshot' );
},
onRender : function()
{
editor.on( 'selectionChange', function( ev )
{
var currentValue = this.getValue(),
elementPath = ev.data.path,
elements = elementPath.elements;
// For each element into the elements path.
for ( var i = 0, count = elements.length, element ; i < count ; i++ )
{
element = elements[i];
// Check if the element is removable by any of
// the styles.
for ( var value in styles )
{
if ( styles[ value ].checkElementRemovable( element, true ) )
{
if ( value != currentValue )
this.setValue( value );
return;
}
}
}
// If no styles match, just empty it.
this.setValue( '' );
},
this);
},
onOpen : function()
{
if ( CKEDITOR.env.ie || CKEDITOR.env.webkit )
editor.focus();
var selection = editor.getSelection(),
element = selection.getSelectedElement(),
elementPath = new CKEDITOR.dom.elementPath( element || selection.getStartElement() ),
counter = [ 0, 0, 0, 0 ];
this.showAll();
this.unmarkAll();
for ( var name in styles )
{
var style = styles[ name ],
type = style.type;
if ( style.checkActive( elementPath ) )
this.mark( name );
else if ( type == CKEDITOR.STYLE_OBJECT && !style.checkApplicable( elementPath ) )
{
this.hideItem( name );
counter[ type ]--;
}
counter[ type ]++;
}
if ( !counter[ CKEDITOR.STYLE_BLOCK ] )
this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_BLOCK ) ] );
if ( !counter[ CKEDITOR.STYLE_INLINE ] )
this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_INLINE ) ] );
if ( !counter[ CKEDITOR.STYLE_OBJECT ] )
this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_OBJECT ) ] );
},
// Force a reload of the data
reset: function()
{
if ( combo )
{
delete combo._.panel;
delete combo._.list;
combo._.committed = 0;
combo._.items = {};
combo._.state = CKEDITOR.TRISTATE_OFF;
}
styles = {};
stylesList = [];
loadStylesSet();
}
});
editor.on( 'instanceReady', function() { loadStylesSet(); } );
}
});
function sortStyles( styleA, styleB )
{
var typeA = styleA.type,
typeB = styleB.type;
return typeA == typeB ? 0 :
typeA == CKEDITOR.STYLE_OBJECT ? -1 :
typeB == CKEDITOR.STYLE_OBJECT ? 1 :
typeB == CKEDITOR.STYLE_BLOCK ? 1 :
-1;
}
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'find',
{
requires : [ 'dialog' ],
init : function( editor )
{
var forms = CKEDITOR.plugins.find;
editor.ui.addButton( 'Find',
{
label : editor.lang.findAndReplace.find,
command : 'find'
});
var findCommand = editor.addCommand( 'find', new CKEDITOR.dialogCommand( 'find' ) );
findCommand.canUndo = false;
findCommand.readOnly = 1;
editor.ui.addButton( 'Replace',
{
label : editor.lang.findAndReplace.replace,
command : 'replace'
});
var replaceCommand = editor.addCommand( 'replace', new CKEDITOR.dialogCommand( 'replace' ) );
replaceCommand.canUndo = false;
CKEDITOR.dialog.add( 'find', this.path + 'dialogs/find.js' );
CKEDITOR.dialog.add( 'replace', this.path + 'dialogs/find.js' );
},
requires : [ 'styles' ]
} );
/**
* Defines the style to be used to highlight results with the find dialog.
* @type Object
* @default { element : 'span', styles : { 'background-color' : '#004', 'color' : '#fff' } }
* @example
* // Highlight search results with blue on yellow.
* config.find_highlight =
* {
* element : 'span',
* styles : { 'background-color' : '#ff0', 'color' : '#00f' }
* };
*/
CKEDITOR.config.find_highlight = { element : 'span', styles : { 'background-color' : '#004', 'color' : '#fff' } };
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var isReplace;
function findEvaluator( node )
{
return node.type == CKEDITOR.NODE_TEXT && node.getLength() > 0 && ( !isReplace || !node.isReadOnly() );
}
/**
* Elements which break characters been considered as sequence.
*/
function nonCharactersBoundary( node )
{
return !( node.type == CKEDITOR.NODE_ELEMENT && node.isBlockBoundary(
CKEDITOR.tools.extend( {}, CKEDITOR.dtd.$empty, CKEDITOR.dtd.$nonEditable ) ) );
}
/**
* Get the cursor object which represent both current character and it's dom
* position thing.
*/
var cursorStep = function()
{
return {
textNode : this.textNode,
offset : this.offset,
character : this.textNode ?
this.textNode.getText().charAt( this.offset ) : null,
hitMatchBoundary : this._.matchBoundary
};
};
var pages = [ 'find', 'replace' ],
fieldsMapping = [
[ 'txtFindFind', 'txtFindReplace' ],
[ 'txtFindCaseChk', 'txtReplaceCaseChk' ],
[ 'txtFindWordChk', 'txtReplaceWordChk' ],
[ 'txtFindCyclic', 'txtReplaceCyclic' ] ];
/**
* Synchronize corresponding filed values between 'replace' and 'find' pages.
* @param {String} currentPageId The page id which receive values.
*/
function syncFieldsBetweenTabs( currentPageId )
{
var sourceIndex, targetIndex,
sourceField, targetField;
sourceIndex = currentPageId === 'find' ? 1 : 0;
targetIndex = 1 - sourceIndex;
var i, l = fieldsMapping.length;
for ( i = 0 ; i < l ; i++ )
{
sourceField = this.getContentElement( pages[ sourceIndex ],
fieldsMapping[ i ][ sourceIndex ] );
targetField = this.getContentElement( pages[ targetIndex ],
fieldsMapping[ i ][ targetIndex ] );
targetField.setValue( sourceField.getValue() );
}
}
var findDialog = function( editor, startupPage )
{
// Style object for highlights: (#5018)
// 1. Defined as full match style to avoid compromising ordinary text color styles.
// 2. Must be apply onto inner-most text to avoid conflicting with ordinary text color styles visually.
var highlightStyle = new CKEDITOR.style(
CKEDITOR.tools.extend( { attributes : { 'data-cke-highlight': 1 }, fullMatch : 1, ignoreReadonly : 1, childRule : function(){ return 0; } },
editor.config.find_highlight, true ) );
/**
* Iterator which walk through the specified range char by char. By
* default the walking will not stop at the character boundaries, until
* the end of the range is encountered.
* @param { CKEDITOR.dom.range } range
* @param {Boolean} matchWord Whether the walking will stop at character boundary.
*/
var characterWalker = function( range , matchWord )
{
var self = this;
var walker =
new CKEDITOR.dom.walker( range );
walker.guard = matchWord ? nonCharactersBoundary : function( node )
{
!nonCharactersBoundary( node ) && ( self._.matchBoundary = true );
};
walker[ 'evaluator' ] = findEvaluator;
walker.breakOnFalse = 1;
if ( range.startContainer.type == CKEDITOR.NODE_TEXT )
{
this.textNode = range.startContainer;
this.offset = range.startOffset - 1;
}
this._ = {
matchWord : matchWord,
walker : walker,
matchBoundary : false
};
};
characterWalker.prototype = {
next : function()
{
return this.move();
},
back : function()
{
return this.move( true );
},
move : function( rtl )
{
var currentTextNode = this.textNode;
// Already at the end of document, no more character available.
if ( currentTextNode === null )
return cursorStep.call( this );
this._.matchBoundary = false;
// There are more characters in the text node, step forward.
if ( currentTextNode
&& rtl
&& this.offset > 0 )
{
this.offset--;
return cursorStep.call( this );
}
else if ( currentTextNode
&& this.offset < currentTextNode.getLength() - 1 )
{
this.offset++;
return cursorStep.call( this );
}
else
{
currentTextNode = null;
// At the end of the text node, walking foward for the next.
while ( !currentTextNode )
{
currentTextNode =
this._.walker[ rtl ? 'previous' : 'next' ].call( this._.walker );
// Stop searching if we're need full word match OR
// already reach document end.
if ( this._.matchWord && !currentTextNode
|| this._.walker._.end )
break;
}
// Found a fresh text node.
this.textNode = currentTextNode;
if ( currentTextNode )
this.offset = rtl ? currentTextNode.getLength() - 1 : 0;
else
this.offset = 0;
}
return cursorStep.call( this );
}
};
/**
* A range of cursors which represent a trunk of characters which try to
* match, it has the same length as the pattern string.
*/
var characterRange = function( characterWalker, rangeLength )
{
this._ = {
walker : characterWalker,
cursors : [],
rangeLength : rangeLength,
highlightRange : null,
isMatched : 0
};
};
characterRange.prototype = {
/**
* Translate this range to {@link CKEDITOR.dom.range}
*/
toDomRange : function()
{
var range = new CKEDITOR.dom.range( editor.document );
var cursors = this._.cursors;
if ( cursors.length < 1 )
{
var textNode = this._.walker.textNode;
if ( textNode )
range.setStartAfter( textNode );
else
return null;
}
else
{
var first = cursors[0],
last = cursors[ cursors.length - 1 ];
range.setStart( first.textNode, first.offset );
range.setEnd( last.textNode, last.offset + 1 );
}
return range;
},
/**
* Reflect the latest changes from dom range.
*/
updateFromDomRange : function( domRange )
{
var cursor,
walker = new characterWalker( domRange );
this._.cursors = [];
do
{
cursor = walker.next();
if ( cursor.character )
this._.cursors.push( cursor );
}
while ( cursor.character );
this._.rangeLength = this._.cursors.length;
},
setMatched : function()
{
this._.isMatched = true;
},
clearMatched : function()
{
this._.isMatched = false;
},
isMatched : function()
{
return this._.isMatched;
},
/**
* Hightlight the current matched chunk of text.
*/
highlight : function()
{
// Do not apply if nothing is found.
if ( this._.cursors.length < 1 )
return;
// Remove the previous highlight if there's one.
if ( this._.highlightRange )
this.removeHighlight();
// Apply the highlight.
var range = this.toDomRange(),
bookmark = range.createBookmark();
highlightStyle.applyToRange( range );
range.moveToBookmark( bookmark );
this._.highlightRange = range;
// Scroll the editor to the highlighted area.
var element = range.startContainer;
if ( element.type != CKEDITOR.NODE_ELEMENT )
element = element.getParent();
element.scrollIntoView();
// Update the character cursors.
this.updateFromDomRange( range );
},
/**
* Remove highlighted find result.
*/
removeHighlight : function()
{
if ( !this._.highlightRange )
return;
var bookmark = this._.highlightRange.createBookmark();
highlightStyle.removeFromRange( this._.highlightRange );
this._.highlightRange.moveToBookmark( bookmark );
this.updateFromDomRange( this._.highlightRange );
this._.highlightRange = null;
},
isReadOnly : function()
{
if ( !this._.highlightRange )
return 0;
return this._.highlightRange.startContainer.isReadOnly();
},
moveBack : function()
{
var retval = this._.walker.back(),
cursors = this._.cursors;
if ( retval.hitMatchBoundary )
this._.cursors = cursors = [];
cursors.unshift( retval );
if ( cursors.length > this._.rangeLength )
cursors.pop();
return retval;
},
moveNext : function()
{
var retval = this._.walker.next(),
cursors = this._.cursors;
// Clear the cursors queue if we've crossed a match boundary.
if ( retval.hitMatchBoundary )
this._.cursors = cursors = [];
cursors.push( retval );
if ( cursors.length > this._.rangeLength )
cursors.shift();
return retval;
},
getEndCharacter : function()
{
var cursors = this._.cursors;
if ( cursors.length < 1 )
return null;
return cursors[ cursors.length - 1 ].character;
},
getNextCharacterRange : function( maxLength )
{
var lastCursor,
nextRangeWalker,
cursors = this._.cursors;
if ( ( lastCursor = cursors[ cursors.length - 1 ] ) && lastCursor.textNode )
nextRangeWalker = new characterWalker( getRangeAfterCursor( lastCursor ) );
// In case it's an empty range (no cursors), figure out next range from walker (#4951).
else
nextRangeWalker = this._.walker;
return new characterRange( nextRangeWalker, maxLength );
},
getCursors : function()
{
return this._.cursors;
}
};
// The remaining document range after the character cursor.
function getRangeAfterCursor( cursor , inclusive )
{
var range = new CKEDITOR.dom.range();
range.setStart( cursor.textNode,
( inclusive ? cursor.offset : cursor.offset + 1 ) );
range.setEndAt( editor.document.getBody(),
CKEDITOR.POSITION_BEFORE_END );
return range;
}
// The document range before the character cursor.
function getRangeBeforeCursor( cursor )
{
var range = new CKEDITOR.dom.range();
range.setStartAt( editor.document.getBody(),
CKEDITOR.POSITION_AFTER_START );
range.setEnd( cursor.textNode, cursor.offset );
return range;
}
var KMP_NOMATCH = 0,
KMP_ADVANCED = 1,
KMP_MATCHED = 2;
/**
* Examination the occurrence of a word which implement KMP algorithm.
*/
var kmpMatcher = function( pattern, ignoreCase )
{
var overlap = [ -1 ];
if ( ignoreCase )
pattern = pattern.toLowerCase();
for ( var i = 0 ; i < pattern.length ; i++ )
{
overlap.push( overlap[i] + 1 );
while ( overlap[ i + 1 ] > 0
&& pattern.charAt( i ) != pattern
.charAt( overlap[ i + 1 ] - 1 ) )
overlap[ i + 1 ] = overlap[ overlap[ i + 1 ] - 1 ] + 1;
}
this._ = {
overlap : overlap,
state : 0,
ignoreCase : !!ignoreCase,
pattern : pattern
};
};
kmpMatcher.prototype =
{
feedCharacter : function( c )
{
if ( this._.ignoreCase )
c = c.toLowerCase();
while ( true )
{
if ( c == this._.pattern.charAt( this._.state ) )
{
this._.state++;
if ( this._.state == this._.pattern.length )
{
this._.state = 0;
return KMP_MATCHED;
}
return KMP_ADVANCED;
}
else if ( !this._.state )
return KMP_NOMATCH;
else
this._.state = this._.overlap[ this._.state ];
}
return null;
},
reset : function()
{
this._.state = 0;
}
};
var wordSeparatorRegex =
/[.,"'?!;: \u0085\u00a0\u1680\u280e\u2028\u2029\u202f\u205f\u3000]/;
var isWordSeparator = function( c )
{
if ( !c )
return true;
var code = c.charCodeAt( 0 );
return ( code >= 9 && code <= 0xd )
|| ( code >= 0x2000 && code <= 0x200a )
|| wordSeparatorRegex.test( c );
};
var finder = {
searchRange : null,
matchRange : null,
find : function( pattern, matchCase, matchWord, matchCyclic, highlightMatched, cyclicRerun )
{
if ( !this.matchRange )
this.matchRange =
new characterRange(
new characterWalker( this.searchRange ),
pattern.length );
else
{
this.matchRange.removeHighlight();
this.matchRange = this.matchRange.getNextCharacterRange( pattern.length );
}
var matcher = new kmpMatcher( pattern, !matchCase ),
matchState = KMP_NOMATCH,
character = '%';
while ( character !== null )
{
this.matchRange.moveNext();
while ( ( character = this.matchRange.getEndCharacter() ) )
{
matchState = matcher.feedCharacter( character );
if ( matchState == KMP_MATCHED )
break;
if ( this.matchRange.moveNext().hitMatchBoundary )
matcher.reset();
}
if ( matchState == KMP_MATCHED )
{
if ( matchWord )
{
var cursors = this.matchRange.getCursors(),
tail = cursors[ cursors.length - 1 ],
head = cursors[ 0 ];
var rangeBefore = getRangeBeforeCursor( head ),
rangeAfter = getRangeAfterCursor( tail );
// The word boundary checks requires to trim the text nodes. (#9036)
rangeBefore.trim();
rangeAfter.trim();
var headWalker = new characterWalker( rangeBefore, true ),
tailWalker = new characterWalker( rangeAfter, true );
if ( ! ( isWordSeparator( headWalker.back().character )
&& isWordSeparator( tailWalker.next().character ) ) )
continue;
}
this.matchRange.setMatched();
if ( highlightMatched !== false )
this.matchRange.highlight();
return true;
}
}
this.matchRange.clearMatched();
this.matchRange.removeHighlight();
// Clear current session and restart with the default search
// range.
// Re-run the finding once for cyclic.(#3517)
if ( matchCyclic && !cyclicRerun )
{
this.searchRange = getSearchRange( 1 );
this.matchRange = null;
return arguments.callee.apply( this,
Array.prototype.slice.call( arguments ).concat( [ true ] ) );
}
return false;
},
/**
* Record how much replacement occurred toward one replacing.
*/
replaceCounter : 0,
replace : function( dialog, pattern, newString, matchCase, matchWord,
matchCyclic , isReplaceAll )
{
isReplace = 1;
// Successiveness of current replace/find.
var result = 0;
// 1. Perform the replace when there's already a match here.
// 2. Otherwise perform the find but don't replace it immediately.
if ( this.matchRange && this.matchRange.isMatched()
&& !this.matchRange._.isReplaced && !this.matchRange.isReadOnly() )
{
// Turn off highlight for a while when saving snapshots.
this.matchRange.removeHighlight();
var domRange = this.matchRange.toDomRange();
var text = editor.document.createText( newString );
if ( !isReplaceAll )
{
// Save undo snaps before and after the replacement.
var selection = editor.getSelection();
selection.selectRanges( [ domRange ] );
editor.fire( 'saveSnapshot' );
}
domRange.deleteContents();
domRange.insertNode( text );
if ( !isReplaceAll )
{
selection.selectRanges( [ domRange ] );
editor.fire( 'saveSnapshot' );
}
this.matchRange.updateFromDomRange( domRange );
if ( !isReplaceAll )
this.matchRange.highlight();
this.matchRange._.isReplaced = true;
this.replaceCounter++;
result = 1;
}
else
result = this.find( pattern, matchCase, matchWord, matchCyclic, !isReplaceAll );
isReplace = 0;
return result;
}
};
/**
* The range in which find/replace happened, receive from user
* selection prior.
*/
function getSearchRange( isDefault )
{
var searchRange,
sel = editor.getSelection(),
body = editor.document.getBody();
if ( sel && !isDefault )
{
searchRange = sel.getRanges()[ 0 ].clone();
searchRange.collapse( true );
}
else
{
searchRange = new CKEDITOR.dom.range();
searchRange.setStartAt( body, CKEDITOR.POSITION_AFTER_START );
}
searchRange.setEndAt( body, CKEDITOR.POSITION_BEFORE_END );
return searchRange;
}
var lang = editor.lang.findAndReplace;
return {
title : lang.title,
resizable : CKEDITOR.DIALOG_RESIZE_NONE,
minWidth : 350,
minHeight : 170,
buttons : [ CKEDITOR.dialog.cancelButton ], // Cancel button only.
contents : [
{
id : 'find',
label : lang.find,
title : lang.find,
accessKey : '',
elements : [
{
type : 'hbox',
widths : [ '230px', '90px' ],
children :
[
{
type : 'text',
id : 'txtFindFind',
label : lang.findWhat,
isChanged : false,
labelLayout : 'horizontal',
accessKey : 'F'
},
{
type : 'button',
id : 'btnFind',
align : 'left',
style : 'width:100%',
label : lang.find,
onClick : function()
{
var dialog = this.getDialog();
if ( !finder.find( dialog.getValueOf( 'find', 'txtFindFind' ),
dialog.getValueOf( 'find', 'txtFindCaseChk' ),
dialog.getValueOf( 'find', 'txtFindWordChk' ),
dialog.getValueOf( 'find', 'txtFindCyclic' ) ) )
alert( lang
.notFoundMsg );
}
}
]
},
{
type : 'fieldset',
label : CKEDITOR.tools.htmlEncode( lang.findOptions ),
style : 'margin-top:29px',
children :
[
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'checkbox',
id : 'txtFindCaseChk',
isChanged : false,
label : lang.matchCase
},
{
type : 'checkbox',
id : 'txtFindWordChk',
isChanged : false,
label : lang.matchWord
},
{
type : 'checkbox',
id : 'txtFindCyclic',
isChanged : false,
'default' : true,
label : lang.matchCyclic
}
]
}
]
}
]
},
{
id : 'replace',
label : lang.replace,
accessKey : 'M',
elements : [
{
type : 'hbox',
widths : [ '230px', '90px' ],
children :
[
{
type : 'text',
id : 'txtFindReplace',
label : lang.findWhat,
isChanged : false,
labelLayout : 'horizontal',
accessKey : 'F'
},
{
type : 'button',
id : 'btnFindReplace',
align : 'left',
style : 'width:100%',
label : lang.replace,
onClick : function()
{
var dialog = this.getDialog();
if ( !finder.replace( dialog,
dialog.getValueOf( 'replace', 'txtFindReplace' ),
dialog.getValueOf( 'replace', 'txtReplace' ),
dialog.getValueOf( 'replace', 'txtReplaceCaseChk' ),
dialog.getValueOf( 'replace', 'txtReplaceWordChk' ),
dialog.getValueOf( 'replace', 'txtReplaceCyclic' ) ) )
alert( lang
.notFoundMsg );
}
}
]
},
{
type : 'hbox',
widths : [ '230px', '90px' ],
children :
[
{
type : 'text',
id : 'txtReplace',
label : lang.replaceWith,
isChanged : false,
labelLayout : 'horizontal',
accessKey : 'R'
},
{
type : 'button',
id : 'btnReplaceAll',
align : 'left',
style : 'width:100%',
label : lang.replaceAll,
isChanged : false,
onClick : function()
{
var dialog = this.getDialog();
var replaceNums;
finder.replaceCounter = 0;
// Scope to full document.
finder.searchRange = getSearchRange( 1 );
if ( finder.matchRange )
{
finder.matchRange.removeHighlight();
finder.matchRange = null;
}
editor.fire( 'saveSnapshot' );
while ( finder.replace( dialog,
dialog.getValueOf( 'replace', 'txtFindReplace' ),
dialog.getValueOf( 'replace', 'txtReplace' ),
dialog.getValueOf( 'replace', 'txtReplaceCaseChk' ),
dialog.getValueOf( 'replace', 'txtReplaceWordChk' ),
false, true ) )
{ /*jsl:pass*/ }
if ( finder.replaceCounter )
{
alert( lang.replaceSuccessMsg.replace( /%1/, finder.replaceCounter ) );
editor.fire( 'saveSnapshot' );
}
else
alert( lang.notFoundMsg );
}
}
]
},
{
type : 'fieldset',
label : CKEDITOR.tools.htmlEncode( lang.findOptions ),
children :
[
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'checkbox',
id : 'txtReplaceCaseChk',
isChanged : false,
label : lang.matchCase
},
{
type : 'checkbox',
id : 'txtReplaceWordChk',
isChanged : false,
label : lang.matchWord
},
{
type : 'checkbox',
id : 'txtReplaceCyclic',
isChanged : false,
'default' : true,
label : lang.matchCyclic
}
]
}
]
}
]
}
],
onLoad : function()
{
var dialog = this;
// Keep track of the current pattern field in use.
var patternField, wholeWordChkField;
// Ignore initial page select on dialog show
var isUserSelect = 0;
this.on( 'hide', function()
{
isUserSelect = 0;
});
this.on( 'show', function()
{
isUserSelect = 1;
});
this.selectPage = CKEDITOR.tools.override( this.selectPage, function( originalFunc )
{
return function( pageId )
{
originalFunc.call( dialog, pageId );
var currPage = dialog._.tabs[ pageId ];
var patternFieldInput, patternFieldId, wholeWordChkFieldId;
patternFieldId = pageId === 'find' ? 'txtFindFind' : 'txtFindReplace';
wholeWordChkFieldId = pageId === 'find' ? 'txtFindWordChk' : 'txtReplaceWordChk';
patternField = dialog.getContentElement( pageId,
patternFieldId );
wholeWordChkField = dialog.getContentElement( pageId,
wholeWordChkFieldId );
// Prepare for check pattern text filed 'keyup' event
if ( !currPage.initialized )
{
patternFieldInput = CKEDITOR.document
.getById( patternField._.inputId );
currPage.initialized = true;
}
// Synchronize fields on tab switch.
if ( isUserSelect )
syncFieldsBetweenTabs.call( this, pageId );
};
} );
},
onShow : function()
{
// Establish initial searching start position.
finder.searchRange = getSearchRange();
// Fill in the find field with selected text.
var selectedText = this.getParentEditor().getSelection().getSelectedText(),
patternFieldId = ( startupPage == 'find' ? 'txtFindFind' : 'txtFindReplace' );
var field = this.getContentElement( startupPage, patternFieldId );
field.setValue( selectedText );
field.select();
this.selectPage( startupPage );
this[ ( startupPage == 'find' && this._.editor.readOnly? 'hide' : 'show' ) + 'Page' ]( 'replace');
},
onHide : function()
{
var range;
if ( finder.matchRange && finder.matchRange.isMatched() )
{
finder.matchRange.removeHighlight();
editor.focus();
range = finder.matchRange.toDomRange();
if ( range )
editor.getSelection().selectRanges( [ range ] );
}
// Clear current session before dialog close
delete finder.matchRange;
},
onFocus : function()
{
if ( startupPage == 'replace' )
return this.getContentElement( 'replace', 'txtFindReplace' );
else
return this.getContentElement( 'find', 'txtFindFind' );
}
};
};
CKEDITOR.dialog.add( 'find', function( editor )
{
return findDialog( editor, 'find' );
});
CKEDITOR.dialog.add( 'replace', function( editor )
{
return findDialog( editor, 'replace' );
});
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'htmlwriter' );
/**
* Class used to write HTML data.
* @constructor
* @example
* var writer = new CKEDITOR.htmlWriter();
* writer.openTag( 'p' );
* writer.attribute( 'class', 'MyClass' );
* writer.openTagClose( 'p' );
* writer.text( 'Hello' );
* writer.closeTag( 'p' );
* alert( writer.getHtml() ); "<p class="MyClass">Hello</p>"
*/
CKEDITOR.htmlWriter = CKEDITOR.tools.createClass(
{
base : CKEDITOR.htmlParser.basicWriter,
$ : function()
{
// Call the base contructor.
this.base();
/**
* The characters to be used for each identation step.
* @type String
* @default "\t" (tab)
* @example
* // Use two spaces for indentation.
* editorInstance.dataProcessor.writer.indentationChars = ' ';
*/
this.indentationChars = '\t';
/**
* The characters to be used to close "self-closing" elements, like "br" or
* "img".
* @type String
* @default " />"
* @example
* // Use HTML4 notation for self-closing elements.
* editorInstance.dataProcessor.writer.selfClosingEnd = '>';
*/
this.selfClosingEnd = ' />';
/**
* The characters to be used for line breaks.
* @type String
* @default "\n" (LF)
* @example
* // Use CRLF for line breaks.
* editorInstance.dataProcessor.writer.lineBreakChars = '\r\n';
*/
this.lineBreakChars = '\n';
this.forceSimpleAmpersand = 0;
this.sortAttributes = 1;
this._.indent = 0;
this._.indentation = '';
// Indicate preformatted block context status. (#5789)
this._.inPre = 0;
this._.rules = {};
var dtd = CKEDITOR.dtd;
for ( var e in CKEDITOR.tools.extend( {}, dtd.$nonBodyContent, dtd.$block, dtd.$listItem, dtd.$tableContent ) )
{
this.setRules( e,
{
indent : 1,
breakBeforeOpen : 1,
breakAfterOpen : 1,
breakBeforeClose : !dtd[ e ][ '#' ],
breakAfterClose : 1
});
}
this.setRules( 'br',
{
breakAfterOpen : 1
});
this.setRules( 'title',
{
indent : 0,
breakAfterOpen : 0
});
this.setRules( 'style',
{
indent : 0,
breakBeforeClose : 1
});
// Disable indentation on <pre>.
this.setRules( 'pre',
{
indent : 0
});
},
proto :
{
/**
* Writes the tag opening part for a opener tag.
* @param {String} tagName The element name for this tag.
* @param {Object} attributes The attributes defined for this tag. The
* attributes could be used to inspect the tag.
* @example
* // Writes "<p".
* writer.openTag( 'p', { class : 'MyClass', id : 'MyId' } );
*/
openTag : function( tagName, attributes )
{
var rules = this._.rules[ tagName ];
if ( this._.indent )
this.indentation();
// Do not break if indenting.
else if ( rules && rules.breakBeforeOpen )
{
this.lineBreak();
this.indentation();
}
this._.output.push( '<', tagName );
},
/**
* Writes the tag closing part for a opener tag.
* @param {String} tagName The element name for this tag.
* @param {Boolean} isSelfClose Indicates that this is a self-closing tag,
* like "br" or "img".
* @example
* // Writes ">".
* writer.openTagClose( 'p', false );
* @example
* // Writes " />".
* writer.openTagClose( 'br', true );
*/
openTagClose : function( tagName, isSelfClose )
{
var rules = this._.rules[ tagName ];
if ( isSelfClose )
this._.output.push( this.selfClosingEnd );
else
{
this._.output.push( '>' );
if ( rules && rules.indent )
this._.indentation += this.indentationChars;
}
if ( rules && rules.breakAfterOpen )
this.lineBreak();
tagName == 'pre' && ( this._.inPre = 1 );
},
/**
* Writes an attribute. This function should be called after opening the
* tag with {@link #openTagClose}.
* @param {String} attName The attribute name.
* @param {String} attValue The attribute value.
* @example
* // Writes ' class="MyClass"'.
* writer.attribute( 'class', 'MyClass' );
*/
attribute : function( attName, attValue )
{
if ( typeof attValue == 'string' )
{
this.forceSimpleAmpersand && ( attValue = attValue.replace( /&/g, '&' ) );
// Browsers don't always escape special character in attribute values. (#4683, #4719).
attValue = CKEDITOR.tools.htmlEncodeAttr( attValue );
}
this._.output.push( ' ', attName, '="', attValue, '"' );
},
/**
* Writes a closer tag.
* @param {String} tagName The element name for this tag.
* @example
* // Writes "</p>".
* writer.closeTag( 'p' );
*/
closeTag : function( tagName )
{
var rules = this._.rules[ tagName ];
if ( rules && rules.indent )
this._.indentation = this._.indentation.substr( this.indentationChars.length );
if ( this._.indent )
this.indentation();
// Do not break if indenting.
else if ( rules && rules.breakBeforeClose )
{
this.lineBreak();
this.indentation();
}
this._.output.push( '</', tagName, '>' );
tagName == 'pre' && ( this._.inPre = 0 );
if ( rules && rules.breakAfterClose )
this.lineBreak();
},
/**
* Writes text.
* @param {String} text The text value
* @example
* // Writes "Hello Word".
* writer.text( 'Hello Word' );
*/
text : function( text )
{
if ( this._.indent )
{
this.indentation();
!this._.inPre && ( text = CKEDITOR.tools.ltrim( text ) );
}
this._.output.push( text );
},
/**
* Writes a comment.
* @param {String} comment The comment text.
* @example
* // Writes "<!-- My comment -->".
* writer.comment( ' My comment ' );
*/
comment : function( comment )
{
if ( this._.indent )
this.indentation();
this._.output.push( '<!--', comment, '-->' );
},
/**
* Writes a line break. It uses the {@link #lineBreakChars} property for it.
* @example
* // Writes "\n" (e.g.).
* writer.lineBreak();
*/
lineBreak : function()
{
if ( !this._.inPre && this._.output.length > 0 )
this._.output.push( this.lineBreakChars );
this._.indent = 1;
},
/**
* Writes the current indentation chars. It uses the
* {@link #indentationChars} property, repeating it for the current
* indentation steps.
* @example
* // Writes "\t" (e.g.).
* writer.indentation();
*/
indentation : function()
{
if( !this._.inPre )
this._.output.push( this._.indentation );
this._.indent = 0;
},
/**
* Sets formatting rules for a give element. The possible rules are:
* <ul>
* <li><b>indent</b>: indent the element contents.</li>
* <li><b>breakBeforeOpen</b>: break line before the opener tag for this element.</li>
* <li><b>breakAfterOpen</b>: break line after the opener tag for this element.</li>
* <li><b>breakBeforeClose</b>: break line before the closer tag for this element.</li>
* <li><b>breakAfterClose</b>: break line after the closer tag for this element.</li>
* </ul>
*
* All rules default to "false". Each call to the function overrides
* already present rules, leaving the undefined untouched.
*
* By default, all elements available in the {@link CKEDITOR.dtd.$block),
* {@link CKEDITOR.dtd.$listItem} and {@link CKEDITOR.dtd.$tableContent}
* lists have all the above rules set to "true". Additionaly, the "br"
* element has the "breakAfterOpen" set to "true".
* @param {String} tagName The element name to which set the rules.
* @param {Object} rules An object containing the element rules.
* @example
* // Break line before and after "img" tags.
* writer.setRules( 'img',
* {
* breakBeforeOpen : true
* breakAfterOpen : true
* });
* @example
* // Reset the rules for the "h1" tag.
* writer.setRules( 'h1', {} );
*/
setRules : function( tagName, rules )
{
var currentRules = this._.rules[ tagName ];
if ( currentRules )
CKEDITOR.tools.extend( currentRules, rules, true );
else
this._.rules[ tagName ] = rules;
}
}
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @fileOverview Undo/Redo system for saving shapshot for document modification
* and other recordable changes.
*/
(function()
{
CKEDITOR.plugins.add( 'undo',
{
requires : [ 'selection', 'wysiwygarea' ],
init : function( editor )
{
var undoManager = new UndoManager( editor );
var undoCommand = editor.addCommand( 'undo',
{
exec : function()
{
if ( undoManager.undo() )
{
editor.selectionChange();
this.fire( 'afterUndo' );
}
},
state : CKEDITOR.TRISTATE_DISABLED,
canUndo : false
});
var redoCommand = editor.addCommand( 'redo',
{
exec : function()
{
if ( undoManager.redo() )
{
editor.selectionChange();
this.fire( 'afterRedo' );
}
},
state : CKEDITOR.TRISTATE_DISABLED,
canUndo : false
});
undoManager.onChange = function()
{
undoCommand.setState( undoManager.undoable() ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
redoCommand.setState( undoManager.redoable() ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );
};
function recordCommand( event )
{
// If the command hasn't been marked to not support undo.
if ( undoManager.enabled && event.data.command.canUndo !== false )
undoManager.save();
}
// We'll save snapshots before and after executing a command.
editor.on( 'beforeCommandExec', recordCommand );
editor.on( 'afterCommandExec', recordCommand );
// Save snapshots before doing custom changes.
editor.on( 'saveSnapshot', function( evt )
{
undoManager.save( evt.data && evt.data.contentOnly );
});
// Registering keydown on every document recreation.(#3844)
editor.on( 'contentDom', function()
{
editor.document.on( 'keydown', function( event )
{
// Do not capture CTRL hotkeys.
if ( !event.data.$.ctrlKey && !event.data.$.metaKey )
undoManager.type( event );
});
});
// Always save an undo snapshot - the previous mode might have
// changed editor contents.
editor.on( 'beforeModeUnload', function()
{
editor.mode == 'wysiwyg' && undoManager.save( true );
});
// Make the undo manager available only in wysiwyg mode.
editor.on( 'mode', function()
{
undoManager.enabled = editor.readOnly ? false : editor.mode == 'wysiwyg';
undoManager.onChange();
});
editor.ui.addButton( 'Undo',
{
label : editor.lang.undo,
command : 'undo'
});
editor.ui.addButton( 'Redo',
{
label : editor.lang.redo,
command : 'redo'
});
editor.resetUndo = function()
{
// Reset the undo stack.
undoManager.reset();
// Create the first image.
editor.fire( 'saveSnapshot' );
};
/**
* Amend the top of undo stack (last undo image) with the current DOM changes.
* @name CKEDITOR.editor#updateUndo
* @example
* function()
* {
* editor.fire( 'saveSnapshot' );
* editor.document.body.append(...);
* // Make new changes following the last undo snapshot part of it.
* editor.fire( 'updateSnapshot' );
* ...
* }
*/
editor.on( 'updateSnapshot', function()
{
if ( undoManager.currentImage )
undoManager.update();
});
}
});
CKEDITOR.plugins.undo = {};
/**
* Undo snapshot which represents the current document status.
* @name CKEDITOR.plugins.undo.Image
* @param editor The editor instance on which the image is created.
*/
var Image = CKEDITOR.plugins.undo.Image = function( editor )
{
this.editor = editor;
editor.fire( 'beforeUndoImage' );
var contents = editor.getSnapshot(),
selection = contents && editor.getSelection();
// In IE, we need to remove the expando attributes.
CKEDITOR.env.ie && contents && ( contents = contents.replace( /\s+data-cke-expando=".*?"/g, '' ) );
this.contents = contents;
this.bookmarks = selection && selection.createBookmarks2( true );
editor.fire( 'afterUndoImage' );
};
// Attributes that browser may changing them when setting via innerHTML.
var protectedAttrs = /\b(?:href|src|name)="[^"]*?"/gi;
Image.prototype =
{
equals : function( otherImage, contentOnly )
{
var thisContents = this.contents,
otherContents = otherImage.contents;
// For IE6/7 : Comparing only the protected attribute values but not the original ones.(#4522)
if ( CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.ie6Compat ) )
{
thisContents = thisContents.replace( protectedAttrs, '' );
otherContents = otherContents.replace( protectedAttrs, '' );
}
if ( thisContents != otherContents )
return false;
if ( contentOnly )
return true;
var bookmarksA = this.bookmarks,
bookmarksB = otherImage.bookmarks;
if ( bookmarksA || bookmarksB )
{
if ( !bookmarksA || !bookmarksB || bookmarksA.length != bookmarksB.length )
return false;
for ( var i = 0 ; i < bookmarksA.length ; i++ )
{
var bookmarkA = bookmarksA[ i ],
bookmarkB = bookmarksB[ i ];
if (
bookmarkA.startOffset != bookmarkB.startOffset ||
bookmarkA.endOffset != bookmarkB.endOffset ||
!CKEDITOR.tools.arrayCompare( bookmarkA.start, bookmarkB.start ) ||
!CKEDITOR.tools.arrayCompare( bookmarkA.end, bookmarkB.end ) )
{
return false;
}
}
}
return true;
}
};
/**
* @constructor Main logic for Redo/Undo feature.
*/
function UndoManager( editor )
{
this.editor = editor;
// Reset the undo stack.
this.reset();
}
var editingKeyCodes = { /*Backspace*/ 8:1, /*Delete*/ 46:1 },
modifierKeyCodes = { /*Shift*/ 16:1, /*Ctrl*/ 17:1, /*Alt*/ 18:1 },
navigationKeyCodes = { 37:1, 38:1, 39:1, 40:1 }; // Arrows: L, T, R, B
UndoManager.prototype =
{
/**
* Process undo system regard keystrikes.
* @param {CKEDITOR.dom.event} event
*/
type : function( event )
{
var keystroke = event && event.data.getKey(),
isModifierKey = keystroke in modifierKeyCodes,
isEditingKey = keystroke in editingKeyCodes,
wasEditingKey = this.lastKeystroke in editingKeyCodes,
sameAsLastEditingKey = isEditingKey && keystroke == this.lastKeystroke,
// Keystrokes which navigation through contents.
isReset = keystroke in navigationKeyCodes,
wasReset = this.lastKeystroke in navigationKeyCodes,
// Keystrokes which just introduce new contents.
isContent = ( !isEditingKey && !isReset ),
// Create undo snap for every different modifier key.
modifierSnapshot = ( isEditingKey && !sameAsLastEditingKey ),
// Create undo snap on the following cases:
// 1. Just start to type .
// 2. Typing some content after a modifier.
// 3. Typing some content after make a visible selection.
startedTyping = !( isModifierKey || this.typing )
|| ( isContent && ( wasEditingKey || wasReset ) );
if ( startedTyping || modifierSnapshot )
{
var beforeTypeImage = new Image( this.editor ),
beforeTypeCount = this.snapshots.length;
// Use setTimeout, so we give the necessary time to the
// browser to insert the character into the DOM.
CKEDITOR.tools.setTimeout( function()
{
var currentSnapshot = this.editor.getSnapshot();
// In IE, we need to remove the expando attributes.
if ( CKEDITOR.env.ie )
currentSnapshot = currentSnapshot.replace( /\s+data-cke-expando=".*?"/g, '' );
// If changes have taken place, while not been captured yet (#8459),
// compensate the snapshot.
if ( beforeTypeImage.contents != currentSnapshot &&
beforeTypeCount == this.snapshots.length )
{
// It's safe to now indicate typing state.
this.typing = true;
// This's a special save, with specified snapshot
// and without auto 'fireChange'.
if ( !this.save( false, beforeTypeImage, false ) )
// Drop future snapshots.
this.snapshots.splice( this.index + 1, this.snapshots.length - this.index - 1 );
this.hasUndo = true;
this.hasRedo = false;
this.typesCount = 1;
this.modifiersCount = 1;
this.onChange();
}
},
0, this
);
}
this.lastKeystroke = keystroke;
// Create undo snap after typed too much (over 25 times).
if ( isEditingKey )
{
this.typesCount = 0;
this.modifiersCount++;
if ( this.modifiersCount > 25 )
{
this.save( false, null, false );
this.modifiersCount = 1;
}
}
else if ( !isReset )
{
this.modifiersCount = 0;
this.typesCount++;
if ( this.typesCount > 25 )
{
this.save( false, null, false );
this.typesCount = 1;
}
}
},
reset : function() // Reset the undo stack.
{
/**
* Remember last pressed key.
*/
this.lastKeystroke = 0;
/**
* Stack for all the undo and redo snapshots, they're always created/removed
* in consistency.
*/
this.snapshots = [];
/**
* Current snapshot history index.
*/
this.index = -1;
this.limit = this.editor.config.undoStackSize || 20;
this.currentImage = null;
this.hasUndo = false;
this.hasRedo = false;
this.resetType();
},
/**
* Reset all states about typing.
* @see UndoManager.type
*/
resetType : function()
{
this.typing = false;
delete this.lastKeystroke;
this.typesCount = 0;
this.modifiersCount = 0;
},
fireChange : function()
{
this.hasUndo = !!this.getNextImage( true );
this.hasRedo = !!this.getNextImage( false );
// Reset typing
this.resetType();
this.onChange();
},
/**
* Save a snapshot of document image for later retrieve.
*/
save : function( onContentOnly, image, autoFireChange )
{
var snapshots = this.snapshots;
// Get a content image.
if ( !image )
image = new Image( this.editor );
// Do nothing if it was not possible to retrieve an image.
if ( image.contents === false )
return false;
// Check if this is a duplicate. In such case, do nothing.
if ( this.currentImage && image.equals( this.currentImage, onContentOnly ) )
return false;
// Drop future snapshots.
snapshots.splice( this.index + 1, snapshots.length - this.index - 1 );
// If we have reached the limit, remove the oldest one.
if ( snapshots.length == this.limit )
snapshots.shift();
// Add the new image, updating the current index.
this.index = snapshots.push( image ) - 1;
this.currentImage = image;
if ( autoFireChange !== false )
this.fireChange();
return true;
},
restoreImage : function( image )
{
// Bring editor focused to restore selection.
var editor = this.editor,
sel;
if ( image.bookmarks )
{
editor.focus();
// Retrieve the selection beforehand. (#8324)
sel = editor.getSelection();
}
this.editor.loadSnapshot( image.contents );
if ( image.bookmarks )
sel.selectBookmarks( image.bookmarks );
else if ( CKEDITOR.env.ie )
{
// IE BUG: If I don't set the selection to *somewhere* after setting
// document contents, then IE would create an empty paragraph at the bottom
// the next time the document is modified.
var $range = this.editor.document.getBody().$.createTextRange();
$range.collapse( true );
$range.select();
}
this.index = image.index;
// Update current image with the actual editor
// content, since actualy content may differ from
// the original snapshot due to dom change. (#4622)
this.update();
this.fireChange();
},
// Get the closest available image.
getNextImage : function( isUndo )
{
var snapshots = this.snapshots,
currentImage = this.currentImage,
image, i;
if ( currentImage )
{
if ( isUndo )
{
for ( i = this.index - 1 ; i >= 0 ; i-- )
{
image = snapshots[ i ];
if ( !currentImage.equals( image, true ) )
{
image.index = i;
return image;
}
}
}
else
{
for ( i = this.index + 1 ; i < snapshots.length ; i++ )
{
image = snapshots[ i ];
if ( !currentImage.equals( image, true ) )
{
image.index = i;
return image;
}
}
}
}
return null;
},
/**
* Check the current redo state.
* @return {Boolean} Whether the document has previous state to
* retrieve.
*/
redoable : function()
{
return this.enabled && this.hasRedo;
},
/**
* Check the current undo state.
* @return {Boolean} Whether the document has future state to restore.
*/
undoable : function()
{
return this.enabled && this.hasUndo;
},
/**
* Perform undo on current index.
*/
undo : function()
{
if ( this.undoable() )
{
this.save( true );
var image = this.getNextImage( true );
if ( image )
return this.restoreImage( image ), true;
}
return false;
},
/**
* Perform redo on current index.
*/
redo : function()
{
if ( this.redoable() )
{
// Try to save. If no changes have been made, the redo stack
// will not change, so it will still be redoable.
this.save( true );
// If instead we had changes, we can't redo anymore.
if ( this.redoable() )
{
var image = this.getNextImage( false );
if ( image )
return this.restoreImage( image ), true;
}
}
return false;
},
/**
* Update the last snapshot of the undo stack with the current editor content.
*/
update : function()
{
this.snapshots.splice( this.index, 1, ( this.currentImage = new Image( this.editor ) ) );
}
};
})();
/**
* The number of undo steps to be saved. The higher this setting value the more
* memory is used for it.
* @name CKEDITOR.config.undoStackSize
* @type Number
* @default 20
* @example
* config.undoStackSize = 50;
*/
/**
* Fired when the editor is about to save an undo snapshot. This event can be
* fired by plugins and customizations to make the editor saving undo snapshots.
* @name CKEDITOR.editor#saveSnapshot
* @event
*/
/**
* Fired before an undo image is to be taken. An undo image represents the
* editor state at some point. It's saved into an undo store, so the editor is
* able to recover the editor state on undo and redo operations.
* @name CKEDITOR.editor#beforeUndoImage
* @since 3.5.3
* @see CKEDITOR.editor#afterUndoImage
* @event
*/
/**
* Fired after an undo image is taken. An undo image represents the
* editor state at some point. It's saved into an undo store, so the editor is
* able to recover the editor state on undo and redo operations.
* @name CKEDITOR.editor#afterUndoImage
* @since 3.5.3
* @see CKEDITOR.editor#beforeUndoImage
* @event
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Forms Plugin
*/
CKEDITOR.plugins.add( 'forms',
{
requires : [ 'dialog' ],
init : function( editor )
{
var lang = editor.lang;
editor.addCss(
'form' +
'{' +
'border: 1px dotted #FF0000;' +
'padding: 2px;' +
'}\n' );
editor.addCss(
'img.cke_hidden' +
'{' +
'background-image: url(' + CKEDITOR.getUrl( this.path + 'images/hiddenfield.gif' ) + ');' +
'background-position: center center;' +
'background-repeat: no-repeat;' +
'border: 1px solid #a9a9a9;' +
'width: 16px !important;' +
'height: 16px !important;' +
'}' );
// All buttons use the same code to register. So, to avoid
// duplications, let's use this tool function.
var addButtonCommand = function( buttonName, commandName, dialogFile )
{
editor.addCommand( commandName, new CKEDITOR.dialogCommand( commandName ) );
editor.ui.addButton( buttonName,
{
label : lang.common[ buttonName.charAt(0).toLowerCase() + buttonName.slice(1) ],
command : commandName
});
CKEDITOR.dialog.add( commandName, dialogFile );
};
var dialogPath = this.path + 'dialogs/';
addButtonCommand( 'Form', 'form', dialogPath + 'form.js' );
addButtonCommand( 'Checkbox', 'checkbox', dialogPath + 'checkbox.js' );
addButtonCommand( 'Radio', 'radio', dialogPath + 'radio.js' );
addButtonCommand( 'TextField', 'textfield', dialogPath + 'textfield.js' );
addButtonCommand( 'Textarea', 'textarea', dialogPath + 'textarea.js' );
addButtonCommand( 'Select', 'select', dialogPath + 'select.js' );
addButtonCommand( 'Button', 'button', dialogPath + 'button.js' );
addButtonCommand( 'ImageButton', 'imagebutton', CKEDITOR.plugins.getPath('image') + 'dialogs/image.js' );
addButtonCommand( 'HiddenField', 'hiddenfield', dialogPath + 'hiddenfield.js' );
// If the "menu" plugin is loaded, register the menu items.
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
form :
{
label : lang.form.menu,
command : 'form',
group : 'form'
},
checkbox :
{
label : lang.checkboxAndRadio.checkboxTitle,
command : 'checkbox',
group : 'checkbox'
},
radio :
{
label : lang.checkboxAndRadio.radioTitle,
command : 'radio',
group : 'radio'
},
textfield :
{
label : lang.textfield.title,
command : 'textfield',
group : 'textfield'
},
hiddenfield :
{
label : lang.hidden.title,
command : 'hiddenfield',
group : 'hiddenfield'
},
imagebutton :
{
label : lang.image.titleButton,
command : 'imagebutton',
group : 'imagebutton'
},
button :
{
label : lang.button.title,
command : 'button',
group : 'button'
},
select :
{
label : lang.select.title,
command : 'select',
group : 'select'
},
textarea :
{
label : lang.textarea.title,
command : 'textarea',
group : 'textarea'
}
});
}
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element )
{
if ( element && element.hasAscendant( 'form', true ) && !element.isReadOnly() )
return { form : CKEDITOR.TRISTATE_OFF };
});
editor.contextMenu.addListener( function( element )
{
if ( element && !element.isReadOnly() )
{
var name = element.getName();
if ( name == 'select' )
return { select : CKEDITOR.TRISTATE_OFF };
if ( name == 'textarea' )
return { textarea : CKEDITOR.TRISTATE_OFF };
if ( name == 'input' )
{
switch( element.getAttribute( 'type' ) )
{
case 'button' :
case 'submit' :
case 'reset' :
return { button : CKEDITOR.TRISTATE_OFF };
case 'checkbox' :
return { checkbox : CKEDITOR.TRISTATE_OFF };
case 'radio' :
return { radio : CKEDITOR.TRISTATE_OFF };
case 'image' :
return { imagebutton : CKEDITOR.TRISTATE_OFF };
default :
return { textfield : CKEDITOR.TRISTATE_OFF };
}
}
if ( name == 'img' && element.data( 'cke-real-element-type' ) == 'hiddenfield' )
return { hiddenfield : CKEDITOR.TRISTATE_OFF };
}
});
}
editor.on( 'doubleclick', function( evt )
{
var element = evt.data.element;
if ( element.is( 'form' ) )
evt.data.dialog = 'form';
else if ( element.is( 'select' ) )
evt.data.dialog = 'select';
else if ( element.is( 'textarea' ) )
evt.data.dialog = 'textarea';
else if ( element.is( 'img' ) && element.data( 'cke-real-element-type' ) == 'hiddenfield' )
evt.data.dialog = 'hiddenfield';
else if ( element.is( 'input' ) )
{
switch ( element.getAttribute( 'type' ) )
{
case 'button' :
case 'submit' :
case 'reset' :
evt.data.dialog = 'button';
break;
case 'checkbox' :
evt.data.dialog = 'checkbox';
break;
case 'radio' :
evt.data.dialog = 'radio';
break;
case 'image' :
evt.data.dialog = 'imagebutton';
break;
default :
evt.data.dialog = 'textfield';
break;
}
}
});
},
afterInit : function( editor )
{
var dataProcessor = editor.dataProcessor,
htmlFilter = dataProcessor && dataProcessor.htmlFilter,
dataFilter = dataProcessor && dataProcessor.dataFilter;
// Cleanup certain IE form elements default values.
if ( CKEDITOR.env.ie )
{
htmlFilter && htmlFilter.addRules(
{
elements :
{
input : function( input )
{
var attrs = input.attributes,
type = attrs.type;
// Old IEs don't provide type for Text inputs #5522
if ( !type )
attrs.type = 'text';
if ( type == 'checkbox' || type == 'radio' )
attrs.value == 'on' && delete attrs.value;
}
}
} );
}
if ( dataFilter )
{
dataFilter.addRules(
{
elements :
{
input : function( element )
{
if ( element.attributes.type == 'hidden' )
return editor.createFakeParserElement( element, 'cke_hidden', 'hiddenfield' );
}
}
} );
}
},
requires : [ 'image', 'fakeobjects' ]
} );
if ( CKEDITOR.env.ie )
{
CKEDITOR.dom.element.prototype.hasAttribute = CKEDITOR.tools.override( CKEDITOR.dom.element.prototype.hasAttribute,
function( original )
{
return function( name )
{
var $attr = this.$.attributes.getNamedItem( name );
if ( this.getName() == 'input' )
{
switch ( name )
{
case 'class' :
return this.$.className.length > 0;
case 'checked' :
return !!this.$.checked;
case 'value' :
var type = this.getAttribute( 'type' );
return type == 'checkbox' || type == 'radio' ? this.$.value != 'on' : this.$.value;
}
}
return original.apply( this, arguments );
};
});
}
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'select', function( editor )
{
// Add a new option to a SELECT object (combo or list).
function addOption( combo, optionText, optionValue, documentObject, index )
{
combo = getSelect( combo );
var oOption;
if ( documentObject )
oOption = documentObject.createElement( "OPTION" );
else
oOption = document.createElement( "OPTION" );
if ( combo && oOption && oOption.getName() == 'option' )
{
if ( CKEDITOR.env.ie ) {
if ( !isNaN( parseInt( index, 10) ) )
combo.$.options.add( oOption.$, index );
else
combo.$.options.add( oOption.$ );
oOption.$.innerHTML = optionText.length > 0 ? optionText : '';
oOption.$.value = optionValue;
}
else
{
if ( index !== null && index < combo.getChildCount() )
combo.getChild( index < 0 ? 0 : index ).insertBeforeMe( oOption );
else
combo.append( oOption );
oOption.setText( optionText.length > 0 ? optionText : '' );
oOption.setValue( optionValue );
}
}
else
return false;
return oOption;
}
// Remove all selected options from a SELECT object.
function removeSelectedOptions( combo )
{
combo = getSelect( combo );
// Save the selected index
var iSelectedIndex = getSelectedIndex( combo );
// Remove all selected options.
for ( var i = combo.getChildren().count() - 1 ; i >= 0 ; i-- )
{
if ( combo.getChild( i ).$.selected )
combo.getChild( i ).remove();
}
// Reset the selection based on the original selected index.
setSelectedIndex( combo, iSelectedIndex );
}
//Modify option from a SELECT object.
function modifyOption( combo, index, title, value )
{
combo = getSelect( combo );
if ( index < 0 )
return false;
var child = combo.getChild( index );
child.setText( title );
child.setValue( value );
return child;
}
function removeAllOptions( combo )
{
combo = getSelect( combo );
while ( combo.getChild( 0 ) && combo.getChild( 0 ).remove() )
{ /*jsl:pass*/ }
}
// Moves the selected option by a number of steps (also negative).
function changeOptionPosition( combo, steps, documentObject )
{
combo = getSelect( combo );
var iActualIndex = getSelectedIndex( combo );
if ( iActualIndex < 0 )
return false;
var iFinalIndex = iActualIndex + steps;
iFinalIndex = ( iFinalIndex < 0 ) ? 0 : iFinalIndex;
iFinalIndex = ( iFinalIndex >= combo.getChildCount() ) ? combo.getChildCount() - 1 : iFinalIndex;
if ( iActualIndex == iFinalIndex )
return false;
var oOption = combo.getChild( iActualIndex ),
sText = oOption.getText(),
sValue = oOption.getValue();
oOption.remove();
oOption = addOption( combo, sText, sValue, ( !documentObject ) ? null : documentObject, iFinalIndex );
setSelectedIndex( combo, iFinalIndex );
return oOption;
}
function getSelectedIndex( combo )
{
combo = getSelect( combo );
return combo ? combo.$.selectedIndex : -1;
}
function setSelectedIndex( combo, index )
{
combo = getSelect( combo );
if ( index < 0 )
return null;
var count = combo.getChildren().count();
combo.$.selectedIndex = ( index >= count ) ? ( count - 1 ) : index;
return combo;
}
function getOptions( combo )
{
combo = getSelect( combo );
return combo ? combo.getChildren() : false;
}
function getSelect( obj )
{
if ( obj && obj.domId && obj.getInputElement().$ ) // Dialog element.
return obj.getInputElement();
else if ( obj && obj.$ )
return obj;
return false;
}
return {
title : editor.lang.select.title,
minWidth : CKEDITOR.env.ie ? 460 : 395,
minHeight : CKEDITOR.env.ie ? 320 : 300,
onShow : function()
{
delete this.selectBox;
this.setupContent( 'clear' );
var element = this.getParentEditor().getSelection().getSelectedElement();
if ( element && element.getName() == "select" )
{
this.selectBox = element;
this.setupContent( element.getName(), element );
// Load Options into dialog.
var objOptions = getOptions( element );
for ( var i = 0 ; i < objOptions.count() ; i++ )
this.setupContent( 'option', objOptions.getItem( i ) );
}
},
onOk : function()
{
var editor = this.getParentEditor(),
element = this.selectBox,
isInsertMode = !element;
if ( isInsertMode )
element = editor.document.createElement( 'select' );
this.commitContent( element );
if ( isInsertMode )
{
editor.insertElement( element );
if ( CKEDITOR.env.ie )
{
var sel = editor.getSelection(),
bms = sel.createBookmarks();
setTimeout(function()
{
sel.selectBookmarks( bms );
}, 0 );
}
}
},
contents : [
{
id : 'info',
label : editor.lang.select.selectInfo,
title : editor.lang.select.selectInfo,
accessKey : '',
elements : [
{
id : 'txtName',
type : 'text',
widths : [ '25%','75%' ],
labelLayout : 'horizontal',
label : editor.lang.common.name,
'default' : '',
accessKey : 'N',
style : 'width:350px',
setup : function( name, element )
{
if ( name == 'clear' )
this.setValue( this[ 'default' ] || '' );
else if ( name == 'select' )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
}
},
commit : function( element )
{
if ( this.getValue() )
element.data( 'cke-saved-name', this.getValue() );
else
{
element.data( 'cke-saved-name', false );
element.removeAttribute( 'name' );
}
}
},
{
id : 'txtValue',
type : 'text',
widths : [ '25%','75%' ],
labelLayout : 'horizontal',
label : editor.lang.select.value,
style : 'width:350px',
'default' : '',
className : 'cke_disabled',
onLoad : function()
{
this.getInputElement().setAttribute( 'readOnly', true );
},
setup : function( name, element )
{
if ( name == 'clear' )
this.setValue( '' );
else if ( name == 'option' && element.getAttribute( 'selected' ) )
this.setValue( element.$.value );
}
},
{
type : 'hbox',
widths : [ '175px', '170px' ],
children :
[
{
id : 'txtSize',
type : 'text',
labelLayout : 'horizontal',
label : editor.lang.select.size,
'default' : '',
accessKey : 'S',
style : 'width:175px',
validate: function()
{
var func = CKEDITOR.dialog.validate.integer( editor.lang.common.validateNumberFailed );
return ( ( this.getValue() === '' ) || func.apply( this ) );
},
setup : function( name, element )
{
if ( name == 'select' )
this.setValue( element.getAttribute( 'size' ) || '' );
if ( CKEDITOR.env.webkit )
this.getInputElement().setStyle( 'width', '86px' );
},
commit : function( element )
{
if ( this.getValue() )
element.setAttribute( 'size', this.getValue() );
else
element.removeAttribute( 'size' );
}
},
{
type : 'html',
html : '<span>' + CKEDITOR.tools.htmlEncode( editor.lang.select.lines ) + '</span>'
}
]
},
{
type : 'html',
html : '<span>' + CKEDITOR.tools.htmlEncode( editor.lang.select.opAvail ) + '</span>'
},
{
type : 'hbox',
widths : [ '115px', '115px' ,'100px' ],
children :
[
{
type : 'vbox',
children :
[
{
id : 'txtOptName',
type : 'text',
label : editor.lang.select.opText,
style : 'width:115px',
setup : function( name, element )
{
if ( name == 'clear' )
this.setValue( "" );
}
},
{
type : 'select',
id : 'cmbName',
label : '',
title : '',
size : 5,
style : 'width:115px;height:75px',
items : [],
onChange : function()
{
var dialog = this.getDialog(),
values = dialog.getContentElement( 'info', 'cmbValue' ),
optName = dialog.getContentElement( 'info', 'txtOptName' ),
optValue = dialog.getContentElement( 'info', 'txtOptValue' ),
iIndex = getSelectedIndex( this );
setSelectedIndex( values, iIndex );
optName.setValue( this.getValue() );
optValue.setValue( values.getValue() );
},
setup : function( name, element )
{
if ( name == 'clear' )
removeAllOptions( this );
else if ( name == 'option' )
addOption( this, element.getText(), element.getText(),
this.getDialog().getParentEditor().document );
},
commit : function( element )
{
var dialog = this.getDialog(),
optionsNames = getOptions( this ),
optionsValues = getOptions( dialog.getContentElement( 'info', 'cmbValue' ) ),
selectValue = dialog.getContentElement( 'info', 'txtValue' ).getValue();
removeAllOptions( element );
for ( var i = 0 ; i < optionsNames.count() ; i++ )
{
var oOption = addOption( element, optionsNames.getItem( i ).getValue(),
optionsValues.getItem( i ).getValue(), dialog.getParentEditor().document );
if ( optionsValues.getItem( i ).getValue() == selectValue )
{
oOption.setAttribute( 'selected', 'selected' );
oOption.selected = true;
}
}
}
}
]
},
{
type : 'vbox',
children :
[
{
id : 'txtOptValue',
type : 'text',
label : editor.lang.select.opValue,
style : 'width:115px',
setup : function( name, element )
{
if ( name == 'clear' )
this.setValue( "" );
}
},
{
type : 'select',
id : 'cmbValue',
label : '',
size : 5,
style : 'width:115px;height:75px',
items : [],
onChange : function()
{
var dialog = this.getDialog(),
names = dialog.getContentElement( 'info', 'cmbName' ),
optName = dialog.getContentElement( 'info', 'txtOptName' ),
optValue = dialog.getContentElement( 'info', 'txtOptValue' ),
iIndex = getSelectedIndex( this );
setSelectedIndex( names, iIndex );
optName.setValue( names.getValue() );
optValue.setValue( this.getValue() );
},
setup : function( name, element )
{
if ( name == 'clear' )
removeAllOptions( this );
else if ( name == 'option' )
{
var oValue = element.getValue();
addOption( this, oValue, oValue,
this.getDialog().getParentEditor().document );
if ( element.getAttribute( 'selected' ) == 'selected' )
this.getDialog().getContentElement( 'info', 'txtValue' ).setValue( oValue );
}
}
}
]
},
{
type : 'vbox',
padding : 5,
children :
[
{
type : 'button',
id : 'btnAdd',
style : '',
label : editor.lang.select.btnAdd,
title : editor.lang.select.btnAdd,
style : 'width:100%;',
onClick : function()
{
//Add new option.
var dialog = this.getDialog(),
parentEditor = dialog.getParentEditor(),
optName = dialog.getContentElement( 'info', 'txtOptName' ),
optValue = dialog.getContentElement( 'info', 'txtOptValue' ),
names = dialog.getContentElement( 'info', 'cmbName' ),
values = dialog.getContentElement( 'info', 'cmbValue' );
addOption(names, optName.getValue(), optName.getValue(), dialog.getParentEditor().document );
addOption(values, optValue.getValue(), optValue.getValue(), dialog.getParentEditor().document );
optName.setValue( "" );
optValue.setValue( "" );
}
},
{
type : 'button',
id : 'btnModify',
label : editor.lang.select.btnModify,
title : editor.lang.select.btnModify,
style : 'width:100%;',
onClick : function()
{
//Modify selected option.
var dialog = this.getDialog(),
optName = dialog.getContentElement( 'info', 'txtOptName' ),
optValue = dialog.getContentElement( 'info', 'txtOptValue' ),
names = dialog.getContentElement( 'info', 'cmbName' ),
values = dialog.getContentElement( 'info', 'cmbValue' ),
iIndex = getSelectedIndex( names );
if ( iIndex >= 0 )
{
modifyOption( names, iIndex, optName.getValue(), optName.getValue() );
modifyOption( values, iIndex, optValue.getValue(), optValue.getValue() );
}
}
},
{
type : 'button',
id : 'btnUp',
style : 'width:100%;',
label : editor.lang.select.btnUp,
title : editor.lang.select.btnUp,
onClick : function()
{
//Move up.
var dialog = this.getDialog(),
names = dialog.getContentElement( 'info', 'cmbName' ),
values = dialog.getContentElement( 'info', 'cmbValue' );
changeOptionPosition( names, -1, dialog.getParentEditor().document );
changeOptionPosition( values, -1, dialog.getParentEditor().document );
}
},
{
type : 'button',
id : 'btnDown',
style : 'width:100%;',
label : editor.lang.select.btnDown,
title : editor.lang.select.btnDown,
onClick : function()
{
//Move down.
var dialog = this.getDialog(),
names = dialog.getContentElement( 'info', 'cmbName' ),
values = dialog.getContentElement( 'info', 'cmbValue' );
changeOptionPosition( names, 1, dialog.getParentEditor().document );
changeOptionPosition( values, 1, dialog.getParentEditor().document );
}
}
]
}
]
},
{
type : 'hbox',
widths : [ '40%', '20%', '40%' ],
children :
[
{
type : 'button',
id : 'btnSetValue',
label : editor.lang.select.btnSetValue,
title : editor.lang.select.btnSetValue,
onClick : function()
{
//Set as default value.
var dialog = this.getDialog(),
values = dialog.getContentElement( 'info', 'cmbValue' ),
txtValue = dialog.getContentElement( 'info', 'txtValue' );
txtValue.setValue( values.getValue() );
}
},
{
type : 'button',
id : 'btnDelete',
label : editor.lang.select.btnDelete,
title : editor.lang.select.btnDelete,
onClick : function()
{
// Delete option.
var dialog = this.getDialog(),
names = dialog.getContentElement( 'info', 'cmbName' ),
values = dialog.getContentElement( 'info', 'cmbValue' ),
optName = dialog.getContentElement( 'info', 'txtOptName' ),
optValue = dialog.getContentElement( 'info', 'txtOptValue' );
removeSelectedOptions( names );
removeSelectedOptions( values );
optName.setValue( "" );
optValue.setValue( "" );
}
},
{
id : 'chkMulti',
type : 'checkbox',
label : editor.lang.select.chkMulti,
'default' : '',
accessKey : 'M',
value : "checked",
setup : function( name, element )
{
if ( name == 'select' )
this.setValue( element.getAttribute( 'multiple' ) );
if ( CKEDITOR.env.webkit )
this.getElement().getParent().setStyle( 'vertical-align', 'middle' );
},
commit : function( element )
{
if ( this.getValue() )
element.setAttribute( 'multiple', this.getValue() );
else
element.removeAttribute( 'multiple' );
}
}
]
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'textfield', function( editor )
{
var autoAttributes =
{
value : 1,
size : 1,
maxLength : 1
};
var acceptedTypes =
{
text : 1,
password : 1
};
return {
title : editor.lang.textfield.title,
minWidth : 350,
minHeight : 150,
onShow : function()
{
delete this.textField;
var element = this.getParentEditor().getSelection().getSelectedElement();
if ( element && element.getName() == "input" &&
( acceptedTypes[ element.getAttribute( 'type' ) ] || !element.getAttribute( 'type' ) ) )
{
this.textField = element;
this.setupContent( element );
}
},
onOk : function()
{
var editor,
element = this.textField,
isInsertMode = !element;
if ( isInsertMode )
{
editor = this.getParentEditor();
element = editor.document.createElement( 'input' );
element.setAttribute( 'type', 'text' );
}
if ( isInsertMode )
editor.insertElement( element );
this.commitContent( { element : element } );
},
onLoad : function()
{
var autoSetup = function( element )
{
var value = element.hasAttribute( this.id ) && element.getAttribute( this.id );
this.setValue( value || '' );
};
var autoCommit = function( data )
{
var element = data.element;
var value = this.getValue();
if ( value )
element.setAttribute( this.id, value );
else
element.removeAttribute( this.id );
};
this.foreach( function( contentObj )
{
if ( autoAttributes[ contentObj.id ] )
{
contentObj.setup = autoSetup;
contentObj.commit = autoCommit;
}
} );
},
contents : [
{
id : 'info',
label : editor.lang.textfield.title,
title : editor.lang.textfield.title,
elements : [
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
id : '_cke_saved_name',
type : 'text',
label : editor.lang.textfield.name,
'default' : '',
accessKey : 'N',
setup : function( element )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : function( data )
{
var element = data.element;
if ( this.getValue() )
element.data( 'cke-saved-name', this.getValue() );
else
{
element.data( 'cke-saved-name', false );
element.removeAttribute( 'name' );
}
}
},
{
id : 'value',
type : 'text',
label : editor.lang.textfield.value,
'default' : '',
accessKey : 'V'
}
]
},
{
type : 'hbox',
widths : [ '50%', '50%' ],
children :
[
{
id : 'size',
type : 'text',
label : editor.lang.textfield.charWidth,
'default' : '',
accessKey : 'C',
style : 'width:50px',
validate : CKEDITOR.dialog.validate.integer( editor.lang.common.validateNumberFailed )
},
{
id : 'maxLength',
type : 'text',
label : editor.lang.textfield.maxChars,
'default' : '',
accessKey : 'M',
style : 'width:50px',
validate : CKEDITOR.dialog.validate.integer( editor.lang.common.validateNumberFailed )
}
],
onLoad : function()
{
// Repaint the style for IE7 (#6068)
if ( CKEDITOR.env.ie7Compat )
this.getElement().setStyle( 'zoom', '100%' );
}
},
{
id : 'type',
type : 'select',
label : editor.lang.textfield.type,
'default' : 'text',
accessKey : 'M',
items :
[
[ editor.lang.textfield.typeText, 'text' ],
[ editor.lang.textfield.typePass, 'password' ]
],
setup : function( element )
{
this.setValue( element.getAttribute( 'type' ) );
},
commit : function( data )
{
var element = data.element;
if ( CKEDITOR.env.ie )
{
var elementType = element.getAttribute( 'type' );
var myType = this.getValue();
if ( elementType != myType )
{
var replace = CKEDITOR.dom.element.createFromHtml( '<input type="' + myType + '"></input>', editor.document );
element.copyAttributes( replace, { type : 1 } );
replace.replace( element );
editor.getSelection().selectElement( replace );
data.element = replace;
}
}
else
element.setAttribute( 'type', this.getValue() );
}
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'hiddenfield', function( editor )
{
return {
title : editor.lang.hidden.title,
hiddenField : null,
minWidth : 350,
minHeight : 110,
onShow : function()
{
delete this.hiddenField;
var editor = this.getParentEditor(),
selection = editor.getSelection(),
element = selection.getSelectedElement();
if ( element && element.data( 'cke-real-element-type' ) && element.data( 'cke-real-element-type' ) == 'hiddenfield' )
{
this.hiddenField = element;
element = editor.restoreRealElement( this.hiddenField );
this.setupContent( element );
selection.selectElement( this.hiddenField );
}
},
onOk : function()
{
var name = this.getValueOf( 'info', '_cke_saved_name' ),
value = this.getValueOf( 'info', 'value' ),
editor = this.getParentEditor(),
element = CKEDITOR.env.ie && !( CKEDITOR.document.$.documentMode >= 8 ) ?
editor.document.createElement( '<input name="' + CKEDITOR.tools.htmlEncode( name ) + '">' )
: editor.document.createElement( 'input' );
element.setAttribute( 'type', 'hidden' );
this.commitContent( element );
var fakeElement = editor.createFakeElement( element, 'cke_hidden', 'hiddenfield' );
if ( !this.hiddenField )
editor.insertElement( fakeElement );
else
{
fakeElement.replace( this.hiddenField );
editor.getSelection().selectElement( fakeElement );
}
return true;
},
contents : [
{
id : 'info',
label : editor.lang.hidden.title,
title : editor.lang.hidden.title,
elements : [
{
id : '_cke_saved_name',
type : 'text',
label : editor.lang.hidden.name,
'default' : '',
accessKey : 'N',
setup : function( element )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : function( element )
{
if ( this.getValue() )
element.setAttribute( 'name', this.getValue() );
else
{
element.removeAttribute( 'name' );
}
}
},
{
id : 'value',
type : 'text',
label : editor.lang.hidden.value,
'default' : '',
accessKey : 'V',
setup : function( element )
{
this.setValue( element.getAttribute( 'value' ) || '' );
},
commit : function( element )
{
if ( this.getValue() )
element.setAttribute( 'value', this.getValue() );
else
element.removeAttribute( 'value' );
}
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'button', function( editor )
{
function commitAttributes( element )
{
var val = this.getValue();
if ( val )
{
element.attributes[ this.id ] = val;
if ( this.id == 'name' )
element.attributes[ 'data-cke-saved-name' ] = val;
}
else
{
delete element.attributes[ this.id ];
if ( this.id == 'name' )
delete element.attributes[ 'data-cke-saved-name' ];
}
}
return {
title : editor.lang.button.title,
minWidth : 350,
minHeight : 150,
onShow : function()
{
delete this.button;
var element = this.getParentEditor().getSelection().getSelectedElement();
if ( element && element.is( 'input' ) )
{
var type = element.getAttribute( 'type' );
if ( type in { button:1, reset:1, submit:1 } )
{
this.button = element;
this.setupContent( element );
}
}
},
onOk : function()
{
var editor = this.getParentEditor(),
element = this.button,
isInsertMode = !element;
var fake = element ? CKEDITOR.htmlParser.fragment.fromHtml( element.getOuterHtml() ).children[ 0 ]
: new CKEDITOR.htmlParser.element( 'input' );
this.commitContent( fake );
var writer = new CKEDITOR.htmlParser.basicWriter();
fake.writeHtml( writer );
var newElement = CKEDITOR.dom.element.createFromHtml( writer.getHtml(), editor.document );
if ( isInsertMode )
editor.insertElement( newElement );
else
{
newElement.replace( element );
editor.getSelection().selectElement( newElement );
}
},
contents : [
{
id : 'info',
label : editor.lang.button.title,
title : editor.lang.button.title,
elements : [
{
id : 'name',
type : 'text',
label : editor.lang.common.name,
'default' : '',
setup : function( element )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : commitAttributes
},
{
id : 'value',
type : 'text',
label : editor.lang.button.text,
accessKey : 'V',
'default' : '',
setup : function( element )
{
this.setValue( element.getAttribute( 'value' ) || '' );
},
commit : commitAttributes
},
{
id : 'type',
type : 'select',
label : editor.lang.button.type,
'default' : 'button',
accessKey : 'T',
items :
[
[ editor.lang.button.typeBtn, 'button' ],
[ editor.lang.button.typeSbm, 'submit' ],
[ editor.lang.button.typeRst, 'reset' ]
],
setup : function( element )
{
this.setValue( element.getAttribute( 'type' ) || '' );
},
commit : commitAttributes
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'form', function( editor )
{
var autoAttributes =
{
action : 1,
id : 1,
method : 1,
enctype : 1,
target : 1
};
return {
title : editor.lang.form.title,
minWidth : 350,
minHeight : 200,
onShow : function()
{
delete this.form;
var element = this.getParentEditor().getSelection().getStartElement();
var form = element && element.getAscendant( 'form', true );
if ( form )
{
this.form = form;
this.setupContent( form );
}
},
onOk : function()
{
var editor,
element = this.form,
isInsertMode = !element;
if ( isInsertMode )
{
editor = this.getParentEditor();
element = editor.document.createElement( 'form' );
!CKEDITOR.env.ie && element.append( editor.document.createElement( 'br' ) );
}
if ( isInsertMode )
editor.insertElement( element );
this.commitContent( element );
},
onLoad : function()
{
function autoSetup( element )
{
this.setValue( element.getAttribute( this.id ) || '' );
}
function autoCommit( element )
{
if ( this.getValue() )
element.setAttribute( this.id, this.getValue() );
else
element.removeAttribute( this.id );
}
this.foreach( function( contentObj )
{
if ( autoAttributes[ contentObj.id ] )
{
contentObj.setup = autoSetup;
contentObj.commit = autoCommit;
}
} );
},
contents : [
{
id : 'info',
label : editor.lang.form.title,
title : editor.lang.form.title,
elements : [
{
id : 'txtName',
type : 'text',
label : editor.lang.common.name,
'default' : '',
accessKey : 'N',
setup : function( element )
{
this.setValue( element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : function( element )
{
if ( this.getValue() )
element.data( 'cke-saved-name', this.getValue() );
else
{
element.data( 'cke-saved-name', false );
element.removeAttribute( 'name' );
}
}
},
{
id : 'action',
type : 'text',
label : editor.lang.form.action,
'default' : '',
accessKey : 'T'
},
{
type : 'hbox',
widths : [ '45%', '55%' ],
children :
[
{
id : 'id',
type : 'text',
label : editor.lang.common.id,
'default' : '',
accessKey : 'I'
},
{
id : 'enctype',
type : 'select',
label : editor.lang.form.encoding,
style : 'width:100%',
accessKey : 'E',
'default' : '',
items :
[
[ '' ],
[ 'text/plain' ],
[ 'multipart/form-data' ],
[ 'application/x-www-form-urlencoded' ]
]
}
]
},
{
type : 'hbox',
widths : [ '45%', '55%' ],
children :
[
{
id : 'target',
type : 'select',
label : editor.lang.common.target,
style : 'width:100%',
accessKey : 'M',
'default' : '',
items :
[
[ editor.lang.common.notSet, '' ],
[ editor.lang.common.targetNew, '_blank' ],
[ editor.lang.common.targetTop, '_top' ],
[ editor.lang.common.targetSelf, '_self' ],
[ editor.lang.common.targetParent, '_parent' ]
]
},
{
id : 'method',
type : 'select',
label : editor.lang.form.method,
accessKey : 'M',
'default' : 'GET',
items :
[
[ 'GET', 'get' ],
[ 'POST', 'post' ]
]
}
]
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'textarea', function( editor )
{
return {
title : editor.lang.textarea.title,
minWidth : 350,
minHeight : 220,
onShow : function()
{
delete this.textarea;
var element = this.getParentEditor().getSelection().getSelectedElement();
if ( element && element.getName() == "textarea" )
{
this.textarea = element;
this.setupContent( element );
}
},
onOk : function()
{
var editor,
element = this.textarea,
isInsertMode = !element;
if ( isInsertMode )
{
editor = this.getParentEditor();
element = editor.document.createElement( 'textarea' );
}
this.commitContent( element );
if ( isInsertMode )
editor.insertElement( element );
},
contents : [
{
id : 'info',
label : editor.lang.textarea.title,
title : editor.lang.textarea.title,
elements : [
{
id : '_cke_saved_name',
type : 'text',
label : editor.lang.common.name,
'default' : '',
accessKey : 'N',
setup : function( element )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : function( element )
{
if ( this.getValue() )
element.data( 'cke-saved-name', this.getValue() );
else
{
element.data( 'cke-saved-name', false );
element.removeAttribute( 'name' );
}
}
},
{
type : 'hbox',
widths:['50%','50%'],
children:[
{
id : 'cols',
type : 'text',
label : editor.lang.textarea.cols,
'default' : '',
accessKey : 'C',
style : 'width:50px',
validate : CKEDITOR.dialog.validate.integer( editor.lang.common.validateNumberFailed ),
setup : function( element )
{
var value = element.hasAttribute( 'cols' ) && element.getAttribute( 'cols' );
this.setValue( value || '' );
},
commit : function( element )
{
if ( this.getValue() )
element.setAttribute( 'cols', this.getValue() );
else
element.removeAttribute( 'cols' );
}
},
{
id : 'rows',
type : 'text',
label : editor.lang.textarea.rows,
'default' : '',
accessKey : 'R',
style : 'width:50px',
validate : CKEDITOR.dialog.validate.integer( editor.lang.common.validateNumberFailed ),
setup : function( element )
{
var value = element.hasAttribute( 'rows' ) && element.getAttribute( 'rows' );
this.setValue( value || '' );
},
commit : function( element )
{
if ( this.getValue() )
element.setAttribute( 'rows', this.getValue() );
else
element.removeAttribute( 'rows' );
}
}
]
},
{
id : 'value',
type : 'textarea',
label : editor.lang.textfield.value,
'default' : '',
setup : function( element )
{
this.setValue( element.$.defaultValue );
},
commit : function( element )
{
element.$.value = element.$.defaultValue = this.getValue() ;
}
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'radio', function( editor )
{
return {
title : editor.lang.checkboxAndRadio.radioTitle,
minWidth : 350,
minHeight : 140,
onShow : function()
{
delete this.radioButton;
var element = this.getParentEditor().getSelection().getSelectedElement();
if ( element && element.getName() == 'input' && element.getAttribute( 'type' ) == 'radio' )
{
this.radioButton = element;
this.setupContent( element );
}
},
onOk : function()
{
var editor,
element = this.radioButton,
isInsertMode = !element;
if ( isInsertMode )
{
editor = this.getParentEditor();
element = editor.document.createElement( 'input' );
element.setAttribute( 'type', 'radio' );
}
if ( isInsertMode )
editor.insertElement( element );
this.commitContent( { element : element } );
},
contents : [
{
id : 'info',
label : editor.lang.checkboxAndRadio.radioTitle,
title : editor.lang.checkboxAndRadio.radioTitle,
elements : [
{
id : 'name',
type : 'text',
label : editor.lang.common.name,
'default' : '',
accessKey : 'N',
setup : function( element )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : function( data )
{
var element = data.element;
if ( this.getValue() )
element.data( 'cke-saved-name', this.getValue() );
else
{
element.data( 'cke-saved-name', false );
element.removeAttribute( 'name' );
}
}
},
{
id : 'value',
type : 'text',
label : editor.lang.checkboxAndRadio.value,
'default' : '',
accessKey : 'V',
setup : function( element )
{
this.setValue( element.getAttribute( 'value' ) || '' );
},
commit : function( data )
{
var element = data.element;
if ( this.getValue() )
element.setAttribute( 'value', this.getValue() );
else
element.removeAttribute( 'value' );
}
},
{
id : 'checked',
type : 'checkbox',
label : editor.lang.checkboxAndRadio.selected,
'default' : '',
accessKey : 'S',
value : "checked",
setup : function( element )
{
this.setValue( element.getAttribute( 'checked' ) );
},
commit : function( data )
{
var element = data.element;
if ( !( CKEDITOR.env.ie || CKEDITOR.env.opera ) )
{
if ( this.getValue() )
element.setAttribute( 'checked', 'checked' );
else
element.removeAttribute( 'checked' );
}
else
{
var isElementChecked = element.getAttribute( 'checked' );
var isChecked = !!this.getValue();
if ( isElementChecked != isChecked )
{
var replace = CKEDITOR.dom.element.createFromHtml( '<input type="radio"'
+ ( isChecked ? ' checked="checked"' : '' )
+ '></input>', editor.document );
element.copyAttributes( replace, { type : 1, checked : 1 } );
replace.replace( element );
editor.getSelection().selectElement( replace );
data.element = replace;
}
}
}
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.dialog.add( 'checkbox', function( editor )
{
return {
title : editor.lang.checkboxAndRadio.checkboxTitle,
minWidth : 350,
minHeight : 140,
onShow : function()
{
delete this.checkbox;
var element = this.getParentEditor().getSelection().getSelectedElement();
if ( element && element.getAttribute( 'type' ) == 'checkbox' )
{
this.checkbox = element;
this.setupContent( element );
}
},
onOk : function()
{
var editor,
element = this.checkbox,
isInsertMode = !element;
if ( isInsertMode )
{
editor = this.getParentEditor();
element = editor.document.createElement( 'input' );
element.setAttribute( 'type', 'checkbox' );
editor.insertElement( element );
}
this.commitContent( { element : element } );
},
contents : [
{
id : 'info',
label : editor.lang.checkboxAndRadio.checkboxTitle,
title : editor.lang.checkboxAndRadio.checkboxTitle,
startupFocus : 'txtName',
elements : [
{
id : 'txtName',
type : 'text',
label : editor.lang.common.name,
'default' : '',
accessKey : 'N',
setup : function( element )
{
this.setValue(
element.data( 'cke-saved-name' ) ||
element.getAttribute( 'name' ) ||
'' );
},
commit : function( data )
{
var element = data.element;
// IE failed to update 'name' property on input elements, protect it now.
if ( this.getValue() )
element.data( 'cke-saved-name', this.getValue() );
else
{
element.data( 'cke-saved-name', false );
element.removeAttribute( 'name' );
}
}
},
{
id : 'txtValue',
type : 'text',
label : editor.lang.checkboxAndRadio.value,
'default' : '',
accessKey : 'V',
setup : function( element )
{
var value = element.getAttribute( 'value' );
// IE Return 'on' as default attr value.
this.setValue( CKEDITOR.env.ie && value == 'on' ? '' : value );
},
commit : function( data )
{
var element = data.element,
value = this.getValue();
if ( value && !( CKEDITOR.env.ie && value == 'on' ) )
element.setAttribute( 'value', value );
else
{
if ( CKEDITOR.env.ie )
{
// Remove attribute 'value' of checkbox (#4721).
var checkbox = new CKEDITOR.dom.element( 'input', element.getDocument() );
element.copyAttributes( checkbox, { value: 1 } );
checkbox.replace( element );
editor.getSelection().selectElement( checkbox );
data.element = checkbox;
}
else
element.removeAttribute( 'value' );
}
}
},
{
id : 'cmbSelected',
type : 'checkbox',
label : editor.lang.checkboxAndRadio.selected,
'default' : '',
accessKey : 'S',
value : "checked",
setup : function( element )
{
this.setValue( element.getAttribute( 'checked' ) );
},
commit : function( data )
{
var element = data.element;
if ( CKEDITOR.env.ie )
{
var isElementChecked = !!element.getAttribute( 'checked' ),
isChecked = !!this.getValue();
if ( isElementChecked != isChecked )
{
var replace = CKEDITOR.dom.element.createFromHtml( '<input type="checkbox"'
+ ( isChecked ? ' checked="checked"' : '' )
+ '/>', editor.document );
element.copyAttributes( replace, { type : 1, checked : 1 } );
replace.replace( element );
editor.getSelection().selectElement( replace );
data.element = replace;
}
}
else
{
var value = this.getValue();
if ( value )
element.setAttribute( 'checked', 'checked' );
else
element.removeAttribute( 'checked' );
}
}
}
]
}
]
};
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
// Register a plugin named "sample".
CKEDITOR.plugins.add( 'keystrokes',
{
beforeInit : function( editor )
{
/**
* Controls keystrokes typing in this editor instance.
* @name CKEDITOR.editor.prototype.keystrokeHandler
* @type CKEDITOR.keystrokeHandler
* @example
*/
editor.keystrokeHandler = new CKEDITOR.keystrokeHandler( editor );
editor.specialKeys = {};
},
init : function( editor )
{
var keystrokesConfig = editor.config.keystrokes,
blockedConfig = editor.config.blockedKeystrokes;
var keystrokes = editor.keystrokeHandler.keystrokes,
blockedKeystrokes = editor.keystrokeHandler.blockedKeystrokes;
for ( var i = 0 ; i < keystrokesConfig.length ; i++ )
keystrokes[ keystrokesConfig[i][0] ] = keystrokesConfig[i][1];
for ( i = 0 ; i < blockedConfig.length ; i++ )
blockedKeystrokes[ blockedConfig[i] ] = 1;
}
});
/**
* Controls keystrokes typing in an editor instance.
* @constructor
* @param {CKEDITOR.editor} editor The editor instance.
* @example
*/
CKEDITOR.keystrokeHandler = function( editor )
{
if ( editor.keystrokeHandler )
return editor.keystrokeHandler;
/**
* List of keystrokes associated to commands. Each entry points to the
* command to be executed.
* @type Object
* @example
*/
this.keystrokes = {};
/**
* List of keystrokes that should be blocked if not defined at
* {@link keystrokes}. In this way it is possible to block the default
* browser behavior for those keystrokes.
* @type Object
* @example
*/
this.blockedKeystrokes = {};
this._ =
{
editor : editor
};
return this;
};
(function()
{
var cancel;
var onKeyDown = function( event )
{
// The DOM event object is passed by the "data" property.
event = event.data;
var keyCombination = event.getKeystroke();
var command = this.keystrokes[ keyCombination ];
var editor = this._.editor;
cancel = ( editor.fire( 'key', { keyCode : keyCombination } ) === true );
if ( !cancel )
{
if ( command )
{
var data = { from : 'keystrokeHandler' };
cancel = ( editor.execCommand( command, data ) !== false );
}
if ( !cancel )
{
var handler = editor.specialKeys[ keyCombination ];
cancel = ( handler && handler( editor ) === true );
if ( !cancel )
cancel = !!this.blockedKeystrokes[ keyCombination ];
}
}
if ( cancel )
event.preventDefault( true );
return !cancel;
};
var onKeyPress = function( event )
{
if ( cancel )
{
cancel = false;
event.data.preventDefault( true );
}
};
CKEDITOR.keystrokeHandler.prototype =
{
/**
* Attaches this keystroke handle to a DOM object. Keystrokes typed
** over this object will get handled by this keystrokeHandler.
* @param {CKEDITOR.dom.domObject} domObject The DOM object to attach
* to.
* @example
*/
attach : function( domObject )
{
// For most browsers, it is enough to listen to the keydown event
// only.
domObject.on( 'keydown', onKeyDown, this );
// 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.
if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
domObject.on( 'keypress', onKeyPress, this );
}
};
})();
/**
* A list of keystrokes to be blocked if not defined in the {@link CKEDITOR.config.keystrokes}
* setting. In this way it is possible to block the default browser behavior
* for those keystrokes.
* @type Array
* @default (see example)
* @example
* // This is actually the default value.
* config.blockedKeystrokes =
* [
* CKEDITOR.CTRL + 66 /*B*/,
* CKEDITOR.CTRL + 73 /*I*/,
* CKEDITOR.CTRL + 85 /*U*/
* ];
*/
CKEDITOR.config.blockedKeystrokes =
[
CKEDITOR.CTRL + 66 /*B*/,
CKEDITOR.CTRL + 73 /*I*/,
CKEDITOR.CTRL + 85 /*U*/
];
/**
* A list associating keystrokes to editor commands. Each element in the list
* is an array where the first item is the keystroke, and the second is the
* name of the command to be executed.
* @type Array
* @default (see example)
* @example
* // This is actually the default value.
* config.keystrokes =
* [
* [ CKEDITOR.ALT + 121 /*F10*/, 'toolbarFocus' ],
* [ CKEDITOR.ALT + 122 /*F11*/, 'elementsPathFocus' ],
*
* [ CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
*
* [ CKEDITOR.CTRL + 90 /*Z*/, 'undo' ],
* [ CKEDITOR.CTRL + 89 /*Y*/, 'redo' ],
* [ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 /*Z*/, 'redo' ],
*
* [ CKEDITOR.CTRL + 76 /*L*/, 'link' ],
*
* [ CKEDITOR.CTRL + 66 /*B*/, 'bold' ],
* [ CKEDITOR.CTRL + 73 /*I*/, 'italic' ],
* [ CKEDITOR.CTRL + 85 /*U*/, 'underline' ],
*
* [ CKEDITOR.ALT + 109 /*-*/, 'toolbarCollapse' ]
* ];
*/
CKEDITOR.config.keystrokes =
[
[ CKEDITOR.ALT + 121 /*F10*/, 'toolbarFocus' ],
[ CKEDITOR.ALT + 122 /*F11*/, 'elementsPathFocus' ],
[ CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
[ CKEDITOR.CTRL + CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
[ CKEDITOR.CTRL + 90 /*Z*/, 'undo' ],
[ CKEDITOR.CTRL + 89 /*Y*/, 'redo' ],
[ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 /*Z*/, 'redo' ],
[ CKEDITOR.CTRL + 76 /*L*/, 'link' ],
[ CKEDITOR.CTRL + 66 /*B*/, 'bold' ],
[ CKEDITOR.CTRL + 73 /*I*/, 'italic' ],
[ CKEDITOR.CTRL + 85 /*U*/, 'underline' ],
[ CKEDITOR.ALT + ( CKEDITOR.env.ie || CKEDITOR.env.webkit ? 189 : 109 ) /*-*/, 'toolbarCollapse' ],
[ CKEDITOR.ALT + 48 /*0*/, 'a11yHelp' ]
];
/**
* Fired when any keyboard key (or combination) is pressed into the editing area.
* @name CKEDITOR.editor#key
* @event
* @param {Number} data.keyCode A number representing the key code (or
* combination). It is the sum of the current key code and the
* {@link CKEDITOR.CTRL}, {@link CKEDITOR.SHIFT} and {@link CKEDITOR.ALT}
* constants, if those are pressed.
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file DOM iterator, which iterates over list items, lines and paragraphs.
*/
CKEDITOR.plugins.add( 'domiterator' );
(function()
{
/**
* @name CKEDITOR.dom.iterator
*/
function iterator( range )
{
if ( arguments.length < 1 )
return;
this.range = range;
this.forceBrBreak = 0;
// Whether include <br>s into the enlarged range.(#3730).
this.enlargeBr = 1;
this.enforceRealBlocks = 0;
this._ || ( this._ = {} );
}
var beginWhitespaceRegex = /^[\r\n\t ]+$/,
// Ignore bookmark nodes.(#3783)
bookmarkGuard = CKEDITOR.dom.walker.bookmark( false, true ),
whitespacesGuard = CKEDITOR.dom.walker.whitespaces( true ),
skipGuard = function( node ) { return bookmarkGuard( node ) && whitespacesGuard( node ); };
// Get a reference for the next element, bookmark nodes are skipped.
function getNextSourceNode( node, startFromSibling, lastNode )
{
var next = node.getNextSourceNode( startFromSibling, null, lastNode );
while ( !bookmarkGuard( next ) )
next = next.getNextSourceNode( startFromSibling, null, lastNode );
return next;
}
iterator.prototype = {
getNextParagraph : function( blockTag )
{
// The block element to be returned.
var block;
// The range object used to identify the paragraph contents.
var range;
// Indicats that the current element in the loop is the last one.
var isLast;
// Indicate at least one of the range boundaries is inside a preformat block.
var touchPre;
// Instructs to cleanup remaining BRs.
var removePreviousBr, removeLastBr;
// This is the first iteration. Let's initialize it.
if ( !this._.started )
{
range = this.range.clone();
// Shrink the range to exclude harmful "noises" (#4087, #4450, #5435).
range.shrink( CKEDITOR.NODE_ELEMENT, true );
touchPre = range.endContainer.hasAscendant( 'pre', true )
|| range.startContainer.hasAscendant( 'pre', true );
range.enlarge( this.forceBrBreak && !touchPre || !this.enlargeBr ?
CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS : CKEDITOR.ENLARGE_BLOCK_CONTENTS );
if ( !range.collapsed )
{
var walker = new CKEDITOR.dom.walker( range.clone() ),
ignoreBookmarkTextEvaluator = CKEDITOR.dom.walker.bookmark( true, true );
// Avoid anchor inside bookmark inner text.
walker.evaluator = ignoreBookmarkTextEvaluator;
this._.nextNode = walker.next();
// TODO: It's better to have walker.reset() used here.
walker = new CKEDITOR.dom.walker( range.clone() );
walker.evaluator = ignoreBookmarkTextEvaluator;
var lastNode = walker.previous();
this._.lastNode = lastNode.getNextSourceNode( true );
// We may have an empty text node at the end of block due to [3770].
// If that node is the lastNode, it would cause our logic to leak to the
// next block.(#3887)
if ( this._.lastNode &&
this._.lastNode.type == CKEDITOR.NODE_TEXT &&
!CKEDITOR.tools.trim( this._.lastNode.getText() ) &&
this._.lastNode.getParent().isBlockBoundary() )
{
var testRange = new CKEDITOR.dom.range( range.document );
testRange.moveToPosition( this._.lastNode, CKEDITOR.POSITION_AFTER_END );
if ( testRange.checkEndOfBlock() )
{
var path = new CKEDITOR.dom.elementPath( testRange.endContainer );
var lastBlock = path.block || path.blockLimit;
this._.lastNode = lastBlock.getNextSourceNode( true );
}
}
// Probably the document end is reached, we need a marker node.
if ( !this._.lastNode )
{
this._.lastNode = this._.docEndMarker = range.document.createText( '' );
this._.lastNode.insertAfter( lastNode );
}
// Let's reuse this variable.
range = null;
}
this._.started = 1;
}
var currentNode = this._.nextNode;
lastNode = this._.lastNode;
this._.nextNode = null;
while ( currentNode )
{
// closeRange indicates that a paragraph boundary has been found,
// so the range can be closed.
var closeRange = 0,
parentPre = currentNode.hasAscendant( 'pre' );
// includeNode indicates that the current node is good to be part
// of the range. By default, any non-element node is ok for it.
var includeNode = ( currentNode.type != CKEDITOR.NODE_ELEMENT ),
continueFromSibling = 0;
// If it is an element node, let's check if it can be part of the
// range.
if ( !includeNode )
{
var nodeName = currentNode.getName();
if ( currentNode.isBlockBoundary( this.forceBrBreak &&
!parentPre && { br : 1 } ) )
{
// <br> boundaries must be part of the range. It will
// happen only if ForceBrBreak.
if ( nodeName == 'br' )
includeNode = 1;
else if ( !range && !currentNode.getChildCount() && nodeName != 'hr' )
{
// If we have found an empty block, and haven't started
// the range yet, it means we must return this block.
block = currentNode;
isLast = currentNode.equals( lastNode );
break;
}
// The range must finish right before the boundary,
// including possibly skipped empty spaces. (#1603)
if ( range )
{
range.setEndAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
// The found boundary must be set as the next one at this
// point. (#1717)
if ( nodeName != 'br' )
this._.nextNode = currentNode;
}
closeRange = 1;
}
else
{
// If we have child nodes, let's check them.
if ( currentNode.getFirst() )
{
// If we don't have a range yet, let's start it.
if ( !range )
{
range = new CKEDITOR.dom.range( this.range.document );
range.setStartAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
}
currentNode = currentNode.getFirst();
continue;
}
includeNode = 1;
}
}
else if ( currentNode.type == CKEDITOR.NODE_TEXT )
{
// Ignore normal whitespaces (i.e. not including or
// other unicode whitespaces) before/after a block node.
if ( beginWhitespaceRegex.test( currentNode.getText() ) )
includeNode = 0;
}
// The current node is good to be part of the range and we are
// starting a new range, initialize it first.
if ( includeNode && !range )
{
range = new CKEDITOR.dom.range( this.range.document );
range.setStartAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
}
// The last node has been found.
isLast = ( ( !closeRange || includeNode ) && currentNode.equals( lastNode ) );
// If we are in an element boundary, let's check if it is time
// to close the range, otherwise we include the parent within it.
if ( range && !closeRange )
{
while ( !currentNode.getNext( skipGuard ) && !isLast )
{
var parentNode = currentNode.getParent();
if ( parentNode.isBlockBoundary( this.forceBrBreak
&& !parentPre && { br : 1 } ) )
{
closeRange = 1;
includeNode = 0;
isLast = isLast || ( parentNode.equals( lastNode) );
// Make sure range includes bookmarks at the end of the block. (#7359)
range.setEndAt( parentNode, CKEDITOR.POSITION_BEFORE_END );
break;
}
currentNode = parentNode;
includeNode = 1;
isLast = ( currentNode.equals( lastNode ) );
continueFromSibling = 1;
}
}
// Now finally include the node.
if ( includeNode )
range.setEndAt( currentNode, CKEDITOR.POSITION_AFTER_END );
currentNode = getNextSourceNode ( currentNode, continueFromSibling, lastNode );
isLast = !currentNode;
// We have found a block boundary. Let's close the range and move out of the
// loop.
if ( isLast || ( closeRange && range ) )
break;
}
// Now, based on the processed range, look for (or create) the block to be returned.
if ( !block )
{
// If no range has been found, this is the end.
if ( !range )
{
this._.docEndMarker && this._.docEndMarker.remove();
this._.nextNode = null;
return null;
}
var startPath = new CKEDITOR.dom.elementPath( range.startContainer );
var startBlockLimit = startPath.blockLimit,
checkLimits = { div : 1, th : 1, td : 1 };
block = startPath.block;
if ( !block
&& !this.enforceRealBlocks
&& checkLimits[ startBlockLimit.getName() ]
&& range.checkStartOfBlock()
&& range.checkEndOfBlock() )
block = startBlockLimit;
else if ( !block || ( this.enforceRealBlocks && block.getName() == 'li' ) )
{
// Create the fixed block.
block = this.range.document.createElement( blockTag || 'p' );
// Move the contents of the temporary range to the fixed block.
range.extractContents().appendTo( block );
block.trim();
// Insert the fixed block into the DOM.
range.insertNode( block );
removePreviousBr = removeLastBr = true;
}
else if ( block.getName() != 'li' )
{
// If the range doesn't includes the entire contents of the
// block, we must split it, isolating the range in a dedicated
// block.
if ( !range.checkStartOfBlock() || !range.checkEndOfBlock() )
{
// The resulting block will be a clone of the current one.
block = block.clone( false );
// Extract the range contents, moving it to the new block.
range.extractContents().appendTo( block );
block.trim();
// Split the block. At this point, the range will be in the
// right position for our intents.
var splitInfo = range.splitBlock();
removePreviousBr = !splitInfo.wasStartOfBlock;
removeLastBr = !splitInfo.wasEndOfBlock;
// Insert the new block into the DOM.
range.insertNode( block );
}
}
else if ( !isLast )
{
// LIs are returned as is, with all their children (due to the
// nested lists). But, the next node is the node right after
// the current range, which could be an <li> child (nested
// lists) or the next sibling <li>.
this._.nextNode = ( block.equals( lastNode ) ? null : getNextSourceNode( range.getBoundaryNodes().endNode, 1, lastNode ) );
}
}
if ( removePreviousBr )
{
var previousSibling = block.getPrevious();
if ( previousSibling && previousSibling.type == CKEDITOR.NODE_ELEMENT )
{
if ( previousSibling.getName() == 'br' )
previousSibling.remove();
else if ( previousSibling.getLast() && previousSibling.getLast().$.nodeName.toLowerCase() == 'br' )
previousSibling.getLast().remove();
}
}
if ( removeLastBr )
{
var lastChild = block.getLast();
if ( lastChild && lastChild.type == CKEDITOR.NODE_ELEMENT && lastChild.getName() == 'br' )
{
// Take care not to remove the block expanding <br> in non-IE browsers.
if ( CKEDITOR.env.ie
|| lastChild.getPrevious( bookmarkGuard )
|| lastChild.getNext( bookmarkGuard ) )
lastChild.remove();
}
}
// Get a reference for the next element. This is important because the
// above block can be removed or changed, so we can rely on it for the
// next interation.
if ( !this._.nextNode )
{
this._.nextNode = ( isLast || block.equals( lastNode ) || !lastNode ) ? null :
getNextSourceNode( block, 1, lastNode );
}
return block;
}
};
CKEDITOR.dom.range.prototype.createIterator = function()
{
return new iterator( this );
};
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'table',
{
requires : [ 'dialog' ],
init : function( editor )
{
var table = CKEDITOR.plugins.table,
lang = editor.lang.table;
editor.addCommand( 'table', new CKEDITOR.dialogCommand( 'table' ) );
editor.addCommand( 'tableProperties', new CKEDITOR.dialogCommand( 'tableProperties' ) );
editor.ui.addButton( 'Table',
{
label : lang.toolbar,
command : 'table'
});
CKEDITOR.dialog.add( 'table', this.path + 'dialogs/table.js' );
CKEDITOR.dialog.add( 'tableProperties', this.path + 'dialogs/table.js' );
// If the "menu" plugin is loaded, register the menu items.
if ( editor.addMenuItems )
{
editor.addMenuItems(
{
table :
{
label : lang.menu,
command : 'tableProperties',
group : 'table',
order : 5
},
tabledelete :
{
label : lang.deleteTable,
command : 'tableDelete',
group : 'table',
order : 1
}
} );
}
editor.on( 'doubleclick', function( evt )
{
var element = evt.data.element;
if ( element.is( 'table' ) )
evt.data.dialog = 'tableProperties';
});
// If the "contextmenu" plugin is loaded, register the listeners.
if ( editor.contextMenu )
{
editor.contextMenu.addListener( function( element, selection )
{
if ( !element || element.isReadOnly() )
return null;
var isTable = element.hasAscendant( 'table', 1 );
if ( isTable )
{
return {
tabledelete : CKEDITOR.TRISTATE_OFF,
table : CKEDITOR.TRISTATE_OFF
};
}
return null;
} );
}
}
} );
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
(function()
{
var defaultToPixel = CKEDITOR.tools.cssLength;
var commitValue = function( data )
{
var id = this.id;
if ( !data.info )
data.info = {};
data.info[id] = this.getValue();
};
function tableColumns( table )
{
var cols = 0, maxCols = 0;
for ( var i = 0, row, rows = table.$.rows.length; i < rows; i++ )
{
row = table.$.rows[ i ], cols = 0;
for ( var j = 0, cell, cells = row.cells.length; j < cells; j++ )
{
cell = row.cells[ j ];
cols += cell.colSpan;
}
cols > maxCols && ( maxCols = cols );
}
return maxCols;
}
// Whole-positive-integer validator.
function validatorNum( msg )
{
return function()
{
var value = this.getValue(),
pass = !!( CKEDITOR.dialog.validate.integer()( value ) && value > 0 );
if ( !pass )
{
alert( msg );
this.select();
}
return pass;
};
}
function tableDialog( editor, command )
{
var makeElement = function( name )
{
return new CKEDITOR.dom.element( name, editor.document );
};
var dialogadvtab = editor.plugins.dialogadvtab;
return {
title : editor.lang.table.title,
minWidth : 310,
minHeight : CKEDITOR.env.ie ? 310 : 280,
onLoad : function()
{
var dialog = this;
var styles = dialog.getContentElement( 'advanced', 'advStyles' );
if ( styles )
{
styles.on( 'change', function( evt )
{
// Synchronize width value.
var width = this.getStyle( 'width', '' ),
txtWidth = dialog.getContentElement( 'info', 'txtWidth' );
txtWidth && txtWidth.setValue( width, true );
// Synchronize height value.
var height = this.getStyle( 'height', '' ),
txtHeight = dialog.getContentElement( 'info', 'txtHeight' );
txtHeight && txtHeight.setValue( height, true );
});
}
},
onShow : function()
{
// Detect if there's a selected table.
var selection = editor.getSelection(),
ranges = selection.getRanges(),
selectedTable = null;
var rowsInput = this.getContentElement( 'info', 'txtRows' ),
colsInput = this.getContentElement( 'info', 'txtCols' ),
widthInput = this.getContentElement( 'info', 'txtWidth' ),
heightInput = this.getContentElement( 'info', 'txtHeight' );
if ( command == 'tableProperties' )
{
if ( ( selectedTable = selection.getSelectedElement() ) )
selectedTable = selectedTable.getAscendant( 'table', true );
else if ( ranges.length > 0 )
{
// Webkit could report the following range on cell selection (#4948):
// <table><tr><td>[ </td></tr></table>]
if ( CKEDITOR.env.webkit )
ranges[ 0 ].shrink( CKEDITOR.NODE_ELEMENT );
var rangeRoot = ranges[0].getCommonAncestor( true );
selectedTable = rangeRoot.getAscendant( 'table', true );
}
// Save a reference to the selected table, and push a new set of default values.
this._.selectedElement = selectedTable;
}
// Enable or disable the row, cols, width fields.
if ( selectedTable )
{
this.setupContent( selectedTable );
rowsInput && rowsInput.disable();
colsInput && colsInput.disable();
}
else
{
rowsInput && rowsInput.enable();
colsInput && colsInput.enable();
}
// Call the onChange method for the widht and height fields so
// they get reflected into the Advanced tab.
widthInput && widthInput.onChange();
heightInput && heightInput.onChange();
},
onOk : function()
{
var selection = editor.getSelection(),
bms = this._.selectedElement && selection.createBookmarks();
var table = this._.selectedElement || makeElement( 'table' ),
me = this,
data = {};
this.commitContent( data, table );
if ( data.info )
{
var info = data.info;
// Generate the rows and cols.
if ( !this._.selectedElement )
{
var tbody = table.append( makeElement( 'tbody' ) ),
rows = parseInt( info.txtRows, 10 ) || 0,
cols = parseInt( info.txtCols, 10 ) || 0;
for ( var i = 0 ; i < rows ; i++ )
{
var row = tbody.append( makeElement( 'tr' ) );
for ( var j = 0 ; j < cols ; j++ )
{
var cell = row.append( makeElement( 'td' ) );
if ( !CKEDITOR.env.ie )
cell.append( makeElement( 'br' ) );
}
}
}
// Modify the table headers. Depends on having rows and cols generated
// correctly so it can't be done in commit functions.
// Should we make a <thead>?
var headers = info.selHeaders;
if ( !table.$.tHead && ( headers == 'row' || headers == 'both' ) )
{
var thead = new CKEDITOR.dom.element( table.$.createTHead() );
tbody = table.getElementsByTag( 'tbody' ).getItem( 0 );
var theRow = tbody.getElementsByTag( 'tr' ).getItem( 0 );
// Change TD to TH:
for ( i = 0 ; i < theRow.getChildCount() ; i++ )
{
var th = theRow.getChild( i );
// Skip bookmark nodes. (#6155)
if ( th.type == CKEDITOR.NODE_ELEMENT && !th.data( 'cke-bookmark' ) )
{
th.renameNode( 'th' );
th.setAttribute( 'scope', 'col' );
}
}
thead.append( theRow.remove() );
}
if ( table.$.tHead !== null && !( headers == 'row' || headers == 'both' ) )
{
// Move the row out of the THead and put it in the TBody:
thead = new CKEDITOR.dom.element( table.$.tHead );
tbody = table.getElementsByTag( 'tbody' ).getItem( 0 );
var previousFirstRow = tbody.getFirst();
while ( thead.getChildCount() > 0 )
{
theRow = thead.getFirst();
for ( i = 0; i < theRow.getChildCount() ; i++ )
{
var newCell = theRow.getChild( i );
if ( newCell.type == CKEDITOR.NODE_ELEMENT )
{
newCell.renameNode( 'td' );
newCell.removeAttribute( 'scope' );
}
}
theRow.insertBefore( previousFirstRow );
}
thead.remove();
}
// Should we make all first cells in a row TH?
if ( !this.hasColumnHeaders && ( headers == 'col' || headers == 'both' ) )
{
for ( row = 0 ; row < table.$.rows.length ; row++ )
{
newCell = new CKEDITOR.dom.element( table.$.rows[ row ].cells[ 0 ] );
newCell.renameNode( 'th' );
newCell.setAttribute( 'scope', 'row' );
}
}
// Should we make all first TH-cells in a row make TD? If 'yes' we do it the other way round :-)
if ( ( this.hasColumnHeaders ) && !( headers == 'col' || headers == 'both' ) )
{
for ( i = 0 ; i < table.$.rows.length ; i++ )
{
row = new CKEDITOR.dom.element( table.$.rows[i] );
if ( row.getParent().getName() == 'tbody' )
{
newCell = new CKEDITOR.dom.element( row.$.cells[0] );
newCell.renameNode( 'td' );
newCell.removeAttribute( 'scope' );
}
}
}
// Set the width and height.
info.txtHeight ? table.setStyle( 'height', info.txtHeight ) : table.removeStyle( 'height' );
info.txtWidth ? table.setStyle( 'width', info.txtWidth ) : table.removeStyle( 'width' );
if ( !table.getAttribute( 'style' ) )
table.removeAttribute( 'style' );
}
// Insert the table element if we're creating one.
if ( !this._.selectedElement )
{
editor.insertElement( table );
// Override the default cursor position after insertElement to place
// cursor inside the first cell (#7959), IE needs a while.
setTimeout( function()
{
var firstCell = new CKEDITOR.dom.element( table.$.rows[ 0 ].cells[ 0 ] );
var range = new CKEDITOR.dom.range( editor.document );
range.moveToPosition( firstCell, CKEDITOR.POSITION_AFTER_START );
range.select( 1 );
}, 0 );
}
// Properly restore the selection, (#4822) but don't break
// because of this, e.g. updated table caption.
else
try { selection.selectBookmarks( bms ); } catch( er ){}
},
contents : [
{
id : 'info',
label : editor.lang.table.title,
elements :
[
{
type : 'hbox',
widths : [ null, null ],
styles : [ 'vertical-align:top' ],
children :
[
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'text',
id : 'txtRows',
'default' : 3,
label : editor.lang.table.rows,
required : true,
controlStyle : 'width:5em',
validate : validatorNum( editor.lang.table.invalidRows ),
setup : function( selectedElement )
{
this.setValue( selectedElement.$.rows.length );
},
commit : commitValue
},
{
type : 'text',
id : 'txtCols',
'default' : 2,
label : editor.lang.table.columns,
required : true,
controlStyle : 'width:5em',
validate : validatorNum( editor.lang.table.invalidCols ),
setup : function( selectedTable )
{
this.setValue( tableColumns( selectedTable ) );
},
commit : commitValue
},
{
type : 'html',
html : ' '
},
{
type : 'select',
id : 'selHeaders',
'default' : '',
label : editor.lang.table.headers,
items :
[
[ editor.lang.table.headersNone, '' ],
[ editor.lang.table.headersRow, 'row' ],
[ editor.lang.table.headersColumn, 'col' ],
[ editor.lang.table.headersBoth, 'both' ]
],
setup : function( selectedTable )
{
// Fill in the headers field.
var dialog = this.getDialog();
dialog.hasColumnHeaders = true;
// Check if all the first cells in every row are TH
for ( var row = 0 ; row < selectedTable.$.rows.length ; row++ )
{
// If just one cell isn't a TH then it isn't a header column
var headCell = selectedTable.$.rows[row].cells[0];
if ( headCell && headCell.nodeName.toLowerCase() != 'th' )
{
dialog.hasColumnHeaders = false;
break;
}
}
// Check if the table contains <thead>.
if ( ( selectedTable.$.tHead !== null) )
this.setValue( dialog.hasColumnHeaders ? 'both' : 'row' );
else
this.setValue( dialog.hasColumnHeaders ? 'col' : '' );
},
commit : commitValue
},
{
type : 'text',
id : 'txtBorder',
'default' : 1,
label : editor.lang.table.border,
controlStyle : 'width:3em',
validate : CKEDITOR.dialog.validate['number']( editor.lang.table.invalidBorder ),
setup : function( selectedTable )
{
this.setValue( selectedTable.getAttribute( 'border' ) || '' );
},
commit : function( data, selectedTable )
{
if ( this.getValue() )
selectedTable.setAttribute( 'border', this.getValue() );
else
selectedTable.removeAttribute( 'border' );
}
},
{
id : 'cmbAlign',
type : 'select',
'default' : '',
label : editor.lang.common.align,
items :
[
[ editor.lang.common.notSet , ''],
[ editor.lang.common.alignLeft , 'left'],
[ editor.lang.common.alignCenter , 'center'],
[ editor.lang.common.alignRight , 'right']
],
setup : function( selectedTable )
{
this.setValue( selectedTable.getAttribute( 'align' ) || '' );
},
commit : function( data, selectedTable )
{
if ( this.getValue() )
selectedTable.setAttribute( 'align', this.getValue() );
else
selectedTable.removeAttribute( 'align' );
}
}
]
},
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'hbox',
widths : [ '5em' ],
children :
[
{
type : 'text',
id : 'txtWidth',
controlStyle : 'width:5em',
label : editor.lang.common.width,
title : editor.lang.common.cssLengthTooltip,
'default' : 500,
getValue : defaultToPixel,
validate : CKEDITOR.dialog.validate.cssLength( editor.lang.common.invalidCssLength.replace( '%1', editor.lang.common.width ) ),
onChange : function()
{
var styles = this.getDialog().getContentElement( 'advanced', 'advStyles' );
styles && styles.updateStyle( 'width', this.getValue() );
},
setup : function( selectedTable )
{
var val = selectedTable.getStyle( 'width' );
val && this.setValue( val );
},
commit : commitValue
}
]
},
{
type : 'hbox',
widths : [ '5em' ],
children :
[
{
type : 'text',
id : 'txtHeight',
controlStyle : 'width:5em',
label : editor.lang.common.height,
title : editor.lang.common.cssLengthTooltip,
'default' : '',
getValue : defaultToPixel,
validate : CKEDITOR.dialog.validate.cssLength( editor.lang.common.invalidCssLength.replace( '%1', editor.lang.common.height ) ),
onChange : function()
{
var styles = this.getDialog().getContentElement( 'advanced', 'advStyles' );
styles && styles.updateStyle( 'height', this.getValue() );
},
setup : function( selectedTable )
{
var val = selectedTable.getStyle( 'height' );
val && this.setValue( val );
},
commit : commitValue
}
]
},
{
type : 'html',
html : ' '
},
{
type : 'text',
id : 'txtCellSpace',
controlStyle : 'width:3em',
label : editor.lang.table.cellSpace,
'default' : 1,
validate : CKEDITOR.dialog.validate.number( editor.lang.table.invalidCellSpacing ),
setup : function( selectedTable )
{
this.setValue( selectedTable.getAttribute( 'cellSpacing' ) || '' );
},
commit : function( data, selectedTable )
{
if ( this.getValue() )
selectedTable.setAttribute( 'cellSpacing', this.getValue() );
else
selectedTable.removeAttribute( 'cellSpacing' );
}
},
{
type : 'text',
id : 'txtCellPad',
controlStyle : 'width:3em',
label : editor.lang.table.cellPad,
'default' : 1,
validate : CKEDITOR.dialog.validate.number( editor.lang.table.invalidCellPadding ),
setup : function( selectedTable )
{
this.setValue( selectedTable.getAttribute( 'cellPadding' ) || '' );
},
commit : function( data, selectedTable )
{
if ( this.getValue() )
selectedTable.setAttribute( 'cellPadding', this.getValue() );
else
selectedTable.removeAttribute( 'cellPadding' );
}
}
]
}
]
},
{
type : 'html',
align : 'right',
html : ''
},
{
type : 'vbox',
padding : 0,
children :
[
{
type : 'text',
id : 'txtCaption',
label : editor.lang.table.caption,
setup : function( selectedTable )
{
this.enable();
var nodeList = selectedTable.getElementsByTag( 'caption' );
if ( nodeList.count() > 0 )
{
var caption = nodeList.getItem( 0 );
var firstElementChild = caption.getFirst( CKEDITOR.dom.walker.nodeType( CKEDITOR.NODE_ELEMENT ) );
if ( firstElementChild && !firstElementChild.equals( caption.getBogus() ) )
{
this.disable();
this.setValue( caption.getText() );
return;
}
caption = CKEDITOR.tools.trim( caption.getText() );
this.setValue( caption );
}
},
commit : function( data, table )
{
if ( !this.isEnabled() )
return;
var caption = this.getValue(),
captionElement = table.getElementsByTag( 'caption' );
if ( caption )
{
if ( captionElement.count() > 0 )
{
captionElement = captionElement.getItem( 0 );
captionElement.setHtml( '' );
}
else
{
captionElement = new CKEDITOR.dom.element( 'caption', editor.document );
if ( table.getChildCount() )
captionElement.insertBefore( table.getFirst() );
else
captionElement.appendTo( table );
}
captionElement.append( new CKEDITOR.dom.text( caption, editor.document ) );
}
else if ( captionElement.count() > 0 )
{
for ( var i = captionElement.count() - 1 ; i >= 0 ; i-- )
captionElement.getItem( i ).remove();
}
}
},
{
type : 'text',
id : 'txtSummary',
label : editor.lang.table.summary,
setup : function( selectedTable )
{
this.setValue( selectedTable.getAttribute( 'summary' ) || '' );
},
commit : function( data, selectedTable )
{
if ( this.getValue() )
selectedTable.setAttribute( 'summary', this.getValue() );
else
selectedTable.removeAttribute( 'summary' );
}
}
]
}
]
},
dialogadvtab && dialogadvtab.createAdvancedTab( editor )
]
};
}
CKEDITOR.dialog.add( 'table', function( editor )
{
return tableDialog( editor, 'table' );
} );
CKEDITOR.dialog.add( 'tableProperties', function( editor )
{
return tableDialog( editor, 'tableProperties' );
} );
})();
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Horizontal Page Break
*/
// Register a plugin named "newpage".
CKEDITOR.plugins.add( 'newpage',
{
init : function( editor )
{
editor.addCommand( 'newpage',
{
modes : { wysiwyg:1, source:1 },
exec : function( editor )
{
var command = this;
editor.setData( editor.config.newpage_html || '', function()
{
// Save the undo snapshot after all document changes are affected. (#4889)
setTimeout( function ()
{
editor.fire( 'afterCommandExec',
{
name: 'newpage',
command: command
} );
editor.selectionChange();
}, 200 );
} );
editor.focus();
},
async : true
});
editor.ui.addButton( 'NewPage',
{
label : editor.lang.newPage,
command : 'newpage'
});
}
});
/**
* The HTML to load in the editor when the "new page" command is executed.
* @name CKEDITOR.config.newpage_html
* @type String
* @default ''
* @example
* config.newpage_html = '<p>Type your text here.</p>';
*/
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.add( 'format',
{
requires : [ 'richcombo', 'styles' ],
init : function( editor )
{
var config = editor.config,
lang = editor.lang.format;
// Gets the list of tags from the settings.
var tags = config.format_tags.split( ';' );
// Create style objects for all defined styles.
var styles = {};
for ( var i = 0 ; i < tags.length ; i++ )
{
var tag = tags[ i ];
styles[ tag ] = new CKEDITOR.style( config[ 'format_' + tag ] );
styles[ tag ]._.enterMode = editor.config.enterMode;
}
editor.ui.addRichCombo( 'Format',
{
label : lang.label,
title : lang.panelTitle,
className : 'cke_format',
panel :
{
css : editor.skin.editor.css.concat( config.contentsCss ),
multiSelect : false,
attributes : { 'aria-label' : lang.panelTitle }
},
init : function()
{
this.startGroup( lang.panelTitle );
for ( var tag in styles )
{
var label = lang[ 'tag_' + tag ];
// Add the tag entry to the panel list.
this.add( tag, styles[tag].buildPreview( label ), label );
}
},
onClick : function( value )
{
editor.focus();
editor.fire( 'saveSnapshot' );
var style = styles[ value ],
elementPath = new CKEDITOR.dom.elementPath( editor.getSelection().getStartElement() );
style[ style.checkActive( elementPath ) ? 'remove' : 'apply' ]( editor.document );
// Save the undo snapshot after all changes are affected. (#4899)
setTimeout( function()
{
editor.fire( 'saveSnapshot' );
}, 0 );
},
onRender : function()
{
editor.on( 'selectionChange', function( ev )
{
var currentTag = this.getValue();
var elementPath = ev.data.path;
for ( var tag in styles )
{
if ( styles[ tag ].checkActive( elementPath ) )
{
if ( tag != currentTag )
this.setValue( tag, editor.lang.format[ 'tag_' + tag ] );
return;
}
}
// If no styles match, just empty it.
this.setValue( '' );
},
this);
}
});
}
});
/**
* A list of semi colon separated style names (by default tags) representing
* the style definition for each entry to be displayed in the Format combo in
* the toolbar. Each entry must have its relative definition configuration in a
* setting named "format_(tagName)". For example, the "p" entry has its
* definition taken from config.format_p.
* @type String
* @default 'p;h1;h2;h3;h4;h5;h6;pre;address;div'
* @example
* config.format_tags = 'p;h2;h3;pre'
*/
CKEDITOR.config.format_tags = 'p;h1;h2;h3;h4;h5;h6;pre;address;div';
/**
* The style definition to be used to apply the "Normal" format.
* @type Object
* @default { element : 'p' }
* @example
* config.format_p = { element : 'p', attributes : { 'class' : 'normalPara' } };
*/
CKEDITOR.config.format_p = { element : 'p' };
/**
* The style definition to be used to apply the "Normal (DIV)" format.
* @type Object
* @default { element : 'div' }
* @example
* config.format_div = { element : 'div', attributes : { 'class' : 'normalDiv' } };
*/
CKEDITOR.config.format_div = { element : 'div' };
/**
* The style definition to be used to apply the "Formatted" format.
* @type Object
* @default { element : 'pre' }
* @example
* config.format_pre = { element : 'pre', attributes : { 'class' : 'code' } };
*/
CKEDITOR.config.format_pre = { element : 'pre' };
/**
* The style definition to be used to apply the "Address" format.
* @type Object
* @default { element : 'address' }
* @example
* config.format_address = { element : 'address', attributes : { 'class' : 'styledAddress' } };
*/
CKEDITOR.config.format_address = { element : 'address' };
/**
* The style definition to be used to apply the "Heading 1" format.
* @type Object
* @default { element : 'h1' }
* @example
* config.format_h1 = { element : 'h1', attributes : { 'class' : 'contentTitle1' } };
*/
CKEDITOR.config.format_h1 = { element : 'h1' };
/**
* The style definition to be used to apply the "Heading 1" format.
* @type Object
* @default { element : 'h2' }
* @example
* config.format_h2 = { element : 'h2', attributes : { 'class' : 'contentTitle2' } };
*/
CKEDITOR.config.format_h2 = { element : 'h2' };
/**
* The style definition to be used to apply the "Heading 1" format.
* @type Object
* @default { element : 'h3' }
* @example
* config.format_h3 = { element : 'h3', attributes : { 'class' : 'contentTitle3' } };
*/
CKEDITOR.config.format_h3 = { element : 'h3' };
/**
* The style definition to be used to apply the "Heading 1" format.
* @type Object
* @default { element : 'h4' }
* @example
* config.format_h4 = { element : 'h4', attributes : { 'class' : 'contentTitle4' } };
*/
CKEDITOR.config.format_h4 = { element : 'h4' };
/**
* The style definition to be used to apply the "Heading 1" format.
* @type Object
* @default { element : 'h5' }
* @example
* config.format_h5 = { element : 'h5', attributes : { 'class' : 'contentTitle5' } };
*/
CKEDITOR.config.format_h5 = { element : 'h5' };
/**
* The style definition to be used to apply the "Heading 1" format.
* @type Object
* @default { element : 'h6' }
* @example
* config.format_h6 = { element : 'h6', attributes : { 'class' : 'contentTitle6' } };
*/
CKEDITOR.config.format_h6 = { element : 'h6' };
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
* @file Special Character plugin
*/
CKEDITOR.plugins.add( 'specialchar',
{
requires : [ 'dialog' ],
// List of available localizations.
availableLangs : { cs:1, cy:1, de:1, el:1, en:1, eo:1, et:1, fa:1, fi:1, fr:1, he:1, hr:1, it:1, nb:1, nl:1, no:1, 'pt-br':1, tr:1, ug:1, 'zh-cn':1 },
init : function( editor )
{
var pluginName = 'specialchar',
plugin = this;
// Register the dialog.
CKEDITOR.dialog.add( pluginName, this.path + 'dialogs/specialchar.js' );
editor.addCommand( pluginName,
{
exec : function()
{
var langCode = editor.langCode;
langCode = plugin.availableLangs[ langCode ] ? langCode : 'en';
CKEDITOR.scriptLoader.load(
CKEDITOR.getUrl( plugin.path + 'lang/' + langCode + '.js' ),
function()
{
CKEDITOR.tools.extend( editor.lang.specialChar, plugin.langEntries[ langCode ] );
editor.openDialog( pluginName );
});
},
modes : { wysiwyg:1 },
canUndo : false
});
// Register the toolbar button.
editor.ui.addButton( 'SpecialChar',
{
label : editor.lang.specialChar.toolbar,
command : pluginName
});
}
} );
/**
* The list of special characters visible in the Special Character dialog window.
* @type Array
* @example
* config.specialChars = [ '"', '’', [ '&custom;', 'Custom label' ] ];
* config.specialChars = config.specialChars.concat( [ '"', [ '’', 'Custom label' ] ] );
*/
CKEDITOR.config.specialChars =
[
'!','"','#','$','%','&',"'",'(',')','*','+','-','.','/',
'0','1','2','3','4','5','6','7','8','9',':',';',
'<','=','>','?','@',
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
'P','Q','R','S','T','U','V','W','X','Y','Z',
'[',']','^','_','`',
'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p',
'q','r','s','t','u','v','w','x','y','z',
'{','|','}','~',
"€", "‘", "’", "“", "”", "–", "—", "¡", "¢", "£", "¤", "¥", "¦", "§", "¨", "©", "ª", "«", "¬", "®", "¯", "°", "²", "³", "´", "µ", "¶", "·", "¸", "¹", "º", "»", "¼", "½", "¾", "¿", "À", "Á", "Â", "Ã", "Ä", "Å", "Æ", "Ç", "È", "É", "Ê", "Ë", "Ì", "Í", "Î", "Ï", "Ð", "Ñ", "Ò", "Ó", "Ô", "Õ", "Ö", "×", "Ø", "Ù", "Ú", "Û", "Ü", "Ý", "Þ", "ß", "à", "á", "â", "ã", "ä", "å", "æ", "ç", "è", "é", "ê", "ë", "ì", "í", "î", "ï", "ð", "ñ", "ò", "ó", "ô", "õ", "ö", "÷", "ø", "ù", "ú", "û", "ü", "ý", "þ", "ÿ", "Œ", "œ", "Ŵ", "Ŷ", "ŵ", "ŷ", "‚", "‛", "„", "…", "™", "►", "•", "→", "⇒", "⇔", "♦", "≈"
];
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'specialchar', 'nl',
{
euro: 'Euro-teken',
lsquo: 'Linker enkel aanhalingsteken',
rsquo: 'Rechter enkel aanhalingsteken',
ldquo: 'Linker dubbel aanhalingsteken',
rdquo: 'Rechter dubbel aanhalingsteken',
ndash: 'En dash',
mdash: 'Em dash',
iexcl: 'Omgekeerd uitroepteken',
cent: 'Cent-teken',
pound: 'Pond-teken',
curren: 'Valuta-teken',
yen: 'Yen-teken',
brvbar: 'Gebroken streep',
sect: 'Paragraaf-teken',
uml: 'Trema',
copy: 'Copyright-teken',
ordf: 'Vrouwelijk ordinaal',
laquo: 'Linker guillemet',
not: 'Ongelijk-teken',
reg: 'Geregistreerd handelsmerk-teken',
macr: 'Macron',
deg: 'Graden-teken',
sup2: 'Superscript twee',
sup3: 'Superscript drie',
acute: 'Accent aigu',
micro: 'Mico-teken',
para: 'Alinea-teken',
middot: 'Halfhoge punt',
cedil: 'Cedille',
sup1: 'Superscript een',
ordm: 'Mannelijk ordinaal',
raquo: 'Rechter guillemet',
frac14: 'Breuk kwart',
frac12: 'Breuk half',
frac34: 'Breuk driekwart',
iquest: 'Omgekeerd vraagteken',
Agrave: 'Latijnse hoofdletter A met een accent grave',
Aacute: 'Latijnse hoofdletter A met een accent aigu',
Acirc: 'Latijnse hoofdletter A met een circonflexe',
Atilde: 'Latijnse hoofdletter A met een tilde',
Auml: 'Latijnse hoofdletter A met een trema',
Aring: 'Latijnse hoofdletter A met een corona',
AElig: 'Latijnse hoofdletter Æ',
Ccedil: 'Latijnse hoofdletter C met een cedille',
Egrave: 'Latijnse hoofdletter E met een accent grave',
Eacute: 'Latijnse hoofdletter E met een accent aigu',
Ecirc: 'Latijnse hoofdletter E met een circonflexe',
Euml: 'Latijnse hoofdletter E met een trema',
Igrave: 'Latijnse hoofdletter I met een accent grave',
Iacute: 'Latijnse hoofdletter I met een accent aigu',
Icirc: 'Latijnse hoofdletter I met een circonflexe',
Iuml: 'Latijnse hoofdletter I met een trema',
ETH: 'Latijnse hoofdletter Eth',
Ntilde: 'Latijnse hoofdletter N met een tilde',
Ograve: 'Latijnse hoofdletter O met een accent grave',
Oacute: 'Latijnse hoofdletter O met een accent aigu',
Ocirc: 'Latijnse hoofdletter O met een circonflexe',
Otilde: 'Latijnse hoofdletter O met een tilde',
Ouml: 'Latijnse hoofdletter O met een trema',
times: 'Maal-teken',
Oslash: 'Latijnse hoofdletter O met een schuine streep',
Ugrave: 'Latijnse hoofdletter U met een accent grave',
Uacute: 'Latijnse hoofdletter U met een accent aigu',
Ucirc: 'Latijnse hoofdletter U met een circonflexe',
Uuml: 'Latijnse hoofdletter U met een trema',
Yacute: 'Latijnse hoofdletter Y met een accent aigu',
THORN: 'Latijnse hoofdletter Thorn',
szlig: 'Latijnse kleine ringel-s',
agrave: 'Latijnse kleine letter a met een accent grave',
aacute: 'Latijnse kleine letter a met een accent aigu',
acirc: 'Latijnse kleine letter a met een circonflexe',
atilde: 'Latijnse kleine letter a met een tilde',
auml: 'Latijnse kleine letter a met een trema',
aring: 'Latijnse kleine letter a met een corona',
aelig: 'Latijnse kleine letter æ',
ccedil: 'Latijnse kleine letter c met een cedille',
egrave: 'Latijnse kleine letter e met een accent grave',
eacute: 'Latijnse kleine letter e met een accent aigu',
ecirc: 'Latijnse kleine letter e met een circonflexe',
euml: 'Latijnse kleine letter e met een trema',
igrave: 'Latijnse kleine letter i met een accent grave',
iacute: 'Latijnse kleine letter i met een accent aigu',
icirc: 'Latijnse kleine letter i met een circonflexe',
iuml: 'Latijnse kleine letter i met een trema',
eth: 'Latijnse kleine letter eth',
ntilde: 'Latijnse kleine letter n met een tilde',
ograve: 'Latijnse kleine letter o met een accent grave',
oacute: 'Latijnse kleine letter o met een accent aigu',
ocirc: 'Latijnse kleine letter o met een circonflexe',
otilde: 'Latijnse kleine letter o met een tilde',
ouml: 'Latijnse kleine letter o met een trema',
divide: 'Deel-teken',
oslash: 'Latijnse kleine letter o met een schuine streep',
ugrave: 'Latijnse kleine letter u met een accent grave',
uacute: 'Latijnse kleine letter u met een accent aigu',
ucirc: 'Latijnse kleine letter u met een circonflexe',
uuml: 'Latijnse kleine letter u met een trema',
yacute: 'Latijnse kleine letter y met een accent aigu',
thorn: 'Latijnse kleine letter thorn',
yuml: 'Latijnse kleine letter y met een trema',
OElig: 'Latijnse hoofdletter Œ',
oelig: 'Latijnse kleine letter œ',
'372': 'Latijnse hoofdletter W met een circonflexe',
'374': 'Latijnse hoofdletter Y met een circonflexe',
'373': 'Latijnse kleine letter w met een circonflexe',
'375': 'Latijnse kleine letter y met een circonflexe',
sbquo: 'Lage enkele aanhalingsteken',
'8219': 'Hoge omgekeerde enkele aanhalingsteken',
bdquo: 'Lage dubbele aanhalingsteken',
hellip: 'Beletselteken',
trade: 'Trademark-teken',
'9658': 'Zwarte driehoek naar rechts',
bull: 'Bullet',
rarr: 'Pijl naar rechts',
rArr: 'Dubbele pijl naar rechts',
hArr: 'Dubbele pijl naar links',
diams: 'Zwart ruitje',
asymp: 'Benaderingsteken'
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'specialchar', 'ug',
{
euro: 'ياۋرو بەلگىسى',
lsquo: 'يالاڭ پەش سول',
rsquo: 'يالاڭ پەش ئوڭ',
ldquo: 'قوش پەش سول',
rdquo: 'قوش پەش ئوڭ',
ndash: 'سىزىقچە',
mdash: 'سىزىق',
iexcl: 'ئۈندەش',
cent: 'تىيىن بەلگىسى',
pound: 'فوند ستېرلىڭ',
curren: 'پۇل بەلگىسى',
yen: 'ياپونىيە يىنى',
brvbar: 'ئۈزۈك بالداق',
sect: 'پاراگراف بەلگىسى',
uml: 'تاۋۇش ئايرىش بەلگىسى',
copy: 'نەشر ھوقۇقى بەلگىسى',
ordf: 'Feminine ordinal indicator', // MISSING
laquo: 'قوش تىرناق سول',
not: 'غەيرى بەلگە',
reg: 'خەتلەتكەن تاۋار ماركىسى',
macr: 'سوزۇش بەلگىسى',
deg: 'گىرادۇس بەلگىسى',
sup2: 'يۇقىرى ئىندېكىس 2',
sup3: 'يۇقىرى ئىندېكىس 3',
acute: 'ئۇرغۇ بەلگىسى',
micro: 'Micro sign', // MISSING
para: 'ئابزاس بەلگىسى',
middot: 'ئوتتۇرا چېكىت',
cedil: 'ئاستىغا قوشۇلىدىغان بەلگە',
sup1: 'يۇقىرى ئىندېكىس 1',
ordm: 'Masculine ordinal indicator', // MISSING
raquo: 'قوش تىرناق ئوڭ',
frac14: 'ئاددىي كەسىر تۆتتىن بىر',
frac12: 'ئاددىي كەسىر ئىككىدىن بىر',
frac34: 'ئاددىي كەسىر ئۈچتىن تۆرت',
iquest: 'Inverted question mark', // MISSING
Agrave: 'Latin capital letter A with grave accent', // MISSING
Aacute: 'Latin capital letter A with acute accent', // MISSING
Acirc: 'Latin capital letter A with circumflex', // MISSING
Atilde: 'Latin capital letter A with tilde', // MISSING
Auml: 'Latin capital letter A with diaeresis', // MISSING
Aring: 'Latin capital letter A with ring above', // MISSING
AElig: 'Latin Capital letter Æ', // MISSING
Ccedil: 'Latin capital letter C with cedilla', // MISSING
Egrave: 'Latin capital letter E with grave accent', // MISSING
Eacute: 'Latin capital letter E with acute accent', // MISSING
Ecirc: 'Latin capital letter E with circumflex', // MISSING
Euml: 'Latin capital letter E with diaeresis', // MISSING
Igrave: 'Latin capital letter I with grave accent', // MISSING
Iacute: 'Latin capital letter I with acute accent', // MISSING
Icirc: 'Latin capital letter I with circumflex', // MISSING
Iuml: 'Latin capital letter I with diaeresis', // MISSING
ETH: 'Latin capital letter Eth', // MISSING
Ntilde: 'Latin capital letter N with tilde', // MISSING
Ograve: 'قوش پەش ئوڭ',
Oacute: 'Latin capital letter O with acute accent', // MISSING
Ocirc: 'Latin capital letter O with circumflex', // MISSING
Otilde: 'Latin capital letter O with tilde', // MISSING
Ouml: 'Latin capital letter O with diaeresis', // MISSING
times: 'Multiplication sign', // MISSING
Oslash: 'Latin capital letter O with stroke', // MISSING
Ugrave: 'Latin capital letter U with grave accent', // MISSING
Uacute: 'Latin capital letter U with acute accent', // MISSING
Ucirc: 'Latin capital letter U with circumflex', // MISSING
Uuml: 'Latin capital letter U with diaeresis', // MISSING
Yacute: 'Latin capital letter Y with acute accent', // MISSING
THORN: 'Latin capital letter Thorn', // MISSING
szlig: 'Latin small letter sharp s', // MISSING
agrave: 'Latin small letter a with grave accent', // MISSING
aacute: 'Latin small letter a with acute accent', // MISSING
acirc: 'Latin small letter a with circumflex', // MISSING
atilde: 'Latin small letter a with tilde', // MISSING
auml: 'Latin small letter a with diaeresis', // MISSING
aring: 'Latin small letter a with ring above', // MISSING
aelig: 'Latin small letter æ', // MISSING
ccedil: 'Latin small letter c with cedilla', // MISSING
egrave: 'Latin small letter e with grave accent', // MISSING
eacute: 'Latin small letter e with acute accent', // MISSING
ecirc: 'Latin small letter e with circumflex', // MISSING
euml: 'Latin small letter e with diaeresis', // MISSING
igrave: 'Latin small letter i with grave accent', // MISSING
iacute: 'Latin small letter i with acute accent', // MISSING
icirc: 'Latin small letter i with circumflex', // MISSING
iuml: 'Latin small letter i with diaeresis', // MISSING
eth: 'Latin small letter eth', // MISSING
ntilde: 'تىك موللاق سوئال بەلگىسى',
ograve: 'Latin small letter o with grave accent', // MISSING
oacute: 'Latin small letter o with acute accent', // MISSING
ocirc: 'Latin small letter o with circumflex', // MISSING
otilde: 'Latin small letter o with tilde', // MISSING
ouml: 'Latin small letter o with diaeresis', // MISSING
divide: 'Division sign', // MISSING
oslash: 'Latin small letter o with stroke', // MISSING
ugrave: 'Latin small letter u with grave accent', // MISSING
uacute: 'Latin small letter u with acute accent', // MISSING
ucirc: 'Latin small letter u with circumflex', // MISSING
uuml: 'Latin small letter u with diaeresis', // MISSING
yacute: 'Latin small letter y with acute accent', // MISSING
thorn: 'Latin small letter thorn', // MISSING
yuml: 'Latin small letter y with diaeresis', // MISSING
OElig: 'Latin capital ligature OE', // MISSING
oelig: 'Latin small ligature oe', // MISSING
'372': 'Latin capital letter W with circumflex', // MISSING
'374': 'Latin capital letter Y with circumflex', // MISSING
'373': 'Latin small letter w with circumflex', // MISSING
'375': 'Latin small letter y with circumflex', // MISSING
sbquo: 'Single low-9 quotation mark', // MISSING
'8219': 'Single high-reversed-9 quotation mark', // MISSING
bdquo: 'Double low-9 quotation mark', // MISSING
hellip: 'Horizontal ellipsis', // MISSING
trade: 'Trade mark sign', // MISSING
'9658': 'Black right-pointing pointer', // MISSING
bull: 'Bullet', // MISSING
rarr: 'ئوڭ يا ئوق',
rArr: 'ئوڭ قوش سىزىق يا ئوق',
hArr: 'ئوڭ سول قوش سىزىق يا ئوق',
diams: 'ئۇيۇل غىچ',
asymp: 'تەخمىنەن تەڭ'
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'specialchar', 'it',
{
euro: 'Simbolo Euro',
lsquo: 'Virgoletta singola sinistra',
rsquo: 'Virgoletta singola destra',
ldquo: 'Virgolette aperte',
rdquo: 'Virgolette chiuse',
ndash: 'Trattino',
mdash: 'Trattino lungo',
iexcl: 'Punto esclavamativo invertito',
cent: 'Simbolo Cent',
pound: 'Simbolo Sterlina',
curren: 'Simbolo Moneta',
yen: 'Simbolo Yen',
brvbar: 'Barra interrotta',
sect: 'Simbolo di sezione',
uml: 'Dieresi',
copy: 'Simbolo Copyright',
ordf: 'Indicatore ordinale femminile',
laquo: 'Virgolette basse aperte',
not: 'Nessun segno',
reg: 'Simbolo Registrato',
macr: 'Macron',
deg: 'Simbolo Grado',
sup2: 'Apice Due',
sup3: 'Apice Tre',
acute: 'Accento acuto',
micro: 'Simbolo Micro',
para: 'Simbolo Paragrafo',
middot: 'Punto centrale',
cedil: 'Cediglia',
sup1: 'Apice Uno',
ordm: 'Indicatore ordinale maschile',
raquo: 'Virgolette basse chiuse',
frac14: 'Frazione volgare un quarto',
frac12: 'Frazione volgare un mezzo',
frac34: 'Frazione volgare tre quarti',
iquest: 'Punto interrogativo invertito',
Agrave: 'Lettera maiuscola latina A con accento grave',
Aacute: 'Lettera maiuscola latina A con accento acuto',
Acirc: 'Lettera maiuscola latina A con accento circonflesso',
Atilde: 'Lettera maiuscola latina A con tilde',
Auml: 'Lettera maiuscola latina A con dieresi',
Aring: 'Lettera maiuscola latina A con anello sopra',
AElig: 'Lettera maiuscola latina AE',
Ccedil: 'Lettera maiuscola latina C con cediglia',
Egrave: 'Lettera maiuscola latina E con accento grave',
Eacute: 'Lettera maiuscola latina E con accento acuto',
Ecirc: 'Lettera maiuscola latina E con accento circonflesso',
Euml: 'Lettera maiuscola latina E con dieresi',
Igrave: 'Lettera maiuscola latina I con accento grave',
Iacute: 'Lettera maiuscola latina I con accento acuto',
Icirc: 'Lettera maiuscola latina I con accento circonflesso',
Iuml: 'Lettera maiuscola latina I con dieresi',
ETH: 'Lettera maiuscola latina Eth',
Ntilde: 'Lettera maiuscola latina N con tilde',
Ograve: 'Lettera maiuscola latina O con accento grave',
Oacute: 'Lettera maiuscola latina O con accento acuto',
Ocirc: 'Lettera maiuscola latina O con accento circonflesso',
Otilde: 'Lettera maiuscola latina O con tilde',
Ouml: 'Lettera maiuscola latina O con dieresi',
times: 'Simbolo di moltiplicazione',
Oslash: 'Lettera maiuscola latina O barrata',
Ugrave: 'Lettera maiuscola latina U con accento grave',
Uacute: 'Lettera maiuscola latina U con accento acuto',
Ucirc: 'Lettera maiuscola latina U con accento circonflesso',
Uuml: 'Lettera maiuscola latina U con accento circonflesso',
Yacute: 'Lettera maiuscola latina Y con accento acuto',
THORN: 'Lettera maiuscola latina Thorn',
szlig: 'Lettera latina minuscola doppia S',
agrave: 'Lettera minuscola latina a con accento grave',
aacute: 'Lettera minuscola latina a con accento acuto',
acirc: 'Lettera minuscola latina a con accento circonflesso',
atilde: 'Lettera minuscola latina a con tilde',
auml: 'Lettera minuscola latina a con dieresi',
aring: 'Lettera minuscola latina a con anello superiore',
aelig: 'Lettera minuscola latina ae',
ccedil: 'Lettera minuscola latina c con cediglia',
egrave: 'Lettera minuscola latina e con accento grave',
eacute: 'Lettera minuscola latina e con accento acuto',
ecirc: 'Lettera minuscola latina e con accento circonflesso',
euml: 'Lettera minuscola latina e con dieresi',
igrave: 'Lettera minuscola latina i con accento grave',
iacute: 'Lettera minuscola latina i con accento acuto',
icirc: 'Lettera minuscola latina i con accento circonflesso',
iuml: 'Lettera minuscola latina i con dieresi',
eth: 'Lettera minuscola latina eth',
ntilde: 'Lettera minuscola latina n con tilde',
ograve: 'Lettera minuscola latina o con accento grave',
oacute: 'Lettera minuscola latina o con accento acuto',
ocirc: 'Lettera minuscola latina o con accento circonflesso',
otilde: 'Lettera minuscola latina o con tilde',
ouml: 'Lettera minuscola latina o con dieresi',
divide: 'Simbolo di divisione',
oslash: 'Lettera minuscola latina o barrata',
ugrave: 'Lettera minuscola latina u con accento grave',
uacute: 'Lettera minuscola latina u con accento acuto',
ucirc: 'Lettera minuscola latina u con accento circonflesso',
uuml: 'Lettera minuscola latina u con dieresi',
yacute: 'Lettera minuscola latina y con accento acuto',
thorn: 'Lettera minuscola latina thorn',
yuml: 'Lettera minuscola latina y con dieresi',
OElig: 'Legatura maiuscola latina OE',
oelig: 'Legatura minuscola latina oe',
'372': 'Lettera maiuscola latina W con accento circonflesso',
'374': 'Lettera maiuscola latina Y con accento circonflesso',
'373': 'Lettera minuscola latina w con accento circonflesso',
'375': 'Lettera minuscola latina y con accento circonflesso',
sbquo: 'Singola virgoletta bassa low-9',
'8219': 'Singola virgoletta bassa low-9 inversa',
bdquo: 'Doppia virgoletta bassa low-9',
hellip: 'Ellissi orizzontale',
trade: 'Simbolo TM',
'9658': 'Puntatore nero rivolto verso destra',
bull: 'Punto',
rarr: 'Freccia verso destra',
rArr: 'Doppia freccia verso destra',
hArr: 'Doppia freccia sinistra destra',
diams: 'Simbolo nero diamante',
asymp: 'Quasi uguale a'
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'specialchar', 'de',
{
euro: 'Euro Zeichen',
lsquo: 'Hochkomma links',
rsquo: 'Hochkomma rechts',
ldquo: 'Anführungszeichen links',
rdquo: 'Anführungszeichen rechts',
ndash: 'kleiner Strich',
mdash: 'mittlerer Strich',
iexcl: 'invertiertes Ausrufezeichen',
cent: 'Cent',
pound: 'Pfund',
curren: 'Währung',
yen: 'Yen',
brvbar: 'gestrichelte Linie',
sect: '§ Zeichen',
uml: 'Diäresis',
copy: 'Copyright',
ordf: 'Feminine ordinal Anzeige',
laquo: 'Nach links zeigenden Doppel-Winkel Anführungszeichen',
not: 'Not-Zeichen',
reg: 'Registriert',
macr: 'Längezeichen',
deg: 'Grad',
sup2: 'Hoch 2',
sup3: 'Hoch 3',
acute: 'Akzentzeichen ',
micro: 'Micro',
para: 'Pilcrow-Zeichen',
middot: 'Mittelpunkt',
cedil: 'Cedilla',
sup1: 'Hoch 1',
ordm: 'Männliche Ordnungszahl Anzeige',
raquo: 'Nach rechts zeigenden Doppel-Winkel Anführungszeichen',
frac14: 'ein Viertel',
frac12: 'Hälfte',
frac34: 'Dreiviertel',
iquest: 'Umgekehrtes Fragezeichen',
Agrave: 'Lateinischer Buchstabe A mit AkzentGrave',
Aacute: 'Lateinischer Buchstabe A mit Akutakzent',
Acirc: 'Lateinischer Buchstabe A mit Zirkumflex',
Atilde: 'Lateinischer Buchstabe A mit Tilde',
Auml: 'Lateinischer Buchstabe A mit Trema',
Aring: 'Lateinischer Buchstabe A mit Ring oben',
AElig: 'Lateinischer Buchstabe Æ',
Ccedil: 'Lateinischer Buchstabe C mit Cedille',
Egrave: 'Lateinischer Buchstabe E mit AkzentGrave',
Eacute: 'Lateinischer Buchstabe E mit Akutakzent',
Ecirc: 'Lateinischer Buchstabe E mit Zirkumflex',
Euml: 'Lateinischer Buchstabe E Trema',
Igrave: 'Lateinischer Buchstabe I mit AkzentGrave',
Iacute: 'Lateinischer Buchstabe I mit Akutakzent',
Icirc: 'Lateinischer Buchstabe I mit Zirkumflex',
Iuml: 'Lateinischer Buchstabe I mit Trema',
ETH: 'Lateinischer Buchstabe Eth',
Ntilde: 'Lateinischer Buchstabe N mit Tilde',
Ograve: 'Lateinischer Buchstabe O mit AkzentGrave',
Oacute: 'Lateinischer Buchstabe O mit Akutakzent',
Ocirc: 'Lateinischer Buchstabe O mit Zirkumflex',
Otilde: 'Lateinischer Buchstabe O mit Tilde',
Ouml: 'Lateinischer Buchstabe O mit Trema',
times: 'Multiplikation',
Oslash: 'Lateinischer Buchstabe O durchgestrichen',
Ugrave: 'Lateinischer Buchstabe U mit Akzentgrave',
Uacute: 'Lateinischer Buchstabe U mit Akutakzent',
Ucirc: 'Lateinischer Buchstabe U mit Zirkumflex',
Uuml: 'Lateinischer Buchstabe a mit Trema',
Yacute: 'Lateinischer Buchstabe a mit Akzent',
THORN: 'Lateinischer Buchstabe mit Dorn',
szlig: 'Kleiner lateinischer Buchstabe scharfe s',
agrave: 'Kleiner lateinischer Buchstabe a mit Accent grave',
aacute: 'Kleiner lateinischer Buchstabe a mit Akut',
acirc: 'Lateinischer Buchstabe a mit Zirkumflex',
atilde: 'Lateinischer Buchstabe a mit Tilde',
auml: 'Kleiner lateinischer Buchstabe a mit Trema',
aring: 'Kleiner lateinischer Buchstabe a mit Ring oben',
aelig: 'Lateinischer Buchstabe æ',
ccedil: 'Kleiner lateinischer Buchstabe c mit Cedille',
egrave: 'Kleiner lateinischer Buchstabe e mit Accent grave',
eacute: 'Kleiner lateinischer Buchstabe e mit Akut',
ecirc: 'Kleiner lateinischer Buchstabe e mit Zirkumflex',
euml: 'Kleiner lateinischer Buchstabe e mit Trema',
igrave: 'Kleiner lateinischer Buchstabe i mit AkzentGrave',
iacute: 'Kleiner lateinischer Buchstabe i mit Akzent',
icirc: 'Kleiner lateinischer Buchstabe i mit Zirkumflex',
iuml: 'Kleiner lateinischer Buchstabe i mit Trema',
eth: 'Kleiner lateinischer Buchstabe eth',
ntilde: 'Kleiner lateinischer Buchstabe n mit Tilde',
ograve: 'Kleiner lateinischer Buchstabe o mit Accent grave',
oacute: 'Kleiner lateinischer Buchstabe o mit Akzent',
ocirc: 'Kleiner lateinischer Buchstabe o mit Zirkumflex',
otilde: 'Lateinischer Buchstabe i mit Tilde',
ouml: 'Kleiner lateinischer Buchstabe o mit Trema',
divide: 'Divisionszeichen',
oslash: 'Kleiner lateinischer Buchstabe o durchgestrichen',
ugrave: 'Kleiner lateinischer Buchstabe u mit Accent grave',
uacute: 'Kleiner lateinischer Buchstabe u mit Akut',
ucirc: 'Kleiner lateinischer Buchstabe u mit Zirkumflex',
uuml: 'Kleiner lateinischer Buchstabe u mit Trema',
yacute: 'Kleiner lateinischer Buchstabe y mit Akut',
thorn: 'Kleiner lateinischer Buchstabe Dorn',
yuml: 'Kleiner lateinischer Buchstabe y mit Trema',
OElig: 'Lateinischer Buchstabe Ligatur OE',
oelig: 'Kleiner lateinischer Buchstabe Ligatur OE',
'372': 'Lateinischer Buchstabe W mit Zirkumflex',
'374': 'Lateinischer Buchstabe Y mit Zirkumflex',
'373': 'Kleiner lateinischer Buchstabe w mit Zirkumflex',
'375': 'Kleiner lateinischer Buchstabe y mit Zirkumflex',
sbquo: 'Tiefergestelltes Komma',
'8219': 'Rumgedrehtes Komma',
bdquo: 'Doppeltes Anführungszeichen unten',
hellip: 'horizontale Auslassungspunkte',
trade: 'Handelszeichen',
'9658': 'Dreickspfeil rechts',
bull: 'Bullet',
rarr: 'Pfeil rechts',
rArr: 'Doppelpfeil rechts',
hArr: 'Doppelpfeil links',
diams: 'Karo',
asymp: 'Ungefähr'
});
| JavaScript |
/*
Copyright (c) 2003-2012, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'specialchar', 'hr',
{
euro: 'Euro znak',
lsquo: 'Lijevi jednostruki navodnik',
rsquo: 'Desni jednostruki navodnik',
ldquo: 'Lijevi dvostruki navodnik',
rdquo: 'Desni dvostruki navodnik',
ndash: 'En crtica',
mdash: 'Em crtica',
iexcl: 'Naopaki uskličnik',
cent: 'Cent znak',
pound: 'Funta znak',
curren: 'Znak valute',
yen: 'Yen znak',
brvbar: 'Potrgana prečka',
sect: 'Znak odjeljka',
uml: 'Diaeresis', // MISSING
copy: 'Copyright znak',
ordf: 'Feminine ordinal indicator', // MISSING
laquo: 'Lijevi dvostruki uglati navodnik',
not: 'Not znak',
reg: 'Registered znak',
macr: 'Macron', // MISSING
deg: 'Stupanj znak',
sup2: 'Superscript two', // MISSING
sup3: 'Superscript three', // MISSING
acute: 'Acute accent', // MISSING
micro: 'Micro sign', // MISSING
para: 'Pilcrow sign', // MISSING
middot: 'Srednja točka',
cedil: 'Cedilla', // MISSING
sup1: 'Superscript one', // MISSING
ordm: 'Masculine ordinal indicator', // MISSING
raquo: 'Desni dvostruku uglati navodnik',
frac14: 'Vulgar fraction one quarter', // MISSING
frac12: 'Vulgar fraction one half', // MISSING
frac34: 'Vulgar fraction three quarters', // MISSING
iquest: 'Naopaki upitnik',
Agrave: 'Veliko latinsko slovo A s akcentom',
Aacute: 'Latin capital letter A with acute accent', // MISSING
Acirc: 'Latin capital letter A with circumflex', // MISSING
Atilde: 'Latin capital letter A with tilde', // MISSING
Auml: 'Latin capital letter A with diaeresis', // MISSING
Aring: 'Latin capital letter A with ring above', // MISSING
AElig: 'Latin Capital letter Æ', // MISSING
Ccedil: 'Latin capital letter C with cedilla', // MISSING
Egrave: 'Latin capital letter E with grave accent', // MISSING
Eacute: 'Latin capital letter E with acute accent', // MISSING
Ecirc: 'Latin capital letter E with circumflex', // MISSING
Euml: 'Latin capital letter E with diaeresis', // MISSING
Igrave: 'Latin capital letter I with grave accent', // MISSING
Iacute: 'Latin capital letter I with acute accent', // MISSING
Icirc: 'Latin capital letter I with circumflex', // MISSING
Iuml: 'Latin capital letter I with diaeresis', // MISSING
ETH: 'Latin capital letter Eth', // MISSING
Ntilde: 'Latin capital letter N with tilde', // MISSING
Ograve: 'Latin capital letter O with grave accent', // MISSING
Oacute: 'Latin capital letter O with acute accent', // MISSING
Ocirc: 'Latin capital letter O with circumflex', // MISSING
Otilde: 'Latin capital letter O with tilde', // MISSING
Ouml: 'Latin capital letter O with diaeresis', // MISSING
times: 'Multiplication sign', // MISSING
Oslash: 'Latin capital letter O with stroke', // MISSING
Ugrave: 'Latin capital letter U with grave accent', // MISSING
Uacute: 'Latin capital letter U with acute accent', // MISSING
Ucirc: 'Latin capital letter U with circumflex', // MISSING
Uuml: 'Latin capital letter U with diaeresis', // MISSING
Yacute: 'Latin capital letter Y with acute accent', // MISSING
THORN: 'Latin capital letter Thorn', // MISSING
szlig: 'Latin small letter sharp s', // MISSING
agrave: 'Latin small letter a with grave accent', // MISSING
aacute: 'Latin small letter a with acute accent', // MISSING
acirc: 'Latin small letter a with circumflex', // MISSING
atilde: 'Latin small letter a with tilde', // MISSING
auml: 'Latin small letter a with diaeresis', // MISSING
aring: 'Latin small letter a with ring above', // MISSING
aelig: 'Latin small letter æ', // MISSING
ccedil: 'Latin small letter c with cedilla', // MISSING
egrave: 'Latin small letter e with grave accent', // MISSING
eacute: 'Latin small letter e with acute accent', // MISSING
ecirc: 'Latin small letter e with circumflex', // MISSING
euml: 'Latin small letter e with diaeresis', // MISSING
igrave: 'Latin small letter i with grave accent', // MISSING
iacute: 'Latin small letter i with acute accent', // MISSING
icirc: 'Latin small letter i with circumflex', // MISSING
iuml: 'Latin small letter i with diaeresis', // MISSING
eth: 'Latin small letter eth', // MISSING
ntilde: 'Latin small letter n with tilde', // MISSING
ograve: 'Latin small letter o with grave accent', // MISSING
oacute: 'Latin small letter o with acute accent', // MISSING
ocirc: 'Latin small letter o with circumflex', // MISSING
otilde: 'Latin small letter o with tilde', // MISSING
ouml: 'Latin small letter o with diaeresis', // MISSING
divide: 'Division sign', // MISSING
oslash: 'Latin small letter o with stroke', // MISSING
ugrave: 'Latin small letter u with grave accent', // MISSING
uacute: 'Latin small letter u with acute accent', // MISSING
ucirc: 'Latin small letter u with circumflex', // MISSING
uuml: 'Latin small letter u with diaeresis', // MISSING
yacute: 'Latin small letter y with acute accent', // MISSING
thorn: 'Latin small letter thorn', // MISSING
yuml: 'Latin small letter y with diaeresis', // MISSING
OElig: 'Latin capital ligature OE', // MISSING
oelig: 'Latin small ligature oe', // MISSING
'372': 'Latin capital letter W with circumflex', // MISSING
'374': 'Latin capital letter Y with circumflex', // MISSING
'373': 'Latin small letter w with circumflex', // MISSING
'375': 'Latin small letter y with circumflex', // MISSING
sbquo: 'Single low-9 quotation mark', // MISSING
'8219': 'Single high-reversed-9 quotation mark', // MISSING
bdquo: 'Double low-9 quotation mark', // MISSING
hellip: 'Horizontal ellipsis', // MISSING
trade: 'Trade mark sign', // MISSING
'9658': 'Black right-pointing pointer', // MISSING
bull: 'Bullet', // MISSING
rarr: 'Rightwards arrow', // MISSING
rArr: 'Rightwards double arrow', // MISSING
hArr: 'Left right double arrow', // MISSING
diams: 'Black diamond suit', // MISSING
asymp: 'Almost equal to' // MISSING
});
| JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.