1 /**

     2  * Compiled inline version. (Library mode)

     3  */

     4 

     5 /*jshint smarttabs:true, undef:true, latedef:true, curly:true, bitwise:true, camelcase:true */

     6 /*globals $code */

     7 

     8 (function(exports, undefined) {

     9 	"use strict";

    10 

    11 	var modules = {};

    12 

    13 	function require(ids, callback) {

    14 		var module, defs = [];

    15 

    16 		for (var i = 0; i < ids.length; ++i) {

    17 			module = modules[ids[i]] || resolve(ids[i]);

    18 			if (!module) {

    19 				throw 'module definition dependecy not found: ' + ids[i];

    20 			}

    21 

    22 			defs.push(module);

    23 		}

    24 

    25 		callback.apply(null, defs);

    26 	}

    27 

    28 	function define(id, dependencies, definition) {

    29 		if (typeof id !== 'string') {

    30 			throw 'invalid module definition, module id must be defined and be a string';

    31 		}

    32 

    33 		if (dependencies === undefined) {

    34 			throw 'invalid module definition, dependencies must be specified';

    35 		}

    36 

    37 		if (definition === undefined) {

    38 			throw 'invalid module definition, definition function must be specified';

    39 		}

    40 

    41 		require(dependencies, function() {

    42 			modules[id] = definition.apply(null, arguments);

    43 		});

    44 	}

    45 

    46 	function defined(id) {

    47 		return !!modules[id];

    48 	}

    49 

    50 	function resolve(id) {

    51 		var target = exports;

    52 		var fragments = id.split(/[.\/]/);

    53 

    54 		for (var fi = 0; fi < fragments.length; ++fi) {

    55 			if (!target[fragments[fi]]) {

    56 				return;

    57 			}

    58 

    59 			target = target[fragments[fi]];

    60 		}

    61 

    62 		return target;

    63 	}

    64 

    65 	function expose(ids) {

    66 		for (var i = 0; i < ids.length; i++) {

    67 			var target = exports;

    68 			var id = ids[i];

    69 			var fragments = id.split(/[.\/]/);

    70 

    71 			for (var fi = 0; fi < fragments.length - 1; ++fi) {

    72 				if (target[fragments[fi]] === undefined) {

    73 					target[fragments[fi]] = {};

    74 				}

    75 

    76 				target = target[fragments[fi]];

    77 			}

    78 

    79 			target[fragments[fragments.length - 1]] = modules[id];

    80 		}

    81 	}

    82 

    83 // Included from: js/tinymce/plugins/paste/classes/Utils.js

    84 

    85 /**

    86  * Utils.js

    87  *

    88  * Copyright, Moxiecode Systems AB

    89  * Released under LGPL License.

    90  *

    91  * License: http://www.tinymce.com/license

    92  * Contributing: http://www.tinymce.com/contributing

    93  */

    94 

    95 /**

    96  * This class contails various utility functions for the paste plugin.

    97  *

    98  * @class tinymce.pasteplugin.Utils

    99  */

   100 define("tinymce/pasteplugin/Utils", [

   101 	"tinymce/util/Tools",

   102 	"tinymce/html/DomParser",

   103 	"tinymce/html/Schema"

   104 ], function(Tools, DomParser, Schema) {

   105 	function filter(content, items) {

   106 		Tools.each(items, function(v) {

   107 			if (v.constructor == RegExp) {

   108 				content = content.replace(v, '');

   109 			} else {

   110 				content = content.replace(v[0], v[1]);

   111 			}

   112 		});

   113 

   114 		return content;

   115 	}

   116 

   117 	/**

   118 	 * Gets the innerText of the specified element. It will handle edge cases

   119 	 * and works better than textContent on Gecko.

   120 	 *

   121 	 * @param {String} html HTML string to get text from.

   122 	 * @return {String} String of text with line feeds.

   123 	 */

   124 	function innerText(html) {

   125 		var schema = new Schema(), domParser = new DomParser({}, schema), text = '';

   126 		var shortEndedElements = schema.getShortEndedElements();

   127 		var ignoreElements = Tools.makeMap('script noscript style textarea video audio iframe object', ' ');

   128 		var blockElements = schema.getBlockElements();

   129 

   130 		function walk(node) {

   131 			var name = node.name, currentNode = node;

   132 

   133 			if (name === 'br') {

   134 				text += '\n';

   135 				return;

   136 			}

   137 

   138 			// img/input/hr

   139 			if (shortEndedElements[name]) {

   140 				text += ' ';

   141 			}

   142 

   143 			// Ingore script, video contents

   144 			if (ignoreElements[name]) {

   145 				text += ' ';

   146 				return;

   147 			}

   148 

   149 			if (node.type == 3) {

   150 				text += node.value;

   151 			}

   152 

   153 			// Walk all children

   154 			if (!node.shortEnded) {

   155 				if ((node = node.firstChild)) {

   156 					do {

   157 						walk(node);

   158 					} while ((node = node.next));

   159 				}

   160 			}

   161 

   162 			// Add \n or \n\n for blocks or P

   163 			if (blockElements[name] && currentNode.next) {

   164 				text += '\n';

   165 

   166 				if (name == 'p') {

   167 					text += '\n';

   168 				}

   169 			}

   170 		}

   171 

   172 		html = filter(html, [

   173 			/<!\[[^\]]+\]>/g // Conditional comments

   174 		]);

   175 

   176 		walk(domParser.parse(html));

   177 

   178 		return text;

   179 	}

   180 

   181 	/**

   182 	 * Trims the specified HTML by removing all WebKit fragments, all elements wrapping the body trailing BR elements etc.

   183 	 *

   184 	 * @param {String} html Html string to trim contents on.

   185 	 * @return {String} Html contents that got trimmed.

   186 	 */

   187 	function trimHtml(html) {

   188 		function trimSpaces(all, s1, s2) {

   189 			// WebKit   meant to preserve multiple spaces but instead inserted around all inline tags,

   190 			// including the spans with inline styles created on paste

   191 			if (!s1 && !s2) {

   192 				return ' ';

   193 			}

   194 

   195 			return '\u00a0';

   196 		}

   197 

   198 		html = filter(html, [

   199 			/^[\s\S]*<body[^>]*>\s*|\s*<\/body[^>]*>[\s\S]*$/g, // Remove anything but the contents within the BODY element

   200 			/<!--StartFragment-->|<!--EndFragment-->/g, // Inner fragments (tables from excel on mac)

   201 			[/( ?)<span class="Apple-converted-space">\u00a0<\/span>( ?)/g, trimSpaces],

   202 			/<br>$/i // Trailing BR elements

   203 		]);

   204 

   205 		return html;

   206 	}

   207 

   208 	return {

   209 		filter: filter,

   210 		innerText: innerText,

   211 		trimHtml: trimHtml

   212 	};

   213 });

   214 

   215 // Included from: js/tinymce/plugins/paste/classes/Clipboard.js

   216 

   217 /**

   218  * Clipboard.js

   219  *

   220  * Copyright, Moxiecode Systems AB

   221  * Released under LGPL License.

   222  *

   223  * License: http://www.tinymce.com/license

   224  * Contributing: http://www.tinymce.com/contributing

   225  */

   226 

   227 /**

   228  * This class contains logic for getting HTML contents out of the clipboard.

   229  *

   230  * We need to make a lot of ugly hacks to get the contents out of the clipboard since

   231  * the W3C Clipboard API is broken in all browsers that have it: Gecko/WebKit/Blink.

   232  * We might rewrite this the way those API:s stabilize. Browsers doesn't handle pasting

   233  * from applications like Word the same way as it does when pasting into a contentEditable area

   234  * so we need to do lots of extra work to try to get to this clipboard data.

   235  *

   236  * Current implementation steps:

   237  *  1. On keydown with paste keys Ctrl+V or Shift+Insert create

   238  *     a paste bin element and move focus to that element.

   239  *  2. Wait for the browser to fire a "paste" event and get the contents out of the paste bin.

   240  *  3. Check if the paste was successful if true, process the HTML.

   241  *  (4). If the paste was unsuccessful use IE execCommand, Clipboard API, document.dataTransfer old WebKit API etc.

   242  *

   243  * @class tinymce.pasteplugin.Clipboard

   244  * @private

   245  */

   246 define("tinymce/pasteplugin/Clipboard", [

   247 	"tinymce/Env",

   248 	"tinymce/dom/RangeUtils",

   249 	"tinymce/util/VK",

   250 	"tinymce/pasteplugin/Utils"

   251 ], function(Env, RangeUtils, VK, Utils) {

   252 	return function(editor) {

   253 		var self = this, pasteBinElm, lastRng, keyboardPasteTimeStamp = 0, draggingInternally = false;

   254 		var pasteBinDefaultContent = '%MCEPASTEBIN%', keyboardPastePlainTextState;

   255 		var mceInternalUrlPrefix = 'data:text/mce-internal,';

   256 

   257 		/**

   258 		 * Pastes the specified HTML. This means that the HTML is filtered and then

   259 		 * inserted at the current selection in the editor. It will also fire paste events

   260 		 * for custom user filtering.

   261 		 *

   262 		 * @param {String} html HTML code to paste into the current selection.

   263 		 */

   264 		function pasteHtml(html) {

   265 			var args, dom = editor.dom;

   266 

   267 			args = editor.fire('BeforePastePreProcess', {content: html}); // Internal event used by Quirks

   268 			args = editor.fire('PastePreProcess', args);

   269 			html = args.content;

   270 

   271 			if (!args.isDefaultPrevented()) {

   272 				// User has bound PastePostProcess events then we need to pass it through a DOM node

   273 				// This is not ideal but we don't want to let the browser mess up the HTML for example

   274 				// some browsers add   to P tags etc

   275 				if (editor.hasEventListeners('PastePostProcess') && !args.isDefaultPrevented()) {

   276 					// We need to attach the element to the DOM so Sizzle selectors work on the contents

   277 					var tempBody = dom.add(editor.getBody(), 'div', {style: 'display:none'}, html);

   278 					args = editor.fire('PastePostProcess', {node: tempBody});

   279 					dom.remove(tempBody);

   280 					html = args.node.innerHTML;

   281 				}

   282 

   283 				if (!args.isDefaultPrevented()) {

   284 					editor.insertContent(html, {merge: editor.settings.paste_merge_formats !== false});

   285 				}

   286 			}

   287 		}

   288 

   289 		/**

   290 		 * Pastes the specified text. This means that the plain text is processed

   291 		 * and converted into BR and P elements. It will fire paste events for custom filtering.

   292 		 *

   293 		 * @param {String} text Text to paste as the current selection location.

   294 		 */

   295 		function pasteText(text) {

   296 			text = editor.dom.encode(text).replace(/\r\n/g, '\n');

   297 

   298 			var startBlock = editor.dom.getParent(editor.selection.getStart(), editor.dom.isBlock);

   299 

   300 			// Create start block html for example <p attr="value">

   301 			var forcedRootBlockName = editor.settings.forced_root_block;

   302 			var forcedRootBlockStartHtml;

   303 			if (forcedRootBlockName) {

   304 				forcedRootBlockStartHtml = editor.dom.createHTML(forcedRootBlockName, editor.settings.forced_root_block_attrs);

   305 				forcedRootBlockStartHtml = forcedRootBlockStartHtml.substr(0, forcedRootBlockStartHtml.length - 3) + '>';

   306 			}

   307 

   308 			if ((startBlock && /^(PRE|DIV)$/.test(startBlock.nodeName)) || !forcedRootBlockName) {

   309 				text = Utils.filter(text, [

   310 					[/\n/g, "<br>"]

   311 				]);

   312 			} else {

   313 				text = Utils.filter(text, [

   314 					[/\n\n/g, "</p>" + forcedRootBlockStartHtml],

   315 					[/^(.*<\/p>)(<p>)$/, forcedRootBlockStartHtml + '$1'],

   316 					[/\n/g, "<br />"]

   317 				]);

   318 

   319 				if (text.indexOf('<p>') != -1) {

   320 					text = forcedRootBlockStartHtml + text;

   321 				}

   322 			}

   323 

   324 			pasteHtml(text);

   325 		}

   326 

   327 		/**

   328 		 * Creates a paste bin element as close as possible to the current caret location and places the focus inside that element

   329 		 * so that when the real paste event occurs the contents gets inserted into this element

   330 		 * instead of the current editor selection element.

   331 		 */

   332 		function createPasteBin() {

   333 			var dom = editor.dom, body = editor.getBody();

   334 			var viewport = editor.dom.getViewPort(editor.getWin()), scrollTop = viewport.y, top = 20;

   335 			var scrollContainer;

   336 

   337 			lastRng = editor.selection.getRng();

   338 

   339 			if (editor.inline) {

   340 				scrollContainer = editor.selection.getScrollContainer();

   341 

   342 				// Can't always rely on scrollTop returning a useful value.

   343 				// It returns 0 if the browser doesn't support scrollTop for the element or is non-scrollable

   344 				if (scrollContainer && scrollContainer.scrollTop > 0) {

   345 					scrollTop = scrollContainer.scrollTop;

   346 				}

   347 			}

   348 

   349 			/**

   350 			 * Returns the rect of the current caret if the caret is in an empty block before a

   351 			 * BR we insert a temporary invisible character that we get the rect this way we always get a proper rect.

   352 			 *

   353 			 * TODO: This might be useful in core.

   354 			 */

   355 			function getCaretRect(rng) {

   356 				var rects, textNode, node, container = rng.startContainer;

   357 

   358 				rects = rng.getClientRects();

   359 				if (rects.length) {

   360 					return rects[0];

   361 				}

   362 

   363 				if (!rng.collapsed || container.nodeType != 1) {

   364 					return;

   365 				}

   366 

   367 				node = container.childNodes[lastRng.startOffset];

   368 

   369 				// Skip empty whitespace nodes

   370 				while (node && node.nodeType == 3 && !node.data.length) {

   371 					node = node.nextSibling;

   372 				}

   373 

   374 				if (!node) {

   375 					return;

   376 				}

   377 

   378 				// Check if the location is |<br>

   379 				// TODO: Might need to expand this to say |<table>

   380 				if (node.tagName == 'BR') {

   381 					textNode = dom.doc.createTextNode('\uFEFF');

   382 					node.parentNode.insertBefore(textNode, node);

   383 

   384 					rng = dom.createRng();

   385 					rng.setStartBefore(textNode);

   386 					rng.setEndAfter(textNode);

   387 

   388 					rects = rng.getClientRects();

   389 					dom.remove(textNode);

   390 				}

   391 

   392 				if (rects.length) {

   393 					return rects[0];

   394 				}

   395 			}

   396 

   397 			// Calculate top cordinate this is needed to avoid scrolling to top of document

   398 			// We want the paste bin to be as close to the caret as possible to avoid scrolling

   399 			if (lastRng.getClientRects) {

   400 				var rect = getCaretRect(lastRng);

   401 

   402 				if (rect) {

   403 					// Client rects gets us closes to the actual

   404 					// caret location in for example a wrapped paragraph block

   405 					top = scrollTop + (rect.top - dom.getPos(body).y);

   406 				} else {

   407 					top = scrollTop;

   408 

   409 					// Check if we can find a closer location by checking the range element

   410 					var container = lastRng.startContainer;

   411 					if (container) {

   412 						if (container.nodeType == 3 && container.parentNode != body) {

   413 							container = container.parentNode;

   414 						}

   415 

   416 						if (container.nodeType == 1) {

   417 							top = dom.getPos(container, scrollContainer || body).y;

   418 						}

   419 					}

   420 				}

   421 			}

   422 

   423 			// Create a pastebin

   424 			pasteBinElm = dom.add(editor.getBody(), 'div', {

   425 				id: "mcepastebin",

   426 				contentEditable: true,

   427 				"data-mce-bogus": "all",

   428 				style: 'position: absolute; top: ' + top + 'px;' +

   429 					'width: 10px; height: 10px; overflow: hidden; opacity: 0'

   430 			}, pasteBinDefaultContent);

   431 

   432 			// Move paste bin out of sight since the controlSelection rect gets displayed otherwise on IE and Gecko

   433 			if (Env.ie || Env.gecko) {

   434 				dom.setStyle(pasteBinElm, 'left', dom.getStyle(body, 'direction', true) == 'rtl' ? 0xFFFF : -0xFFFF);

   435 			}

   436 

   437 			// Prevent focus events from bubbeling fixed FocusManager issues

   438 			dom.bind(pasteBinElm, 'beforedeactivate focusin focusout', function(e) {

   439 				e.stopPropagation();

   440 			});

   441 

   442 			pasteBinElm.focus();

   443 			editor.selection.select(pasteBinElm, true);

   444 		}

   445 

   446 		/**

   447 		 * Removes the paste bin if it exists.

   448 		 */

   449 		function removePasteBin() {

   450 			if (pasteBinElm) {

   451 				var pasteBinClone;

   452 

   453 				// WebKit/Blink might clone the div so

   454 				// lets make sure we remove all clones

   455 				// TODO: Man o man is this ugly. WebKit is the new IE! Remove this if they ever fix it!

   456 				while ((pasteBinClone = editor.dom.get('mcepastebin'))) {

   457 					editor.dom.remove(pasteBinClone);

   458 					editor.dom.unbind(pasteBinClone);

   459 				}

   460 

   461 				if (lastRng) {

   462 					editor.selection.setRng(lastRng);

   463 				}

   464 			}

   465 

   466 			pasteBinElm = lastRng = null;

   467 		}

   468 

   469 		/**

   470 		 * Returns the contents of the paste bin as a HTML string.

   471 		 *

   472 		 * @return {String} Get the contents of the paste bin.

   473 		 */

   474 		function getPasteBinHtml() {

   475 			var html = '', pasteBinClones, i, clone, cloneHtml;

   476 

   477 			// Since WebKit/Chrome might clone the paste bin when pasting

   478 			// for example: <img style="float: right"> we need to check if any of them contains some useful html.

   479 			// TODO: Man o man is this ugly. WebKit is the new IE! Remove this if they ever fix it!

   480 			pasteBinClones = editor.dom.select('div[id=mcepastebin]');

   481 			for (i = 0; i < pasteBinClones.length; i++) {

   482 				clone = pasteBinClones[i];

   483 

   484 				// Pasting plain text produces pastebins in pastebinds makes sence right!?

   485 				if (clone.firstChild && clone.firstChild.id == 'mcepastebin') {

   486 					clone = clone.firstChild;

   487 				}

   488 

   489 				cloneHtml = clone.innerHTML;

   490 				if (html != pasteBinDefaultContent) {

   491 					html += cloneHtml;

   492 				}

   493 			}

   494 

   495 			return html;

   496 		}

   497 

   498 		/**

   499 		 * Gets various content types out of a datatransfer object.

   500 		 *

   501 		 * @param {DataTransfer} dataTransfer Event fired on paste.

   502 		 * @return {Object} Object with mime types and data for those mime types.

   503 		 */

   504 		function getDataTransferItems(dataTransfer) {

   505 			var data = {};

   506 

   507 			if (dataTransfer) {

   508 				// Use old WebKit/IE API

   509 				if (dataTransfer.getData) {

   510 					var legacyText = dataTransfer.getData('Text');

   511 					if (legacyText && legacyText.length > 0) {

   512 						if (legacyText.indexOf(mceInternalUrlPrefix) == -1) {

   513 							data['text/plain'] = legacyText;

   514 						}

   515 					}

   516 				}

   517 

   518 				if (dataTransfer.types) {

   519 					for (var i = 0; i < dataTransfer.types.length; i++) {

   520 						var contentType = dataTransfer.types[i];

   521 						data[contentType] = dataTransfer.getData(contentType);

   522 					}

   523 				}

   524 			}

   525 

   526 			return data;

   527 		}

   528 

   529 		/**

   530 		 * Gets various content types out of the Clipboard API. It will also get the

   531 		 * plain text using older IE and WebKit API:s.

   532 		 *

   533 		 * @param {ClipboardEvent} clipboardEvent Event fired on paste.

   534 		 * @return {Object} Object with mime types and data for those mime types.

   535 		 */

   536 		function getClipboardContent(clipboardEvent) {

   537 			return getDataTransferItems(clipboardEvent.clipboardData || editor.getDoc().dataTransfer);

   538 		}

   539 

   540 		/**

   541 		 * Checks if the clipboard contains image data if it does it will take that data

   542 		 * and convert it into a data url image and paste that image at the caret location.

   543 		 *

   544 		 * @param  {ClipboardEvent} e Paste/drop event object.

   545 		 * @param  {DOMRange} rng Optional rng object to move selection to.

   546 		 * @return {Boolean} true/false if the image data was found or not.

   547 		 */

   548 		function pasteImageData(e, rng) {

   549 			var dataTransfer = e.clipboardData || e.dataTransfer;

   550 

   551 			function processItems(items) {

   552 				var i, item, reader, hadImage = false;

   553 

   554 				function pasteImage(reader) {

   555 					if (rng) {

   556 						editor.selection.setRng(rng);

   557 						rng = null;

   558 					}

   559 

   560 					pasteHtml('<img src="' + reader.result + '">');

   561 				}

   562 

   563 				if (items) {

   564 					for (i = 0; i < items.length; i++) {

   565 						item = items[i];

   566 

   567 						if (/^image\/(jpeg|png|gif|bmp)$/.test(item.type)) {

   568 							reader = new FileReader();

   569 							reader.onload = pasteImage.bind(null, reader);

   570 							reader.readAsDataURL(item.getAsFile ? item.getAsFile() : item);

   571 

   572 							e.preventDefault();

   573 							hadImage = true;

   574 						}

   575 					}

   576 				}

   577 

   578 				return hadImage;

   579 			}

   580 

   581 			if (editor.settings.paste_data_images && dataTransfer) {

   582 				return processItems(dataTransfer.items) || processItems(dataTransfer.files);

   583 			}

   584 		}

   585 

   586 		/**

   587 		 * Chrome on Android doesn't support proper clipboard access so we have no choice but to allow the browser default behavior.

   588 		 *

   589 		 * @param {Event} e Paste event object to check if it contains any data.

   590 		 * @return {Boolean} true/false if the clipboard is empty or not.

   591 		 */

   592 		function isBrokenAndroidClipboardEvent(e) {

   593 			var clipboardData = e.clipboardData;

   594 

   595 			return navigator.userAgent.indexOf('Android') != -1 && clipboardData && clipboardData.items && clipboardData.items.length === 0;

   596 		}

   597 

   598 		function getCaretRangeFromEvent(e) {

   599 			return RangeUtils.getCaretRangeFromPoint(e.clientX, e.clientY, editor.getDoc());

   600 		}

   601 

   602 		function hasContentType(clipboardContent, mimeType) {

   603 			return mimeType in clipboardContent && clipboardContent[mimeType].length > 0;

   604 		}

   605 

   606 		function isKeyboardPasteEvent(e) {

   607 			return (VK.metaKeyPressed(e) && e.keyCode == 86) || (e.shiftKey && e.keyCode == 45);

   608 		}

   609 

   610 		function registerEventHandlers() {

   611 			editor.on('keydown', function(e) {

   612 				function removePasteBinOnKeyUp(e) {

   613 					// Ctrl+V or Shift+Insert

   614 					if (isKeyboardPasteEvent(e) && !e.isDefaultPrevented()) {

   615 						removePasteBin();

   616 					}

   617 				}

   618 

   619 				// Ctrl+V or Shift+Insert

   620 				if (isKeyboardPasteEvent(e) && !e.isDefaultPrevented()) {

   621 					keyboardPastePlainTextState = e.shiftKey && e.keyCode == 86;

   622 

   623 					// Edge case on Safari on Mac where it doesn't handle Cmd+Shift+V correctly

   624 					// it fires the keydown but no paste or keyup so we are left with a paste bin

   625 					if (keyboardPastePlainTextState && Env.webkit && navigator.userAgent.indexOf('Version/') != -1) {

   626 						return;

   627 					}

   628 

   629 					// Prevent undoManager keydown handler from making an undo level with the pastebin in it

   630 					e.stopImmediatePropagation();

   631 

   632 					keyboardPasteTimeStamp = new Date().getTime();

   633 

   634 					// IE doesn't support Ctrl+Shift+V and it doesn't even produce a paste event

   635 					// so lets fake a paste event and let IE use the execCommand/dataTransfer methods

   636 					if (Env.ie && keyboardPastePlainTextState) {

   637 						e.preventDefault();

   638 						editor.fire('paste', {ieFake: true});

   639 						return;

   640 					}

   641 

   642 					removePasteBin();

   643 					createPasteBin();

   644 

   645 					// Remove pastebin if we get a keyup and no paste event

   646 					// For example pasting a file in IE 11 will not produce a paste event

   647 					editor.once('keyup', removePasteBinOnKeyUp);

   648 					editor.once('paste', function() {

   649 						editor.off('keyup', removePasteBinOnKeyUp);

   650 					});

   651 				}

   652 			});

   653 

   654 			editor.on('paste', function(e) {

   655 				// Getting content from the Clipboard can take some time

   656 				var clipboardTimer = new Date().getTime();

   657 				var clipboardContent = getClipboardContent(e);

   658 				var clipboardDelay = new Date().getTime() - clipboardTimer;

   659 

   660 				var isKeyBoardPaste = (new Date().getTime() - keyboardPasteTimeStamp - clipboardDelay) < 1000;

   661 				var plainTextMode = self.pasteFormat == "text" || keyboardPastePlainTextState;

   662 

   663 				keyboardPastePlainTextState = false;

   664 

   665 				if (e.isDefaultPrevented() || isBrokenAndroidClipboardEvent(e)) {

   666 					removePasteBin();

   667 					return;

   668 				}

   669 

   670 				if (pasteImageData(e)) {

   671 					removePasteBin();

   672 					return;

   673 				}

   674 

   675 				// Not a keyboard paste prevent default paste and try to grab the clipboard contents using different APIs

   676 				if (!isKeyBoardPaste) {

   677 					e.preventDefault();

   678 				}

   679 

   680 				// Try IE only method if paste isn't a keyboard paste

   681 				if (Env.ie && (!isKeyBoardPaste || e.ieFake)) {

   682 					createPasteBin();

   683 

   684 					editor.dom.bind(pasteBinElm, 'paste', function(e) {

   685 						e.stopPropagation();

   686 					});

   687 

   688 					editor.getDoc().execCommand('Paste', false, null);

   689 					clipboardContent["text/html"] = getPasteBinHtml();

   690 				}

   691 

   692 				setTimeout(function() {

   693 					var content;

   694 

   695 					// Grab HTML from Clipboard API or paste bin as a fallback

   696 					if (hasContentType(clipboardContent, 'text/html')) {

   697 						content = clipboardContent['text/html'];

   698 					} else {

   699 						content = getPasteBinHtml();

   700 

   701 						// If paste bin is empty try using plain text mode

   702 						// since that is better than nothing right

   703 						if (content == pasteBinDefaultContent) {

   704 							plainTextMode = true;

   705 						}

   706 					}

   707 

   708 					content = Utils.trimHtml(content);

   709 

   710 					// WebKit has a nice bug where it clones the paste bin if you paste from for example notepad

   711 					// so we need to force plain text mode in this case

   712 					if (pasteBinElm && pasteBinElm.firstChild && pasteBinElm.firstChild.id === 'mcepastebin') {

   713 						plainTextMode = true;

   714 					}

   715 

   716 					removePasteBin();

   717 

   718 					// If we got nothing from clipboard API and pastebin then we could try the last resort: plain/text

   719 					if (!content.length) {

   720 						plainTextMode = true;

   721 					}

   722 

   723 					// Grab plain text from Clipboard API or convert existing HTML to plain text

   724 					if (plainTextMode) {

   725 						// Use plain text contents from Clipboard API unless the HTML contains paragraphs then

   726 						// we should convert the HTML to plain text since works better when pasting HTML/Word contents as plain text

   727 						if (hasContentType(clipboardContent, 'text/plain') && content.indexOf('</p>') == -1) {

   728 							content = clipboardContent['text/plain'];

   729 						} else {

   730 							content = Utils.innerText(content);

   731 						}

   732 					}

   733 

   734 					// If the content is the paste bin default HTML then it was

   735 					// impossible to get the cliboard data out.

   736 					if (content == pasteBinDefaultContent) {

   737 						if (!isKeyBoardPaste) {

   738 							editor.windowManager.alert('Please use Ctrl+V/Cmd+V keyboard shortcuts to paste contents.');

   739 						}

   740 

   741 						return;

   742 					}

   743 

   744 					if (plainTextMode) {

   745 						pasteText(content);

   746 					} else {

   747 						pasteHtml(content);

   748 					}

   749 				}, 0);

   750 			});

   751 

   752 			editor.on('dragstart dragend', function(e) {

   753 				draggingInternally = e.type == 'dragstart';

   754 			});

   755 

   756 			editor.on('drop', function(e) {

   757 				var rng = getCaretRangeFromEvent(e);

   758 

   759 				if (e.isDefaultPrevented() || draggingInternally) {

   760 					return;

   761 				}

   762 

   763 				if (pasteImageData(e, rng)) {

   764 					return;

   765 				}

   766 

   767 				if (rng && editor.settings.paste_filter_drop !== false) {

   768 					var dropContent = getDataTransferItems(e.dataTransfer);

   769 					var content = dropContent['mce-internal'] || dropContent['text/html'] || dropContent['text/plain'];

   770 

   771 					if (content) {

   772 						e.preventDefault();

   773 

   774 						editor.undoManager.transact(function() {

   775 							if (dropContent['mce-internal']) {

   776 								editor.execCommand('Delete');

   777 							}

   778 

   779 							editor.selection.setRng(rng);

   780 

   781 							content = Utils.trimHtml(content);

   782 

   783 							if (!dropContent['text/html']) {

   784 								pasteText(content);

   785 							} else {

   786 								pasteHtml(content);

   787 							}

   788 						});

   789 					}

   790 				}

   791 			});

   792 

   793 			editor.on('dragover dragend', function(e) {

   794 				if (editor.settings.paste_data_images) {

   795 					e.preventDefault();

   796 				}

   797 			});

   798 		}

   799 

   800 		self.pasteHtml = pasteHtml;

   801 		self.pasteText = pasteText;

   802 

   803 		editor.on('preInit', function() {

   804 			registerEventHandlers();

   805 

   806 			// Remove all data images from paste for example from Gecko

   807 			// except internal images like video elements

   808 			editor.parser.addNodeFilter('img', function(nodes) {

   809 				if (!editor.settings.paste_data_images) {

   810 					var i = nodes.length;

   811 

   812 					while (i--) {

   813 						var src = nodes[i].attributes.map.src;

   814 

   815 						// Some browsers automatically produce data uris on paste

   816 						// Safari on Mac produces webkit-fake-url see: https://bugs.webkit.org/show_bug.cgi?id=49141

   817 						if (src && /^(data:image|webkit\-fake\-url)/.test(src)) {

   818 							if (!nodes[i].attr('data-mce-object') && src !== Env.transparentSrc) {

   819 								nodes[i].remove();

   820 							}

   821 						}

   822 					}

   823 				}

   824 			});

   825 		});

   826 	};

   827 });

   828 

   829 // Included from: js/tinymce/plugins/paste/classes/WordFilter.js

   830 

   831 /**

   832  * WordFilter.js

   833  *

   834  * Copyright, Moxiecode Systems AB

   835  * Released under LGPL License.

   836  *

   837  * License: http://www.tinymce.com/license

   838  * Contributing: http://www.tinymce.com/contributing

   839  */

   840 

   841 /**

   842  * This class parses word HTML into proper TinyMCE markup.

   843  *

   844  * @class tinymce.pasteplugin.WordFilter

   845  * @private

   846  */

   847 define("tinymce/pasteplugin/WordFilter", [

   848 	"tinymce/util/Tools",

   849 	"tinymce/html/DomParser",

   850 	"tinymce/html/Schema",

   851 	"tinymce/html/Serializer",

   852 	"tinymce/html/Node",

   853 	"tinymce/pasteplugin/Utils"

   854 ], function(Tools, DomParser, Schema, Serializer, Node, Utils) {

   855 	/**

   856 	 * Checks if the specified content is from any of the following sources: MS Word/Office 365/Google docs.

   857 	 */

   858 	function isWordContent(content) {

   859 		return (

   860 			(/<font face="Times New Roman"|class="?Mso|style="[^"]*\bmso-|style='[^'']*\bmso-|w:WordDocument/i).test(content) ||

   861 			(/class="OutlineElement/).test(content) ||

   862 			(/id="?docs\-internal\-guid\-/.test(content))

   863 		);

   864 	}

   865 

   866 	/**

   867 	 * Checks if the specified text starts with "1. " or "a. " etc.

   868 	 */

   869 	function isNumericList(text) {

   870 		var found, patterns;

   871 

   872 		patterns = [

   873 			/^[IVXLMCD]{1,2}\.[ \u00a0]/,  // Roman upper case

   874 			/^[ivxlmcd]{1,2}\.[ \u00a0]/,  // Roman lower case

   875 			/^[a-z]{1,2}[\.\)][ \u00a0]/,  // Alphabetical a-z

   876 			/^[A-Z]{1,2}[\.\)][ \u00a0]/,  // Alphabetical A-Z

   877 			/^[0-9]+\.[ \u00a0]/,          // Numeric lists

   878 			/^[\u3007\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d]+\.[ \u00a0]/, // Japanese

   879 			/^[\u58f1\u5f10\u53c2\u56db\u4f0d\u516d\u4e03\u516b\u4e5d\u62fe]+\.[ \u00a0]/  // Chinese

   880 		];

   881 

   882 		text = text.replace(/^[\u00a0 ]+/, '');

   883 

   884 		Tools.each(patterns, function(pattern) {

   885 			if (pattern.test(text)) {

   886 				found = true;

   887 				return false;

   888 			}

   889 		});

   890 

   891 		return found;

   892 	}

   893 

   894 	function isBulletList(text) {

   895 		return /^[\s\u00a0]*[\u2022\u00b7\u00a7\u25CF]\s*/.test(text);

   896 	}

   897 

   898 	function WordFilter(editor) {

   899 		var settings = editor.settings;

   900 

   901 		editor.on('BeforePastePreProcess', function(e) {

   902 			var content = e.content, retainStyleProperties, validStyles;

   903 

   904 			// Remove google docs internal guid markers

   905 			content = content.replace(/<b[^>]+id="?docs-internal-[^>]*>/gi, '');

   906 			content = content.replace(/<br class="?Apple-interchange-newline"?>/gi, '');

   907 

   908 			retainStyleProperties = settings.paste_retain_style_properties;

   909 			if (retainStyleProperties) {

   910 				validStyles = Tools.makeMap(retainStyleProperties.split(/[, ]/));

   911 			}

   912 

   913 			/**

   914 			 * Converts fake bullet and numbered lists to real semantic OL/UL.

   915 			 *

   916 			 * @param {tinymce.html.Node} node Root node to convert children of.

   917 			 */

   918 			function convertFakeListsToProperLists(node) {

   919 				var currentListNode, prevListNode, lastLevel = 1;

   920 

   921 				function getText(node) {

   922 					var txt = '';

   923 

   924 					if (node.type === 3) {

   925 						return node.value;

   926 					}

   927 

   928 					if ((node = node.firstChild)) {

   929 						do {

   930 							txt += getText(node);

   931 						} while ((node = node.next));

   932 					}

   933 

   934 					return txt;

   935 				}

   936 

   937 				function trimListStart(node, regExp) {

   938 					if (node.type === 3) {

   939 						if (regExp.test(node.value)) {

   940 							node.value = node.value.replace(regExp, '');

   941 							return false;

   942 						}

   943 					}

   944 

   945 					if ((node = node.firstChild)) {

   946 						do {

   947 							if (!trimListStart(node, regExp)) {

   948 								return false;

   949 							}

   950 						} while ((node = node.next));

   951 					}

   952 

   953 					return true;

   954 				}

   955 

   956 				function removeIgnoredNodes(node) {

   957 					if (node._listIgnore) {

   958 						node.remove();

   959 						return;

   960 					}

   961 

   962 					if ((node = node.firstChild)) {

   963 						do {

   964 							removeIgnoredNodes(node);

   965 						} while ((node = node.next));

   966 					}

   967 				}

   968 

   969 				function convertParagraphToLi(paragraphNode, listName, start) {

   970 					var level = paragraphNode._listLevel || lastLevel;

   971 

   972 					// Handle list nesting

   973 					if (level != lastLevel) {

   974 						if (level < lastLevel) {

   975 							// Move to parent list

   976 							if (currentListNode) {

   977 								currentListNode = currentListNode.parent.parent;

   978 							}

   979 						} else {

   980 							// Create new list

   981 							prevListNode = currentListNode;

   982 							currentListNode = null;

   983 						}

   984 					}

   985 

   986 					if (!currentListNode || currentListNode.name != listName) {

   987 						prevListNode = prevListNode || currentListNode;

   988 						currentListNode = new Node(listName, 1);

   989 

   990 						if (start > 1) {

   991 							currentListNode.attr('start', '' + start);

   992 						}

   993 

   994 						paragraphNode.wrap(currentListNode);

   995 					} else {

   996 						currentListNode.append(paragraphNode);

   997 					}

   998 

   999 					paragraphNode.name = 'li';

  1000 

  1001 					// Append list to previous list if it exists

  1002 					if (level > lastLevel && prevListNode) {

  1003 						prevListNode.lastChild.append(currentListNode);

  1004 					}

  1005 

  1006 					lastLevel = level;

  1007 

  1008 					// Remove start of list item "1. " or "· " etc

  1009 					removeIgnoredNodes(paragraphNode);

  1010 					trimListStart(paragraphNode, /^\u00a0+/);

  1011 					trimListStart(paragraphNode, /^\s*([\u2022\u00b7\u00a7\u25CF]|\w+\.)/);

  1012 					trimListStart(paragraphNode, /^\u00a0+/);

  1013 				}

  1014 

  1015 				// Build a list of all root level elements before we start

  1016 				// altering them in the loop below.

  1017 				var elements = [], child = node.firstChild;

  1018 				while (typeof child !== 'undefined' && child !== null) {

  1019 					elements.push(child);

  1020 

  1021 					child = child.walk();

  1022 					if (child !== null) {

  1023 						while (typeof child !== 'undefined' && child.parent !== node) {

  1024 							child = child.walk();

  1025 						}

  1026 					}

  1027 				}

  1028 

  1029 				for (var i = 0; i < elements.length; i++) {

  1030 					node = elements[i];

  1031 

  1032 					if (node.name == 'p' && node.firstChild) {

  1033 						// Find first text node in paragraph

  1034 						var nodeText = getText(node);

  1035 

  1036 						// Detect unordered lists look for bullets

  1037 						if (isBulletList(nodeText)) {

  1038 							convertParagraphToLi(node, 'ul');

  1039 							continue;

  1040 						}

  1041 

  1042 						// Detect ordered lists 1., a. or ixv.

  1043 						if (isNumericList(nodeText)) {

  1044 							// Parse OL start number

  1045 							var matches = /([0-9]+)\./.exec(nodeText);

  1046 							var start = 1;

  1047 							if (matches) {

  1048 								start = parseInt(matches[1], 10);

  1049 							}

  1050 

  1051 							convertParagraphToLi(node, 'ol', start);

  1052 							continue;

  1053 						}

  1054 

  1055 						// Convert paragraphs marked as lists but doesn't look like anything

  1056 						if (node._listLevel) {

  1057 							convertParagraphToLi(node, 'ul', 1);

  1058 							continue;

  1059 						}

  1060 

  1061 						currentListNode = null;

  1062 					} else {

  1063 						// If the root level element isn't a p tag which can be

  1064 						// processed by convertParagraphToLi, it interrupts the

  1065 						// lists, causing a new list to start instead of having

  1066 						// elements from the next list inserted above this tag.

  1067 						prevListNode = currentListNode;

  1068 						currentListNode = null;

  1069 					}

  1070 				}

  1071 			}

  1072 

  1073 			function filterStyles(node, styleValue) {

  1074 				var outputStyles = {}, matches, styles = editor.dom.parseStyle(styleValue);

  1075 

  1076 				Tools.each(styles, function(value, name) {

  1077 					// Convert various MS styles to W3C styles

  1078 					switch (name) {

  1079 						case 'mso-list':

  1080 							// Parse out list indent level for lists

  1081 							matches = /\w+ \w+([0-9]+)/i.exec(styleValue);

  1082 							if (matches) {

  1083 								node._listLevel = parseInt(matches[1], 10);

  1084 							}

  1085 

  1086 							// Remove these nodes <span style="mso-list:Ignore">o</span>

  1087 							// Since the span gets removed we mark the text node and the span

  1088 							if (/Ignore/i.test(value) && node.firstChild) {

  1089 								node._listIgnore = true;

  1090 								node.firstChild._listIgnore = true;

  1091 							}

  1092 

  1093 							break;

  1094 

  1095 						case "horiz-align":

  1096 							name = "text-align";

  1097 							break;

  1098 

  1099 						case "vert-align":

  1100 							name = "vertical-align";

  1101 							break;

  1102 

  1103 						case "font-color":

  1104 						case "mso-foreground":

  1105 							name = "color";

  1106 							break;

  1107 

  1108 						case "mso-background":

  1109 						case "mso-highlight":

  1110 							name = "background";

  1111 							break;

  1112 

  1113 						case "font-weight":

  1114 						case "font-style":

  1115 							if (value != "normal") {

  1116 								outputStyles[name] = value;

  1117 							}

  1118 							return;

  1119 

  1120 						case "mso-element":

  1121 							// Remove track changes code

  1122 							if (/^(comment|comment-list)$/i.test(value)) {

  1123 								node.remove();

  1124 								return;

  1125 							}

  1126 

  1127 							break;

  1128 					}

  1129 

  1130 					if (name.indexOf('mso-comment') === 0) {

  1131 						node.remove();

  1132 						return;

  1133 					}

  1134 

  1135 					// Never allow mso- prefixed names