').css({
+ position: "absolute",
+ top: 0, left: 0,
+ width: docSize.width,
+ height: docSize.height,
+ zIndex: 0x7FFFFFFF,
+ opacity: 0.0001,
+ cursor: cursor
+ }).appendTo(doc.body);
+
+ $(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop);
+
+ settings.start(e);
+ };
+
+ drag = function(e) {
+ updateWithTouchData(e);
+
+ if (e.button !== downButton) {
+ return stop(e);
+ }
+
+ e.deltaX = e.screenX - startX;
+ e.deltaY = e.screenY - startY;
+
+ e.preventDefault();
+ settings.drag(e);
+ };
+
+ stop = function(e) {
+ updateWithTouchData(e);
+
+ $(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop);
+
+ $eventOverlay.remove();
+
+ if (settings.stop) {
+ settings.stop(e);
+ }
+ };
+
+ /**
+ * Destroys the drag/drop helper instance.
+ *
+ * @method destroy
+ */
+ this.destroy = function() {
+ $(getHandleElm()).off();
+ };
+
+ $(getHandleElm()).on('mousedown touchstart', start);
+ };
+});
+
+// Included from: js/tinymce/classes/ui/Scrollable.js
+
+/**
+ * Scrollable.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This mixin makes controls scrollable using custom scrollbars.
+ *
+ * @-x-less Scrollable.less
+ * @mixin tinymce.ui.Scrollable
+ */
+define("tinymce/ui/Scrollable", [
+ "tinymce/dom/DomQuery",
+ "tinymce/ui/DragHelper"
+], function($, DragHelper) {
+ "use strict";
+
+ return {
+ init: function() {
+ var self = this;
+ self.on('repaint', self.renderScroll);
+ },
+
+ renderScroll: function() {
+ var self = this, margin = 2;
+
+ function repaintScroll() {
+ var hasScrollH, hasScrollV, bodyElm;
+
+ function repaintAxis(axisName, posName, sizeName, contentSizeName, hasScroll, ax) {
+ var containerElm, scrollBarElm, scrollThumbElm;
+ var containerSize, scrollSize, ratio, rect;
+ var posNameLower, sizeNameLower;
+
+ scrollBarElm = self.getEl('scroll' + axisName);
+ if (scrollBarElm) {
+ posNameLower = posName.toLowerCase();
+ sizeNameLower = sizeName.toLowerCase();
+
+ $(self.getEl('absend')).css(posNameLower, self.layoutRect()[contentSizeName] - 1);
+
+ if (!hasScroll) {
+ $(scrollBarElm).css('display', 'none');
+ return;
+ }
+
+ $(scrollBarElm).css('display', 'block');
+ containerElm = self.getEl('body');
+ scrollThumbElm = self.getEl('scroll' + axisName + "t");
+ containerSize = containerElm["client" + sizeName] - (margin * 2);
+ containerSize -= hasScrollH && hasScrollV ? scrollBarElm["client" + ax] : 0;
+ scrollSize = containerElm["scroll" + sizeName];
+ ratio = containerSize / scrollSize;
+
+ rect = {};
+ rect[posNameLower] = containerElm["offset" + posName] + margin;
+ rect[sizeNameLower] = containerSize;
+ $(scrollBarElm).css(rect);
+
+ rect = {};
+ rect[posNameLower] = containerElm["scroll" + posName] * ratio;
+ rect[sizeNameLower] = containerSize * ratio;
+ $(scrollThumbElm).css(rect);
+ }
+ }
+
+ bodyElm = self.getEl('body');
+ hasScrollH = bodyElm.scrollWidth > bodyElm.clientWidth;
+ hasScrollV = bodyElm.scrollHeight > bodyElm.clientHeight;
+
+ repaintAxis("h", "Left", "Width", "contentW", hasScrollH, "Height");
+ repaintAxis("v", "Top", "Height", "contentH", hasScrollV, "Width");
+ }
+
+ function addScroll() {
+ function addScrollAxis(axisName, posName, sizeName, deltaPosName, ax) {
+ var scrollStart, axisId = self._id + '-scroll' + axisName, prefix = self.classPrefix;
+
+ $(self.getEl()).append(
+ '
'
+ );
+
+ self.draghelper = new DragHelper(axisId + 't', {
+ start: function() {
+ scrollStart = self.getEl('body')["scroll" + posName];
+ $('#' + axisId).addClass(prefix + 'active');
+ },
+
+ drag: function(e) {
+ var ratio, hasScrollH, hasScrollV, containerSize, layoutRect = self.layoutRect();
+
+ hasScrollH = layoutRect.contentW > layoutRect.innerW;
+ hasScrollV = layoutRect.contentH > layoutRect.innerH;
+ containerSize = self.getEl('body')["client" + sizeName] - (margin * 2);
+ containerSize -= hasScrollH && hasScrollV ? self.getEl('scroll' + axisName)["client" + ax] : 0;
+
+ ratio = containerSize / self.getEl('body')["scroll" + sizeName];
+ self.getEl('body')["scroll" + posName] = scrollStart + (e["delta" + deltaPosName] / ratio);
+ },
+
+ stop: function() {
+ $('#' + axisId).removeClass(prefix + 'active');
+ }
+ });
+ }
+
+ self.classes.add('scroll');
+
+ addScrollAxis("v", "Top", "Height", "Y", "Width");
+ addScrollAxis("h", "Left", "Width", "X", "Height");
+ }
+
+ if (self.settings.autoScroll) {
+ if (!self._hasScroll) {
+ self._hasScroll = true;
+ addScroll();
+
+ self.on('wheel', function(e) {
+ var bodyEl = self.getEl('body');
+
+ bodyEl.scrollLeft += (e.deltaX || 0) * 10;
+ bodyEl.scrollTop += e.deltaY * 10;
+
+ repaintScroll();
+ });
+
+ $(self.getEl('body')).on("scroll", repaintScroll);
+ }
+
+ repaintScroll();
+ }
+ }
+ };
+});
+
+// Included from: js/tinymce/classes/ui/Panel.js
+
+/**
+ * Panel.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a new panel.
+ *
+ * @-x-less Panel.less
+ * @class tinymce.ui.Panel
+ * @extends tinymce.ui.Container
+ * @mixes tinymce.ui.Scrollable
+ */
+define("tinymce/ui/Panel", [
+ "tinymce/ui/Container",
+ "tinymce/ui/Scrollable"
+], function(Container, Scrollable) {
+ "use strict";
+
+ return Container.extend({
+ Defaults: {
+ layout: 'fit',
+ containerCls: 'panel'
+ },
+
+ Mixins: [Scrollable],
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, layout = self._layout, innerHtml = self.settings.html;
+
+ self.preRender();
+ layout.preRender(self);
+
+ if (typeof innerHtml == "undefined") {
+ innerHtml = (
+ '
' +
+ layout.renderHtml(self) +
+ '
'
+ );
+ } else {
+ if (typeof innerHtml == 'function') {
+ innerHtml = innerHtml.call(self);
+ }
+
+ self._hasBody = false;
+ }
+
+ return (
+ '
' +
+ (self._preBodyHtml || '') +
+ innerHtml +
+ '
'
+ );
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/Movable.js
+
+/**
+ * Movable.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Movable mixin. Makes controls movable absolute and relative to other elements.
+ *
+ * @mixin tinymce.ui.Movable
+ */
+define("tinymce/ui/Movable", [
+ "tinymce/ui/DomUtils"
+], function(DomUtils) {
+ "use strict";
+
+ function calculateRelativePosition(ctrl, targetElm, rel) {
+ var ctrlElm, pos, x, y, selfW, selfH, targetW, targetH, viewport, size;
+
+ viewport = DomUtils.getViewPort();
+
+ // Get pos of target
+ pos = DomUtils.getPos(targetElm);
+ x = pos.x;
+ y = pos.y;
+
+ if (ctrl.state.get('fixed') && DomUtils.getRuntimeStyle(document.body, 'position') == 'static') {
+ x -= viewport.x;
+ y -= viewport.y;
+ }
+
+ // Get size of self
+ ctrlElm = ctrl.getEl();
+ size = DomUtils.getSize(ctrlElm);
+ selfW = size.width;
+ selfH = size.height;
+
+ // Get size of target
+ size = DomUtils.getSize(targetElm);
+ targetW = size.width;
+ targetH = size.height;
+
+ // Parse align string
+ rel = (rel || '').split('');
+
+ // Target corners
+ if (rel[0] === 'b') {
+ y += targetH;
+ }
+
+ if (rel[1] === 'r') {
+ x += targetW;
+ }
+
+ if (rel[0] === 'c') {
+ y += Math.round(targetH / 2);
+ }
+
+ if (rel[1] === 'c') {
+ x += Math.round(targetW / 2);
+ }
+
+ // Self corners
+ if (rel[3] === 'b') {
+ y -= selfH;
+ }
+
+ if (rel[4] === 'r') {
+ x -= selfW;
+ }
+
+ if (rel[3] === 'c') {
+ y -= Math.round(selfH / 2);
+ }
+
+ if (rel[4] === 'c') {
+ x -= Math.round(selfW / 2);
+ }
+
+ return {
+ x: x,
+ y: y,
+ w: selfW,
+ h: selfH
+ };
+ }
+
+ return {
+ /**
+ * Tests various positions to get the most suitable one.
+ *
+ * @method testMoveRel
+ * @param {DOMElement} elm Element to position against.
+ * @param {Array} rels Array with relative positions.
+ * @return {String} Best suitable relative position.
+ */
+ testMoveRel: function(elm, rels) {
+ var viewPortRect = DomUtils.getViewPort();
+
+ for (var i = 0; i < rels.length; i++) {
+ var pos = calculateRelativePosition(this, elm, rels[i]);
+
+ if (this.state.get('fixed')) {
+ if (pos.x > 0 && pos.x + pos.w < viewPortRect.w && pos.y > 0 && pos.y + pos.h < viewPortRect.h) {
+ return rels[i];
+ }
+ } else {
+ if (pos.x > viewPortRect.x && pos.x + pos.w < viewPortRect.w + viewPortRect.x &&
+ pos.y > viewPortRect.y && pos.y + pos.h < viewPortRect.h + viewPortRect.y) {
+ return rels[i];
+ }
+ }
+ }
+
+ return rels[0];
+ },
+
+ /**
+ * Move relative to the specified element.
+ *
+ * @method moveRel
+ * @param {Element} elm Element to move relative to.
+ * @param {String} rel Relative mode. For example: br-tl.
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ moveRel: function(elm, rel) {
+ if (typeof rel != 'string') {
+ rel = this.testMoveRel(elm, rel);
+ }
+
+ var pos = calculateRelativePosition(this, elm, rel);
+ return this.moveTo(pos.x, pos.y);
+ },
+
+ /**
+ * Move by a relative x, y values.
+ *
+ * @method moveBy
+ * @param {Number} dx Relative x position.
+ * @param {Number} dy Relative y position.
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ moveBy: function(dx, dy) {
+ var self = this, rect = self.layoutRect();
+
+ self.moveTo(rect.x + dx, rect.y + dy);
+
+ return self;
+ },
+
+ /**
+ * Move to absolute position.
+ *
+ * @method moveTo
+ * @param {Number} x Absolute x position.
+ * @param {Number} y Absolute y position.
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ moveTo: function(x, y) {
+ var self = this;
+
+ // TODO: Move this to some global class
+ function constrain(value, max, size) {
+ if (value < 0) {
+ return 0;
+ }
+
+ if (value + size > max) {
+ value = max - size;
+ return value < 0 ? 0 : value;
+ }
+
+ return value;
+ }
+
+ if (self.settings.constrainToViewport) {
+ var viewPortRect = DomUtils.getViewPort(window);
+ var layoutRect = self.layoutRect();
+
+ x = constrain(x, viewPortRect.w + viewPortRect.x, layoutRect.w);
+ y = constrain(y, viewPortRect.h + viewPortRect.y, layoutRect.h);
+ }
+
+ if (self.state.get('rendered')) {
+ self.layoutRect({x: x, y: y}).repaint();
+ } else {
+ self.settings.x = x;
+ self.settings.y = y;
+ }
+
+ self.fire('move', {x: x, y: y});
+
+ return self;
+ }
+ };
+});
+
+// Included from: js/tinymce/classes/ui/Resizable.js
+
+/**
+ * Resizable.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Resizable mixin. Enables controls to be resized.
+ *
+ * @mixin tinymce.ui.Resizable
+ */
+define("tinymce/ui/Resizable", [
+ "tinymce/ui/DomUtils"
+], function(DomUtils) {
+ "use strict";
+
+ return {
+ /**
+ * Resizes the control to contents.
+ *
+ * @method resizeToContent
+ */
+ resizeToContent: function() {
+ this._layoutRect.autoResize = true;
+ this._lastRect = null;
+ this.reflow();
+ },
+
+ /**
+ * Resizes the control to a specific width/height.
+ *
+ * @method resizeTo
+ * @param {Number} w Control width.
+ * @param {Number} h Control height.
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ resizeTo: function(w, h) {
+ // TODO: Fix hack
+ if (w <= 1 || h <= 1) {
+ var rect = DomUtils.getWindowSize();
+
+ w = w <= 1 ? w * rect.w : w;
+ h = h <= 1 ? h * rect.h : h;
+ }
+
+ this._layoutRect.autoResize = false;
+ return this.layoutRect({minW: w, minH: h, w: w, h: h}).reflow();
+ },
+
+ /**
+ * Resizes the control to a specific relative width/height.
+ *
+ * @method resizeBy
+ * @param {Number} dw Relative control width.
+ * @param {Number} dh Relative control height.
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ resizeBy: function(dw, dh) {
+ var self = this, rect = self.layoutRect();
+
+ return self.resizeTo(rect.w + dw, rect.h + dh);
+ }
+ };
+});
+
+// Included from: js/tinymce/classes/ui/FloatPanel.js
+
+/**
+ * FloatPanel.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class creates a floating panel.
+ *
+ * @-x-less FloatPanel.less
+ * @class tinymce.ui.FloatPanel
+ * @extends tinymce.ui.Panel
+ * @mixes tinymce.ui.Movable
+ * @mixes tinymce.ui.Resizable
+ */
+define("tinymce/ui/FloatPanel", [
+ "tinymce/ui/Panel",
+ "tinymce/ui/Movable",
+ "tinymce/ui/Resizable",
+ "tinymce/ui/DomUtils",
+ "tinymce/dom/DomQuery",
+ "tinymce/util/Delay"
+], function(Panel, Movable, Resizable, DomUtils, $, Delay) {
+ "use strict";
+
+ var documentClickHandler, documentScrollHandler, windowResizeHandler, visiblePanels = [];
+ var zOrder = [], hasModal;
+
+ function isChildOf(ctrl, parent) {
+ while (ctrl) {
+ if (ctrl == parent) {
+ return true;
+ }
+
+ ctrl = ctrl.parent();
+ }
+ }
+
+ function skipOrHidePanels(e) {
+ // Hide any float panel when a click/focus out is out side that float panel and the
+ // float panels direct parent for example a click on a menu button
+ var i = visiblePanels.length;
+
+ while (i--) {
+ var panel = visiblePanels[i], clickCtrl = panel.getParentCtrl(e.target);
+
+ if (panel.settings.autohide) {
+ if (clickCtrl) {
+ if (isChildOf(clickCtrl, panel) || panel.parent() === clickCtrl) {
+ continue;
+ }
+ }
+
+ e = panel.fire('autohide', {target: e.target});
+ if (!e.isDefaultPrevented()) {
+ panel.hide();
+ }
+ }
+ }
+ }
+
+ function bindDocumentClickHandler() {
+
+ if (!documentClickHandler) {
+ documentClickHandler = function(e) {
+ // Gecko fires click event and in the wrong order on Mac so lets normalize
+ if (e.button == 2) {
+ return;
+ }
+
+ skipOrHidePanels(e);
+ };
+
+ $(document).on('click touchstart', documentClickHandler);
+ }
+ }
+
+ function bindDocumentScrollHandler() {
+ if (!documentScrollHandler) {
+ documentScrollHandler = function() {
+ var i;
+
+ i = visiblePanels.length;
+ while (i--) {
+ repositionPanel(visiblePanels[i]);
+ }
+ };
+
+ $(window).on('scroll', documentScrollHandler);
+ }
+ }
+
+ function bindWindowResizeHandler() {
+ if (!windowResizeHandler) {
+ var docElm = document.documentElement, clientWidth = docElm.clientWidth, clientHeight = docElm.clientHeight;
+
+ windowResizeHandler = function() {
+ // Workaround for #7065 IE 7 fires resize events event though the window wasn't resized
+ if (!document.all || clientWidth != docElm.clientWidth || clientHeight != docElm.clientHeight) {
+ clientWidth = docElm.clientWidth;
+ clientHeight = docElm.clientHeight;
+ FloatPanel.hideAll();
+ }
+ };
+
+ $(window).on('resize', windowResizeHandler);
+ }
+ }
+
+ /**
+ * Repositions the panel to the top of page if the panel is outside of the visual viewport. It will
+ * also reposition all child panels of the current panel.
+ */
+ function repositionPanel(panel) {
+ var scrollY = DomUtils.getViewPort().y;
+
+ function toggleFixedChildPanels(fixed, deltaY) {
+ var parent;
+
+ for (var i = 0; i < visiblePanels.length; i++) {
+ if (visiblePanels[i] != panel) {
+ parent = visiblePanels[i].parent();
+
+ while (parent && (parent = parent.parent())) {
+ if (parent == panel) {
+ visiblePanels[i].fixed(fixed).moveBy(0, deltaY).repaint();
+ }
+ }
+ }
+ }
+ }
+
+ if (panel.settings.autofix) {
+ if (!panel.state.get('fixed')) {
+ panel._autoFixY = panel.layoutRect().y;
+
+ if (panel._autoFixY < scrollY) {
+ panel.fixed(true).layoutRect({y: 0}).repaint();
+ toggleFixedChildPanels(true, scrollY - panel._autoFixY);
+ }
+ } else {
+ if (panel._autoFixY > scrollY) {
+ panel.fixed(false).layoutRect({y: panel._autoFixY}).repaint();
+ toggleFixedChildPanels(false, panel._autoFixY - scrollY);
+ }
+ }
+ }
+ }
+
+ function addRemove(add, ctrl) {
+ var i, zIndex = FloatPanel.zIndex || 0xFFFF, topModal;
+
+ if (add) {
+ zOrder.push(ctrl);
+ } else {
+ i = zOrder.length;
+
+ while (i--) {
+ if (zOrder[i] === ctrl) {
+ zOrder.splice(i, 1);
+ }
+ }
+ }
+
+ if (zOrder.length) {
+ for (i = 0; i < zOrder.length; i++) {
+ if (zOrder[i].modal) {
+ zIndex++;
+ topModal = zOrder[i];
+ }
+
+ zOrder[i].getEl().style.zIndex = zIndex;
+ zOrder[i].zIndex = zIndex;
+ zIndex++;
+ }
+ }
+
+ var modalBlockEl = $('#' + ctrl.classPrefix + 'modal-block', ctrl.getContainerElm())[0];
+
+ if (topModal) {
+ $(modalBlockEl).css('z-index', topModal.zIndex - 1);
+ } else if (modalBlockEl) {
+ modalBlockEl.parentNode.removeChild(modalBlockEl);
+ hasModal = false;
+ }
+
+ FloatPanel.currentZIndex = zIndex;
+ }
+
+ var FloatPanel = Panel.extend({
+ Mixins: [Movable, Resizable],
+
+ /**
+ * Constructs a new control instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {Boolean} autohide Automatically hide the panel.
+ */
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+ self._eventsRoot = self;
+
+ self.classes.add('floatpanel');
+
+ // Hide floatpanes on click out side the root button
+ if (settings.autohide) {
+ bindDocumentClickHandler();
+ bindWindowResizeHandler();
+ visiblePanels.push(self);
+ }
+
+ if (settings.autofix) {
+ bindDocumentScrollHandler();
+
+ self.on('move', function() {
+ repositionPanel(this);
+ });
+ }
+
+ self.on('postrender show', function(e) {
+ if (e.control == self) {
+ var $modalBlockEl, prefix = self.classPrefix;
+
+ if (self.modal && !hasModal) {
+ $modalBlockEl = $('#' + prefix + 'modal-block', self.getContainerElm());
+ if (!$modalBlockEl[0]) {
+ $modalBlockEl = $(
+ '
'
+ ).appendTo(self.getContainerElm());
+ }
+
+ Delay.setTimeout(function() {
+ $modalBlockEl.addClass(prefix + 'in');
+ $(self.getEl()).addClass(prefix + 'in');
+ });
+
+ hasModal = true;
+ }
+
+ addRemove(true, self);
+ }
+ });
+
+ self.on('show', function() {
+ self.parents().each(function(ctrl) {
+ if (ctrl.state.get('fixed')) {
+ self.fixed(true);
+ return false;
+ }
+ });
+ });
+
+ if (settings.popover) {
+ self._preBodyHtml = '
';
+ self.classes.add('popover').add('bottom').add(self.isRtl() ? 'end' : 'start');
+ }
+
+ self.aria('label', settings.ariaLabel);
+ self.aria('labelledby', self._id);
+ self.aria('describedby', self.describedBy || self._id + '-none');
+ },
+
+ fixed: function(state) {
+ var self = this;
+
+ if (self.state.get('fixed') != state) {
+ if (self.state.get('rendered')) {
+ var viewport = DomUtils.getViewPort();
+
+ if (state) {
+ self.layoutRect().y -= viewport.y;
+ } else {
+ self.layoutRect().y += viewport.y;
+ }
+ }
+
+ self.classes.toggle('fixed', state);
+ self.state.set('fixed', state);
+ }
+
+ return self;
+ },
+
+ /**
+ * Shows the current float panel.
+ *
+ * @method show
+ * @return {tinymce.ui.FloatPanel} Current floatpanel instance.
+ */
+ show: function() {
+ var self = this, i, state = self._super();
+
+ i = visiblePanels.length;
+ while (i--) {
+ if (visiblePanels[i] === self) {
+ break;
+ }
+ }
+
+ if (i === -1) {
+ visiblePanels.push(self);
+ }
+
+ return state;
+ },
+
+ /**
+ * Hides the current float panel.
+ *
+ * @method hide
+ * @return {tinymce.ui.FloatPanel} Current floatpanel instance.
+ */
+ hide: function() {
+ removeVisiblePanel(this);
+ addRemove(false, this);
+
+ return this._super();
+ },
+
+ /**
+ * Hide all visible float panels with he autohide setting enabled. This is for
+ * manually hiding floating menus or panels.
+ *
+ * @method hideAll
+ */
+ hideAll: function() {
+ FloatPanel.hideAll();
+ },
+
+ /**
+ * Closes the float panel. This will remove the float panel from page and fire the close event.
+ *
+ * @method close
+ */
+ close: function() {
+ var self = this;
+
+ if (!self.fire('close').isDefaultPrevented()) {
+ self.remove();
+ addRemove(false, self);
+ }
+
+ return self;
+ },
+
+ /**
+ * Removes the float panel from page.
+ *
+ * @method remove
+ */
+ remove: function() {
+ removeVisiblePanel(this);
+ this._super();
+ },
+
+ postRender: function() {
+ var self = this;
+
+ if (self.settings.bodyRole) {
+ this.getEl('body').setAttribute('role', self.settings.bodyRole);
+ }
+
+ return self._super();
+ }
+ });
+
+ /**
+ * Hide all visible float panels with he autohide setting enabled. This is for
+ * manually hiding floating menus or panels.
+ *
+ * @static
+ * @method hideAll
+ */
+ FloatPanel.hideAll = function() {
+ var i = visiblePanels.length;
+
+ while (i--) {
+ var panel = visiblePanels[i];
+
+ if (panel && panel.settings.autohide) {
+ panel.hide();
+ visiblePanels.splice(i, 1);
+ }
+ }
+ };
+
+ function removeVisiblePanel(panel) {
+ var i;
+
+ i = visiblePanels.length;
+ while (i--) {
+ if (visiblePanels[i] === panel) {
+ visiblePanels.splice(i, 1);
+ }
+ }
+
+ i = zOrder.length;
+ while (i--) {
+ if (zOrder[i] === panel) {
+ zOrder.splice(i, 1);
+ }
+ }
+ }
+
+ return FloatPanel;
+});
+
+// Included from: js/tinymce/classes/ui/Window.js
+
+/**
+ * Window.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a new window.
+ *
+ * @-x-less Window.less
+ * @class tinymce.ui.Window
+ * @extends tinymce.ui.FloatPanel
+ */
+define("tinymce/ui/Window", [
+ "tinymce/ui/FloatPanel",
+ "tinymce/ui/Panel",
+ "tinymce/ui/DomUtils",
+ "tinymce/dom/DomQuery",
+ "tinymce/ui/DragHelper",
+ "tinymce/ui/BoxUtils",
+ "tinymce/Env",
+ "tinymce/util/Delay"
+], function(FloatPanel, Panel, DomUtils, $, DragHelper, BoxUtils, Env, Delay) {
+ "use strict";
+
+ var windows = [], oldMetaValue = '';
+
+ function toggleFullScreenState(state) {
+ var noScaleMetaValue = 'width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0',
+ viewport = $("meta[name=viewport]")[0],
+ contentValue;
+
+ if (Env.overrideViewPort === false) {
+ return;
+ }
+
+ if (!viewport) {
+ viewport = document.createElement('meta');
+ viewport.setAttribute('name', 'viewport');
+ document.getElementsByTagName('head')[0].appendChild(viewport);
+ }
+
+ contentValue = viewport.getAttribute('content');
+ if (contentValue && typeof oldMetaValue != 'undefined') {
+ oldMetaValue = contentValue;
+ }
+
+ viewport.setAttribute('content', state ? noScaleMetaValue : oldMetaValue);
+ }
+
+ function toggleBodyFullScreenClasses(classPrefix) {
+ for (var i = 0; i < windows.length; i++) {
+ if (windows[i]._fullscreen) {
+ return;
+ }
+ }
+
+ $([document.documentElement, document.body]).removeClass(classPrefix + 'fullscreen');
+ }
+
+ function handleWindowResize() {
+ if (!Env.desktop) {
+ var lastSize = {
+ w: window.innerWidth,
+ h: window.innerHeight
+ };
+
+ Delay.setInterval(function() {
+ var w = window.innerWidth,
+ h = window.innerHeight;
+
+ if (lastSize.w != w || lastSize.h != h) {
+ lastSize = {
+ w: w,
+ h: h
+ };
+
+ $(window).trigger('resize');
+ }
+ }, 100);
+ }
+
+ function reposition() {
+ var i, rect = DomUtils.getWindowSize(), layoutRect;
+
+ for (i = 0; i < windows.length; i++) {
+ layoutRect = windows[i].layoutRect();
+
+ windows[i].moveTo(
+ windows[i].settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2),
+ windows[i].settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2)
+ );
+ }
+ }
+
+ $(window).on('resize', reposition);
+ }
+
+ var Window = FloatPanel.extend({
+ modal: true,
+
+ Defaults: {
+ border: 1,
+ layout: 'flex',
+ containerCls: 'panel',
+ role: 'dialog',
+ callbacks: {
+ submit: function() {
+ this.fire('submit', {data: this.toJSON()});
+ },
+
+ close: function() {
+ this.close();
+ }
+ }
+ },
+
+ /**
+ * Constructs a instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ */
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+
+ if (self.isRtl()) {
+ self.classes.add('rtl');
+ }
+
+ self.classes.add('window');
+ self.bodyClasses.add('window-body');
+ self.state.set('fixed', true);
+
+ // Create statusbar
+ if (settings.buttons) {
+ self.statusbar = new Panel({
+ layout: 'flex',
+ border: '1 0 0 0',
+ spacing: 3,
+ padding: 10,
+ align: 'center',
+ pack: self.isRtl() ? 'start' : 'end',
+ defaults: {
+ type: 'button'
+ },
+ items: settings.buttons
+ });
+
+ self.statusbar.classes.add('foot');
+ self.statusbar.parent(self);
+ }
+
+ self.on('click', function(e) {
+ var closeClass = self.classPrefix + 'close';
+
+ if (DomUtils.hasClass(e.target, closeClass) || DomUtils.hasClass(e.target.parentNode, closeClass)) {
+ self.close();
+ }
+ });
+
+ self.on('cancel', function() {
+ self.close();
+ });
+
+ self.aria('describedby', self.describedBy || self._id + '-none');
+ self.aria('label', settings.title);
+ self._fullscreen = false;
+ },
+
+ /**
+ * Recalculates the positions of the controls in the current container.
+ * This is invoked by the reflow method and shouldn't be called directly.
+ *
+ * @method recalc
+ */
+ recalc: function() {
+ var self = this, statusbar = self.statusbar, layoutRect, width, x, needsRecalc;
+
+ if (self._fullscreen) {
+ self.layoutRect(DomUtils.getWindowSize());
+ self.layoutRect().contentH = self.layoutRect().innerH;
+ }
+
+ self._super();
+
+ layoutRect = self.layoutRect();
+
+ // Resize window based on title width
+ if (self.settings.title && !self._fullscreen) {
+ width = layoutRect.headerW;
+ if (width > layoutRect.w) {
+ x = layoutRect.x - Math.max(0, width / 2);
+ self.layoutRect({w: width, x: x});
+ needsRecalc = true;
+ }
+ }
+
+ // Resize window based on statusbar width
+ if (statusbar) {
+ statusbar.layoutRect({w: self.layoutRect().innerW}).recalc();
+
+ width = statusbar.layoutRect().minW + layoutRect.deltaW;
+ if (width > layoutRect.w) {
+ x = layoutRect.x - Math.max(0, width - layoutRect.w);
+ self.layoutRect({w: width, x: x});
+ needsRecalc = true;
+ }
+ }
+
+ // Recalc body and disable auto resize
+ if (needsRecalc) {
+ self.recalc();
+ }
+ },
+
+ /**
+ * Initializes the current controls layout rect.
+ * This will be executed by the layout managers to determine the
+ * default minWidth/minHeight etc.
+ *
+ * @method initLayoutRect
+ * @return {Object} Layout rect instance.
+ */
+ initLayoutRect: function() {
+ var self = this, layoutRect = self._super(), deltaH = 0, headEl;
+
+ // Reserve vertical space for title
+ if (self.settings.title && !self._fullscreen) {
+ headEl = self.getEl('head');
+
+ var size = DomUtils.getSize(headEl);
+
+ layoutRect.headerW = size.width;
+ layoutRect.headerH = size.height;
+
+ deltaH += layoutRect.headerH;
+ }
+
+ // Reserve vertical space for statusbar
+ if (self.statusbar) {
+ deltaH += self.statusbar.layoutRect().h;
+ }
+
+ layoutRect.deltaH += deltaH;
+ layoutRect.minH += deltaH;
+ //layoutRect.innerH -= deltaH;
+ layoutRect.h += deltaH;
+
+ var rect = DomUtils.getWindowSize();
+
+ layoutRect.x = self.settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2);
+ layoutRect.y = self.settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2);
+
+ return layoutRect;
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, layout = self._layout, id = self._id, prefix = self.classPrefix;
+ var settings = self.settings, headerHtml = '', footerHtml = '', html = settings.html;
+
+ self.preRender();
+ layout.preRender(self);
+
+ if (settings.title) {
+ headerHtml = (
+ '
' +
+ '
' + self.encode(settings.title) + '
' +
+ '
' +
+ '
' +
+ '
'
+ );
+ }
+
+ if (settings.url) {
+ html = '
';
+ }
+
+ if (typeof html == "undefined") {
+ html = layout.renderHtml(self);
+ }
+
+ if (self.statusbar) {
+ footerHtml = self.statusbar.renderHtml();
+ }
+
+ return (
+ '
' +
+ '
' +
+ headerHtml +
+ '
' +
+ html +
+ '
' +
+ footerHtml +
+ '
' +
+ '
'
+ );
+ },
+
+ /**
+ * Switches the window fullscreen mode.
+ *
+ * @method fullscreen
+ * @param {Boolean} state True/false state.
+ * @return {tinymce.ui.Window} Current window instance.
+ */
+ fullscreen: function(state) {
+ var self = this, documentElement = document.documentElement, slowRendering, prefix = self.classPrefix, layoutRect;
+
+ if (state != self._fullscreen) {
+ $(window).on('resize', function() {
+ var time;
+
+ if (self._fullscreen) {
+ // Time the layout time if it's to slow use a timeout to not hog the CPU
+ if (!slowRendering) {
+ time = new Date().getTime();
+
+ var rect = DomUtils.getWindowSize();
+ self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+
+ if ((new Date().getTime()) - time > 50) {
+ slowRendering = true;
+ }
+ } else {
+ if (!self._timer) {
+ self._timer = Delay.setTimeout(function() {
+ var rect = DomUtils.getWindowSize();
+ self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+
+ self._timer = 0;
+ }, 50);
+ }
+ }
+ }
+ });
+
+ layoutRect = self.layoutRect();
+ self._fullscreen = state;
+
+ if (!state) {
+ self.borderBox = BoxUtils.parseBox(self.settings.border);
+ self.getEl('head').style.display = '';
+ layoutRect.deltaH += layoutRect.headerH;
+ $([documentElement, document.body]).removeClass(prefix + 'fullscreen');
+ self.classes.remove('fullscreen');
+ self.moveTo(self._initial.x, self._initial.y).resizeTo(self._initial.w, self._initial.h);
+ } else {
+ self._initial = {x: layoutRect.x, y: layoutRect.y, w: layoutRect.w, h: layoutRect.h};
+
+ self.borderBox = BoxUtils.parseBox('0');
+ self.getEl('head').style.display = 'none';
+ layoutRect.deltaH -= layoutRect.headerH + 2;
+ $([documentElement, document.body]).addClass(prefix + 'fullscreen');
+ self.classes.add('fullscreen');
+
+ var rect = DomUtils.getWindowSize();
+ self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+ }
+ }
+
+ return self.reflow();
+ },
+
+ /**
+ * Called after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this, startPos;
+
+ setTimeout(function() {
+ self.classes.add('in');
+ self.fire('open');
+ }, 0);
+
+ self._super();
+
+ if (self.statusbar) {
+ self.statusbar.postRender();
+ }
+
+ self.focus();
+
+ this.dragHelper = new DragHelper(self._id + '-dragh', {
+ start: function() {
+ startPos = {
+ x: self.layoutRect().x,
+ y: self.layoutRect().y
+ };
+ },
+
+ drag: function(e) {
+ self.moveTo(startPos.x + e.deltaX, startPos.y + e.deltaY);
+ }
+ });
+
+ self.on('submit', function(e) {
+ if (!e.isDefaultPrevented()) {
+ self.close();
+ }
+ });
+
+ windows.push(self);
+ toggleFullScreenState(true);
+ },
+
+ /**
+ * Fires a submit event with the serialized form.
+ *
+ * @method submit
+ * @return {Object} Event arguments object.
+ */
+ submit: function() {
+ return this.fire('submit', {data: this.toJSON()});
+ },
+
+ /**
+ * Removes the current control from DOM and from UI collections.
+ *
+ * @method remove
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ remove: function() {
+ var self = this, i;
+
+ self.dragHelper.destroy();
+ self._super();
+
+ if (self.statusbar) {
+ this.statusbar.remove();
+ }
+
+ i = windows.length;
+ while (i--) {
+ if (windows[i] === self) {
+ windows.splice(i, 1);
+ }
+ }
+
+ toggleFullScreenState(windows.length > 0);
+ toggleBodyFullScreenClasses(self.classPrefix);
+ },
+
+ /**
+ * Returns the contentWindow object of the iframe if it exists.
+ *
+ * @method getContentWindow
+ * @return {Window} window object or null.
+ */
+ getContentWindow: function() {
+ var ifr = this.getEl().getElementsByTagName('iframe')[0];
+ return ifr ? ifr.contentWindow : null;
+ }
+ });
+
+ handleWindowResize();
+
+ return Window;
+});
+
+// Included from: js/tinymce/classes/ui/MessageBox.js
+
+/**
+ * MessageBox.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class is used to create MessageBoxes like alerts/confirms etc.
+ *
+ * @class tinymce.ui.MessageBox
+ * @extends tinymce.ui.FloatPanel
+ */
+define("tinymce/ui/MessageBox", [
+ "tinymce/ui/Window"
+], function(Window) {
+ "use strict";
+
+ var MessageBox = Window.extend({
+ /**
+ * Constructs a instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ */
+ init: function(settings) {
+ settings = {
+ border: 1,
+ padding: 20,
+ layout: 'flex',
+ pack: "center",
+ align: "center",
+ containerCls: 'panel',
+ autoScroll: true,
+ buttons: {type: "button", text: "Ok", action: "ok"},
+ items: {
+ type: "label",
+ multiline: true,
+ maxWidth: 500,
+ maxHeight: 200
+ }
+ };
+
+ this._super(settings);
+ },
+
+ Statics: {
+ /**
+ * Ok buttons constant.
+ *
+ * @static
+ * @final
+ * @field {Number} OK
+ */
+ OK: 1,
+
+ /**
+ * Ok/cancel buttons constant.
+ *
+ * @static
+ * @final
+ * @field {Number} OK_CANCEL
+ */
+ OK_CANCEL: 2,
+
+ /**
+ * yes/no buttons constant.
+ *
+ * @static
+ * @final
+ * @field {Number} YES_NO
+ */
+ YES_NO: 3,
+
+ /**
+ * yes/no/cancel buttons constant.
+ *
+ * @static
+ * @final
+ * @field {Number} YES_NO_CANCEL
+ */
+ YES_NO_CANCEL: 4,
+
+ /**
+ * Constructs a new message box and renders it to the body element.
+ *
+ * @static
+ * @method msgBox
+ * @param {Object} settings Name/value object with settings.
+ */
+ msgBox: function(settings) {
+ var buttons, callback = settings.callback || function() {};
+
+ function createButton(text, status, primary) {
+ return {
+ type: "button",
+ text: text,
+ subtype: primary ? 'primary' : '',
+ onClick: function(e) {
+ e.control.parents()[1].close();
+ callback(status);
+ }
+ };
+ }
+
+ switch (settings.buttons) {
+ case MessageBox.OK_CANCEL:
+ buttons = [
+ createButton('Ok', true, true),
+ createButton('Cancel', false)
+ ];
+ break;
+
+ case MessageBox.YES_NO:
+ case MessageBox.YES_NO_CANCEL:
+ buttons = [
+ createButton('Yes', 1, true),
+ createButton('No', 0)
+ ];
+
+ if (settings.buttons == MessageBox.YES_NO_CANCEL) {
+ buttons.push(createButton('Cancel', -1));
+ }
+ break;
+
+ default:
+ buttons = [
+ createButton('Ok', true, true)
+ ];
+ break;
+ }
+
+ return new Window({
+ padding: 20,
+ x: settings.x,
+ y: settings.y,
+ minWidth: 300,
+ minHeight: 100,
+ layout: "flex",
+ pack: "center",
+ align: "center",
+ buttons: buttons,
+ title: settings.title,
+ role: 'alertdialog',
+ items: {
+ type: "label",
+ multiline: true,
+ maxWidth: 500,
+ maxHeight: 200,
+ text: settings.text
+ },
+ onPostRender: function() {
+ this.aria('describedby', this.items()[0]._id);
+ },
+ onClose: settings.onClose,
+ onCancel: function() {
+ callback(false);
+ }
+ }).renderTo(document.body).reflow();
+ },
+
+ /**
+ * Creates a new alert dialog.
+ *
+ * @method alert
+ * @param {Object} settings Settings for the alert dialog.
+ * @param {function} [callback] Callback to execute when the user makes a choice.
+ */
+ alert: function(settings, callback) {
+ if (typeof settings == "string") {
+ settings = {text: settings};
+ }
+
+ settings.callback = callback;
+ return MessageBox.msgBox(settings);
+ },
+
+ /**
+ * Creates a new confirm dialog.
+ *
+ * @method confirm
+ * @param {Object} settings Settings for the confirm dialog.
+ * @param {function} [callback] Callback to execute when the user makes a choice.
+ */
+ confirm: function(settings, callback) {
+ if (typeof settings == "string") {
+ settings = {text: settings};
+ }
+
+ settings.callback = callback;
+ settings.buttons = MessageBox.OK_CANCEL;
+
+ return MessageBox.msgBox(settings);
+ }
+ }
+ });
+
+ return MessageBox;
+});
+
+// Included from: js/tinymce/classes/WindowManager.js
+
+/**
+ * WindowManager.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class handles the creation of native windows and dialogs. This class can be extended to provide for example inline dialogs.
+ *
+ * @class tinymce.WindowManager
+ * @example
+ * // Opens a new dialog with the file.htm file and the size 320x240
+ * // It also adds a custom parameter this can be retrieved by using tinyMCEPopup.getWindowArg inside the dialog.
+ * tinymce.activeEditor.windowManager.open({
+ * url: 'file.htm',
+ * width: 320,
+ * height: 240
+ * }, {
+ * custom_param: 1
+ * });
+ *
+ * // Displays an alert box using the active editors window manager instance
+ * tinymce.activeEditor.windowManager.alert('Hello world!');
+ *
+ * // Displays an confirm box and an alert message will be displayed depending on what you choose in the confirm
+ * tinymce.activeEditor.windowManager.confirm("Do you want to do something", function(s) {
+ * if (s)
+ * tinymce.activeEditor.windowManager.alert("Ok");
+ * else
+ * tinymce.activeEditor.windowManager.alert("Cancel");
+ * });
+ */
+define("tinymce/WindowManager", [
+ "tinymce/ui/Window",
+ "tinymce/ui/MessageBox"
+], function(Window, MessageBox) {
+ return function(editor) {
+ var self = this, windows = [];
+
+ function getTopMostWindow() {
+ if (windows.length) {
+ return windows[windows.length - 1];
+ }
+ }
+
+ function fireOpenEvent(win) {
+ editor.fire('OpenWindow', {
+ win: win
+ });
+ }
+
+ function fireCloseEvent(win) {
+ editor.fire('CloseWindow', {
+ win: win
+ });
+ }
+
+ self.windows = windows;
+
+ editor.on('remove', function() {
+ var i = windows.length;
+
+ while (i--) {
+ windows[i].close();
+ }
+ });
+
+ /**
+ * Opens a new window.
+ *
+ * @method open
+ * @param {Object} args Optional name/value settings collection contains things like width/height/url etc.
+ * @param {Object} params Options like title, file, width, height etc.
+ * @option {String} title Window title.
+ * @option {String} file URL of the file to open in the window.
+ * @option {Number} width Width in pixels.
+ * @option {Number} height Height in pixels.
+ * @option {Boolean} autoScroll Specifies whether the popup window can have scrollbars if required (i.e. content
+ * larger than the popup size specified).
+ */
+ self.open = function(args, params) {
+ var win;
+
+ editor.editorManager.setActive(editor);
+
+ args.title = args.title || ' ';
+
+ // Handle URL
+ args.url = args.url || args.file; // Legacy
+ if (args.url) {
+ args.width = parseInt(args.width || 320, 10);
+ args.height = parseInt(args.height || 240, 10);
+ }
+
+ // Handle body
+ if (args.body) {
+ args.items = {
+ defaults: args.defaults,
+ type: args.bodyType || 'form',
+ items: args.body,
+ data: args.data,
+ callbacks: args.commands
+ };
+ }
+
+ if (!args.url && !args.buttons) {
+ args.buttons = [
+ {text: 'Ok', subtype: 'primary', onclick: function() {
+ win.find('form')[0].submit();
+ }},
+
+ {text: 'Cancel', onclick: function() {
+ win.close();
+ }}
+ ];
+ }
+
+ win = new Window(args);
+ windows.push(win);
+
+ win.on('close', function() {
+ var i = windows.length;
+
+ while (i--) {
+ if (windows[i] === win) {
+ windows.splice(i, 1);
+ }
+ }
+
+ if (!windows.length) {
+ editor.focus();
+ }
+
+ fireCloseEvent(win);
+ });
+
+ // Handle data
+ if (args.data) {
+ win.on('postRender', function() {
+ this.find('*').each(function(ctrl) {
+ var name = ctrl.name();
+
+ if (name in args.data) {
+ ctrl.value(args.data[name]);
+ }
+ });
+ });
+ }
+
+ // store args and parameters
+ win.features = args || {};
+ win.params = params || {};
+
+ // Takes a snapshot in the FocusManager of the selection before focus is lost to dialog
+ if (windows.length === 1) {
+ editor.nodeChanged();
+ }
+
+ win = win.renderTo().reflow();
+
+ fireOpenEvent(win);
+
+ return win;
+ };
+
+ /**
+ * Creates a alert dialog. Please don't use the blocking behavior of this
+ * native version use the callback method instead then it can be extended.
+ *
+ * @method alert
+ * @param {String} message Text to display in the new alert dialog.
+ * @param {function} callback Callback function to be executed after the user has selected ok.
+ * @param {Object} scope Optional scope to execute the callback in.
+ * @example
+ * // Displays an alert box using the active editors window manager instance
+ * tinymce.activeEditor.windowManager.alert('Hello world!');
+ */
+ self.alert = function(message, callback, scope) {
+ var win;
+
+ win = MessageBox.alert(message, function() {
+ if (callback) {
+ callback.call(scope || this);
+ } else {
+ editor.focus();
+ }
+ });
+
+ win.on('close', function() {
+ fireCloseEvent(win);
+ });
+
+ fireOpenEvent(win);
+ };
+
+ /**
+ * Creates a confirm dialog. Please don't use the blocking behavior of this
+ * native version use the callback method instead then it can be extended.
+ *
+ * @method confirm
+ * @param {String} message Text to display in the new confirm dialog.
+ * @param {function} callback Callback function to be executed after the user has selected ok or cancel.
+ * @param {Object} scope Optional scope to execute the callback in.
+ * @example
+ * // Displays an confirm box and an alert message will be displayed depending on what you choose in the confirm
+ * tinymce.activeEditor.windowManager.confirm("Do you want to do something", function(s) {
+ * if (s)
+ * tinymce.activeEditor.windowManager.alert("Ok");
+ * else
+ * tinymce.activeEditor.windowManager.alert("Cancel");
+ * });
+ */
+ self.confirm = function(message, callback, scope) {
+ var win;
+
+ win = MessageBox.confirm(message, function(state) {
+ callback.call(scope || this, state);
+ });
+
+ win.on('close', function() {
+ fireCloseEvent(win);
+ });
+
+ fireOpenEvent(win);
+ };
+
+ /**
+ * Closes the top most window.
+ *
+ * @method close
+ */
+ self.close = function() {
+ if (getTopMostWindow()) {
+ getTopMostWindow().close();
+ }
+ };
+
+ /**
+ * Returns the params of the last window open call. This can be used in iframe based
+ * dialog to get params passed from the tinymce plugin.
+ *
+ * @example
+ * var dialogArguments = top.tinymce.activeEditor.windowManager.getParams();
+ *
+ * @method getParams
+ * @return {Object} Name/value object with parameters passed from windowManager.open call.
+ */
+ self.getParams = function() {
+ return getTopMostWindow() ? getTopMostWindow().params : null;
+ };
+
+ /**
+ * Sets the params of the last opened window.
+ *
+ * @method setParams
+ * @param {Object} params Params object to set for the last opened window.
+ */
+ self.setParams = function(params) {
+ if (getTopMostWindow()) {
+ getTopMostWindow().params = params;
+ }
+ };
+
+ /**
+ * Returns the currently opened window objects.
+ *
+ * @method getWindows
+ * @return {Array} Array of the currently opened windows.
+ */
+ self.getWindows = function() {
+ return windows;
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/ui/Tooltip.js
+
+/**
+ * Tooltip.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a tooltip instance.
+ *
+ * @-x-less ToolTip.less
+ * @class tinymce.ui.ToolTip
+ * @extends tinymce.ui.Control
+ * @mixes tinymce.ui.Movable
+ */
+define("tinymce/ui/Tooltip", [
+ "tinymce/ui/Control",
+ "tinymce/ui/Movable"
+], function(Control, Movable) {
+ return Control.extend({
+ Mixins: [Movable],
+
+ Defaults: {
+ classes: 'widget tooltip tooltip-n'
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, prefix = self.classPrefix;
+
+ return (
+ '
' +
+ '
' +
+ '
' + self.encode(self.state.get('text')) + '
' +
+ '
'
+ );
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:text', function(e) {
+ self.getEl().lastChild.innerHTML = self.encode(e.value);
+ });
+
+ return self._super();
+ },
+
+ /**
+ * Repaints the control after a layout operation.
+ *
+ * @method repaint
+ */
+ repaint: function() {
+ var self = this, style, rect;
+
+ style = self.getEl().style;
+ rect = self._layoutRect;
+
+ style.left = rect.x + 'px';
+ style.top = rect.y + 'px';
+ style.zIndex = 0xFFFF + 0xFFFF;
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/Widget.js
+
+/**
+ * Widget.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Widget base class a widget is a control that has a tooltip and some basic states.
+ *
+ * @class tinymce.ui.Widget
+ * @extends tinymce.ui.Control
+ */
+define("tinymce/ui/Widget", [
+ "tinymce/ui/Control",
+ "tinymce/ui/Tooltip"
+], function(Control, Tooltip) {
+ "use strict";
+
+ var tooltip;
+
+ var Widget = Control.extend({
+ /**
+ * Constructs a instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {String} tooltip Tooltip text to display when hovering.
+ * @setting {Boolean} autofocus True if the control should be focused when rendered.
+ * @setting {String} text Text to display inside widget.
+ */
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+ settings = self.settings;
+ self.canFocus = true;
+
+ if (settings.tooltip && Widget.tooltips !== false) {
+ self.on('mouseenter', function(e) {
+ var tooltip = self.tooltip().moveTo(-0xFFFF);
+
+ if (e.control == self) {
+ var rel = tooltip.text(settings.tooltip).show().testMoveRel(self.getEl(), ['bc-tc', 'bc-tl', 'bc-tr']);
+
+ tooltip.classes.toggle('tooltip-n', rel == 'bc-tc');
+ tooltip.classes.toggle('tooltip-nw', rel == 'bc-tl');
+ tooltip.classes.toggle('tooltip-ne', rel == 'bc-tr');
+
+ tooltip.moveRel(self.getEl(), rel);
+ } else {
+ tooltip.hide();
+ }
+ });
+
+ self.on('mouseleave mousedown click', function() {
+ self.tooltip().hide();
+ });
+ }
+
+ self.aria('label', settings.ariaLabel || settings.tooltip);
+ },
+
+ /**
+ * Returns the current tooltip instance.
+ *
+ * @method tooltip
+ * @return {tinymce.ui.Tooltip} Tooltip instance.
+ */
+ tooltip: function() {
+ if (!tooltip) {
+ tooltip = new Tooltip({type: 'tooltip'});
+ tooltip.renderTo();
+ }
+
+ return tooltip;
+ },
+
+ /**
+ * Called after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this, settings = self.settings;
+
+ self._super();
+
+ if (!self.parent() && (settings.width || settings.height)) {
+ self.initLayoutRect();
+ self.repaint();
+ }
+
+ if (settings.autofocus) {
+ self.focus();
+ }
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ function disable(state) {
+ self.aria('disabled', state);
+ self.classes.toggle('disabled', state);
+ }
+
+ function active(state) {
+ self.aria('pressed', state);
+ self.classes.toggle('active', state);
+ }
+
+ self.state.on('change:disabled', function(e) {
+ disable(e.value);
+ });
+
+ self.state.on('change:active', function(e) {
+ active(e.value);
+ });
+
+ if (self.state.get('disabled')) {
+ disable(true);
+ }
+
+ if (self.state.get('active')) {
+ active(true);
+ }
+
+ return self._super();
+ },
+
+ /**
+ * Removes the current control from DOM and from UI collections.
+ *
+ * @method remove
+ * @return {tinymce.ui.Control} Current control instance.
+ */
+ remove: function() {
+ this._super();
+
+ if (tooltip) {
+ tooltip.remove();
+ tooltip = null;
+ }
+ }
+ });
+
+ return Widget;
+});
+
+// Included from: js/tinymce/classes/ui/Progress.js
+
+/**
+ * Progress.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Progress control.
+ *
+ * @-x-less Progress.less
+ * @class tinymce.ui.Progress
+ * @extends tinymce.ui.Control
+ */
+define("tinymce/ui/Progress", [
+ "tinymce/ui/Widget"
+], function(Widget) {
+ "use strict";
+
+ return Widget.extend({
+ Defaults: {
+ value: 0
+ },
+
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+ self.classes.add('progress');
+
+ if (!self.settings.filter) {
+ self.settings.filter = function(value) {
+ return Math.round(value);
+ };
+ }
+ },
+
+ renderHtml: function() {
+ var self = this, id = self._id, prefix = this.classPrefix;
+
+ return (
+ '
'
+ );
+ },
+
+ postRender: function() {
+ var self = this;
+
+ self._super();
+ self.value(self.settings.value);
+
+ return self;
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ function setValue(value) {
+ value = self.settings.filter(value);
+ self.getEl().lastChild.innerHTML = value + '%';
+ self.getEl().firstChild.firstChild.style.width = value + '%';
+ }
+
+ self.state.on('change:value', function(e) {
+ setValue(e.value);
+ });
+
+ setValue(self.state.get('value'));
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/Notification.js
+
+/**
+ * Notification.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a notification instance.
+ *
+ * @-x-less Notification.less
+ * @class tinymce.ui.Notification
+ * @extends tinymce.ui.Container
+ * @mixes tinymce.ui.Movable
+ */
+define("tinymce/ui/Notification", [
+ "tinymce/ui/Control",
+ "tinymce/ui/Movable",
+ "tinymce/ui/Progress",
+ "tinymce/util/Delay"
+], function(Control, Movable, Progress, Delay) {
+ return Control.extend({
+ Mixins: [Movable],
+
+ Defaults: {
+ classes: 'widget notification'
+ },
+
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+
+ if (settings.text) {
+ self.text(settings.text);
+ }
+
+ if (settings.icon) {
+ self.icon = settings.icon;
+ }
+
+ if (settings.color) {
+ self.color = settings.color;
+ }
+
+ if (settings.type) {
+ self.classes.add('notification-' + settings.type);
+ }
+
+ if (settings.timeout && (settings.timeout < 0 || settings.timeout > 0) && !settings.closeButton) {
+ self.closeButton = false;
+ } else {
+ self.classes.add('has-close');
+ self.closeButton = true;
+ }
+
+ if (settings.progressBar) {
+ self.progressBar = new Progress();
+ }
+
+ self.on('click', function(e) {
+ if (e.target.className.indexOf(self.classPrefix + 'close') != -1) {
+ self.close();
+ }
+ });
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, prefix = self.classPrefix, icon = '', closeButton = '', progressBar = '', notificationStyle = '';
+
+ if (self.icon) {
+ icon = '
';
+ }
+
+ if (self.color) {
+ notificationStyle = ' style="background-color: ' + self.color + '"';
+ }
+
+ if (self.closeButton) {
+ closeButton = '
';
+ }
+
+ if (self.progressBar) {
+ progressBar = self.progressBar.renderHtml();
+ }
+
+ return (
+ '
' +
+ icon +
+ '
' + self.state.get('text') + '
' +
+ progressBar +
+ closeButton +
+ '
'
+ );
+ },
+
+ postRender: function() {
+ var self = this;
+
+ Delay.setTimeout(function() {
+ self.$el.addClass(self.classPrefix + 'in');
+ });
+
+ return self._super();
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:text', function(e) {
+ self.getEl().childNodes[1].innerHTML = e.value;
+ });
+ if (self.progressBar) {
+ self.progressBar.bindStates();
+ }
+ return self._super();
+ },
+
+ close: function() {
+ var self = this;
+
+ if (!self.fire('close').isDefaultPrevented()) {
+ self.remove();
+ }
+
+ return self;
+ },
+
+ /**
+ * Repaints the control after a layout operation.
+ *
+ * @method repaint
+ */
+ repaint: function() {
+ var self = this, style, rect;
+
+ style = self.getEl().style;
+ rect = self._layoutRect;
+
+ style.left = rect.x + 'px';
+ style.top = rect.y + 'px';
+ style.zIndex = 0xFFFF + 0xFFFF;
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/NotificationManager.js
+
+/**
+ * NotificationManager.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class handles the creation of TinyMCE's notifications.
+ *
+ * @class tinymce.notificationManager
+ * @example
+ * // Opens a new notification of type "error" with text "An error occurred."
+ * tinymce.activeEditor.notificationManager.open({
+ * text: 'An error occurred.',
+ * type: 'error'
+ * });
+ */
+define("tinymce/NotificationManager", [
+ "tinymce/ui/Notification",
+ "tinymce/util/Delay"
+], function(Notification, Delay) {
+ return function(editor) {
+ var self = this, notifications = [];
+
+ function getLastNotification() {
+ if (notifications.length) {
+ return notifications[notifications.length - 1];
+ }
+ }
+
+ self.notifications = notifications;
+
+ function resizeWindowEvent() {
+ Delay.requestAnimationFrame(function() {
+ prePositionNotifications();
+ positionNotifications();
+ });
+ }
+
+ // Since the viewport will change based on the present notifications, we need to move them all to the
+ // top left of the viewport to give an accurate size measurement so we can position them later.
+ function prePositionNotifications() {
+ for (var i = 0; i < notifications.length; i++) {
+ notifications[i].moveTo(0, 0);
+ }
+ }
+
+ function positionNotifications() {
+ if (notifications.length > 0) {
+ var firstItem = notifications.slice(0, 1)[0];
+ var container = editor.inline ? editor.getElement() : editor.getContentAreaContainer();
+ firstItem.moveRel(container, 'tc-tc');
+ if (notifications.length > 1) {
+ for (var i = 1; i < notifications.length; i++) {
+ notifications[i].moveRel(notifications[i - 1].getEl(), 'bc-tc');
+ }
+ }
+ }
+ }
+
+ editor.on('remove', function() {
+ var i = notifications.length;
+
+ while (i--) {
+ notifications[i].close();
+ }
+ });
+
+ editor.on('ResizeEditor', positionNotifications);
+ editor.on('ResizeWindow', resizeWindowEvent);
+
+ /**
+ * Opens a new notification.
+ *
+ * @method open
+ * @param {Object} args Optional name/value settings collection contains things like timeout/color/message etc.
+ */
+ self.open = function(args) {
+ var notif;
+
+ editor.editorManager.setActive(editor);
+
+ notif = new Notification(args);
+ notifications.push(notif);
+
+ //If we have a timeout value
+ if (args.timeout > 0) {
+ notif.timer = setTimeout(function() {
+ notif.close();
+ }, args.timeout);
+ }
+
+ notif.on('close', function() {
+ var i = notifications.length;
+
+ if (notif.timer) {
+ editor.getWin().clearTimeout(notif.timer);
+ }
+
+ while (i--) {
+ if (notifications[i] === notif) {
+ notifications.splice(i, 1);
+ }
+ }
+
+ positionNotifications();
+ });
+
+ notif.renderTo();
+
+ positionNotifications();
+
+ return notif;
+ };
+
+ /**
+ * Closes the top most notification.
+ *
+ * @method close
+ */
+ self.close = function() {
+ if (getLastNotification()) {
+ getLastNotification().close();
+ }
+ };
+
+ /**
+ * Returns the currently opened notification objects.
+ *
+ * @method getNotifications
+ * @return {Array} Array of the currently opened notifications.
+ */
+ self.getNotifications = function() {
+ return notifications;
+ };
+
+ editor.on('SkinLoaded', function() {
+ var serviceMessage = editor.settings.service_message;
+
+ if (serviceMessage) {
+ editor.notificationManager.open({
+ text: serviceMessage,
+ type: 'warning',
+ timeout: 0,
+ icon: ''
+ });
+ }
+ });
+
+ //self.positionNotifications = positionNotifications;
+ };
+});
+
+// Included from: js/tinymce/classes/dom/NodePath.js
+
+/**
+ * NodePath.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Handles paths of nodes within an element.
+ *
+ * @private
+ * @class tinymce.dom.NodePath
+ */
+define("tinymce/dom/NodePath", [
+ "tinymce/dom/DOMUtils"
+], function(DOMUtils) {
+ function create(rootNode, targetNode, normalized) {
+ var path = [];
+
+ for (; targetNode && targetNode != rootNode; targetNode = targetNode.parentNode) {
+ path.push(DOMUtils.nodeIndex(targetNode, normalized));
+ }
+
+ return path;
+ }
+
+ function resolve(rootNode, path) {
+ var i, node, children;
+
+ for (node = rootNode, i = path.length - 1; i >= 0; i--) {
+ children = node.childNodes;
+
+ if (path[i] > children.length - 1) {
+ return null;
+ }
+
+ node = children[path[i]];
+ }
+
+ return node;
+ }
+
+ return {
+ create: create,
+ resolve: resolve
+ };
+});
+
+// Included from: js/tinymce/classes/util/Quirks.js
+
+/**
+ * Quirks.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ *
+ * @ignore-file
+ */
+
+/**
+ * This file includes fixes for various browser quirks it's made to make it easy to add/remove browser specific fixes.
+ *
+ * @private
+ * @class tinymce.util.Quirks
+ */
+define("tinymce/util/Quirks", [
+ "tinymce/util/VK",
+ "tinymce/dom/RangeUtils",
+ "tinymce/dom/TreeWalker",
+ "tinymce/dom/NodePath",
+ "tinymce/html/Node",
+ "tinymce/html/Entities",
+ "tinymce/Env",
+ "tinymce/util/Tools",
+ "tinymce/util/Delay",
+ "tinymce/caret/CaretContainer",
+ "tinymce/caret/CaretPosition",
+ "tinymce/caret/CaretWalker"
+], function(VK, RangeUtils, TreeWalker, NodePath, Node, Entities, Env, Tools, Delay, CaretContainer, CaretPosition, CaretWalker) {
+ return function(editor) {
+ var each = Tools.each, $ = editor.$;
+ var BACKSPACE = VK.BACKSPACE, DELETE = VK.DELETE, dom = editor.dom, selection = editor.selection,
+ settings = editor.settings, parser = editor.parser, serializer = editor.serializer;
+ var isGecko = Env.gecko, isIE = Env.ie, isWebKit = Env.webkit;
+ var mceInternalUrlPrefix = 'data:text/mce-internal,';
+ var mceInternalDataType = isIE ? 'Text' : 'URL';
+
+ /**
+ * Executes a command with a specific state this can be to enable/disable browser editing features.
+ */
+ function setEditorCommandState(cmd, state) {
+ try {
+ editor.getDoc().execCommand(cmd, false, state);
+ } catch (ex) {
+ // Ignore
+ }
+ }
+
+ /**
+ * Returns current IE document mode.
+ */
+ function getDocumentMode() {
+ var documentMode = editor.getDoc().documentMode;
+
+ return documentMode ? documentMode : 6;
+ }
+
+ /**
+ * Returns true/false if the event is prevented or not.
+ *
+ * @private
+ * @param {Event} e Event object.
+ * @return {Boolean} true/false if the event is prevented or not.
+ */
+ function isDefaultPrevented(e) {
+ return e.isDefaultPrevented();
+ }
+
+ /**
+ * Sets Text/URL data on the event's dataTransfer object to a special data:text/mce-internal url.
+ * This is to workaround the inability to set custom contentType on IE and Safari.
+ * The editor's selected content is encoded into this url so drag and drop between editors will work.
+ *
+ * @private
+ * @param {DragEvent} e Event object
+ */
+ function setMceInternalContent(e) {
+ var selectionHtml, internalContent;
+
+ if (e.dataTransfer) {
+ if (editor.selection.isCollapsed() && e.target.tagName == 'IMG') {
+ selection.select(e.target);
+ }
+
+ selectionHtml = editor.selection.getContent();
+
+ // Safari/IE doesn't support custom dataTransfer items so we can only use URL and Text
+ if (selectionHtml.length > 0) {
+ internalContent = mceInternalUrlPrefix + escape(editor.id) + ',' + escape(selectionHtml);
+ e.dataTransfer.setData(mceInternalDataType, internalContent);
+ }
+ }
+ }
+
+ /**
+ * Gets content of special data:text/mce-internal url on the event's dataTransfer object.
+ * This is to workaround the inability to set custom contentType on IE and Safari.
+ * The editor's selected content is encoded into this url so drag and drop between editors will work.
+ *
+ * @private
+ * @param {DragEvent} e Event object
+ * @returns {String} mce-internal content
+ */
+ function getMceInternalContent(e) {
+ var internalContent;
+
+ if (e.dataTransfer) {
+ internalContent = e.dataTransfer.getData(mceInternalDataType);
+
+ if (internalContent && internalContent.indexOf(mceInternalUrlPrefix) >= 0) {
+ internalContent = internalContent.substr(mceInternalUrlPrefix.length).split(',');
+
+ return {
+ id: unescape(internalContent[0]),
+ html: unescape(internalContent[1])
+ };
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Inserts contents using the paste clipboard command if it's available if it isn't it will fallback
+ * to the core command.
+ *
+ * @private
+ * @param {String} content Content to insert at selection.
+ */
+ function insertClipboardContents(content) {
+ if (editor.queryCommandSupported('mceInsertClipboardContent')) {
+ editor.execCommand('mceInsertClipboardContent', false, {content: content});
+ } else {
+ editor.execCommand('mceInsertContent', false, content);
+ }
+ }
+
+ /**
+ * Fixes a WebKit bug when deleting contents using backspace or delete key.
+ * WebKit will produce a span element if you delete across two block elements.
+ *
+ * Example:
+ *
a
|b
+ *
+ * Will produce this on backspace:
+ *
ab
+ *
+ * This fixes the backspace to produce:
+ * a|b
+ *
+ * See bug: https://bugs.webkit.org/show_bug.cgi?id=45784
+ *
+ * This fixes the following delete scenarios:
+ * 1. Delete by pressing backspace key.
+ * 2. Delete by pressing delete key.
+ * 3. Delete by pressing backspace key with ctrl/cmd (Word delete).
+ * 4. Delete by pressing delete key with ctrl/cmd (Word delete).
+ * 5. Delete by drag/dropping contents inside the editor.
+ * 6. Delete by using Cut Ctrl+X/Cmd+X.
+ * 7. Delete by selecting contents and writing a character.
+ *
+ * This code is a ugly hack since writing full custom delete logic for just this bug
+ * fix seemed like a huge task. I hope we can remove this before the year 2030.
+ */
+ function cleanupStylesWhenDeleting() {
+ var doc = editor.getDoc(), dom = editor.dom, selection = editor.selection;
+ var MutationObserver = window.MutationObserver, olderWebKit, dragStartRng;
+
+ // Add mini polyfill for older WebKits
+ // TODO: Remove this when old Safari versions gets updated
+ if (!MutationObserver) {
+ olderWebKit = true;
+
+ MutationObserver = function() {
+ var records = [], target;
+
+ function nodeInsert(e) {
+ var target = e.relatedNode || e.target;
+ records.push({target: target, addedNodes: [target]});
+ }
+
+ function attrModified(e) {
+ var target = e.relatedNode || e.target;
+ records.push({target: target, attributeName: e.attrName});
+ }
+
+ this.observe = function(node) {
+ target = node;
+ target.addEventListener('DOMSubtreeModified', nodeInsert, false);
+ target.addEventListener('DOMNodeInsertedIntoDocument', nodeInsert, false);
+ target.addEventListener('DOMNodeInserted', nodeInsert, false);
+ target.addEventListener('DOMAttrModified', attrModified, false);
+ };
+
+ this.disconnect = function() {
+ target.removeEventListener('DOMSubtreeModified', nodeInsert, false);
+ target.removeEventListener('DOMNodeInsertedIntoDocument', nodeInsert, false);
+ target.removeEventListener('DOMNodeInserted', nodeInsert, false);
+ target.removeEventListener('DOMAttrModified', attrModified, false);
+ };
+
+ this.takeRecords = function() {
+ return records;
+ };
+ };
+ }
+
+ function isTrailingBr(node) {
+ var blockElements = dom.schema.getBlockElements(), rootNode = editor.getBody();
+
+ if (node.nodeName != 'BR') {
+ return false;
+ }
+
+ for (; node != rootNode && !blockElements[node.nodeName]; node = node.parentNode) {
+ if (node.nextSibling) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function isSiblingsIgnoreWhiteSpace(node1, node2) {
+ var node;
+
+ for (node = node1.nextSibling; node && node != node2; node = node.nextSibling) {
+ if (node.nodeType == 3 && $.trim(node.data).length === 0) {
+ continue;
+ }
+
+ if (node !== node2) {
+ return false;
+ }
+ }
+
+ return node === node2;
+ }
+
+ function findCaretNode(node, forward, startNode) {
+ var walker, current, nonEmptyElements;
+
+ nonEmptyElements = dom.schema.getNonEmptyElements();
+
+ walker = new TreeWalker(startNode || node, node);
+
+ while ((current = walker[forward ? 'next' : 'prev']())) {
+ if (nonEmptyElements[current.nodeName] && !isTrailingBr(current)) {
+ return current;
+ }
+
+ if (current.nodeType == 3 && current.data.length > 0) {
+ return current;
+ }
+ }
+ }
+
+ function deleteRangeBetweenTextBlocks(rng) {
+ var startBlock, endBlock, caretNodeBefore, caretNodeAfter, textBlockElements;
+
+ if (rng.collapsed) {
+ return;
+ }
+
+ startBlock = dom.getParent(RangeUtils.getNode(rng.startContainer, rng.startOffset), dom.isBlock);
+ endBlock = dom.getParent(RangeUtils.getNode(rng.endContainer, rng.endOffset), dom.isBlock);
+ textBlockElements = editor.schema.getTextBlockElements();
+
+ if (startBlock == endBlock) {
+ return;
+ }
+
+ if (!textBlockElements[startBlock.nodeName] || !textBlockElements[endBlock.nodeName]) {
+ return;
+ }
+
+ if (dom.getContentEditable(startBlock) === "false" || dom.getContentEditable(endBlock) === "false") {
+ return;
+ }
+
+ rng.deleteContents();
+
+ caretNodeBefore = findCaretNode(startBlock, false);
+ caretNodeAfter = findCaretNode(endBlock, true);
+
+ if (!dom.isEmpty(endBlock)) {
+ $(startBlock).append(endBlock.childNodes);
+ }
+
+ $(endBlock).remove();
+
+ if (caretNodeBefore) {
+ if (caretNodeBefore.nodeType == 1) {
+ if (caretNodeBefore.nodeName == "BR") {
+ rng.setStartBefore(caretNodeBefore);
+ rng.setEndBefore(caretNodeBefore);
+ } else {
+ rng.setStartAfter(caretNodeBefore);
+ rng.setEndAfter(caretNodeBefore);
+ }
+ } else {
+ rng.setStart(caretNodeBefore, caretNodeBefore.data.length);
+ rng.setEnd(caretNodeBefore, caretNodeBefore.data.length);
+ }
+ } else if (caretNodeAfter) {
+ if (caretNodeAfter.nodeType == 1) {
+ rng.setStartBefore(caretNodeAfter);
+ rng.setEndBefore(caretNodeAfter);
+ } else {
+ rng.setStart(caretNodeAfter, 0);
+ rng.setEnd(caretNodeAfter, 0);
+ }
+ }
+
+ selection.setRng(rng);
+
+ return true;
+ }
+
+ function expandBetweenBlocks(rng, isForward) {
+ var caretNode, targetCaretNode, textBlock, targetTextBlock, container, offset;
+
+ if (!rng.collapsed) {
+ return rng;
+ }
+
+ container = rng.startContainer;
+ offset = rng.startOffset;
+
+ if (container.nodeType == 3) {
+ if (isForward) {
+ if (offset < container.data.length) {
+ return rng;
+ }
+ } else {
+ if (offset > 0) {
+ return rng;
+ }
+ }
+ }
+
+ caretNode = RangeUtils.getNode(rng.startContainer, rng.startOffset);
+ textBlock = dom.getParent(caretNode, dom.isBlock);
+ targetCaretNode = findCaretNode(editor.getBody(), isForward, caretNode);
+ targetTextBlock = dom.getParent(targetCaretNode, dom.isBlock);
+
+ if (!caretNode || !targetCaretNode) {
+ return rng;
+ }
+
+ if (targetTextBlock && textBlock != targetTextBlock) {
+ if (!isForward) {
+ if (!isSiblingsIgnoreWhiteSpace(targetTextBlock, textBlock)) {
+ return rng;
+ }
+
+ if (targetCaretNode.nodeType == 1) {
+ if (targetCaretNode.nodeName == "BR") {
+ rng.setStartBefore(targetCaretNode);
+ } else {
+ rng.setStartAfter(targetCaretNode);
+ }
+ } else {
+ rng.setStart(targetCaretNode, targetCaretNode.data.length);
+ }
+
+ if (caretNode.nodeType == 1) {
+ rng.setEnd(caretNode, 0);
+ } else {
+ rng.setEndBefore(caretNode);
+ }
+ } else {
+ if (!isSiblingsIgnoreWhiteSpace(textBlock, targetTextBlock)) {
+ return rng;
+ }
+
+ if (caretNode.nodeType == 1) {
+ if (caretNode.nodeName == "BR") {
+ rng.setStartBefore(caretNode);
+ } else {
+ rng.setStartAfter(caretNode);
+ }
+ } else {
+ rng.setStart(caretNode, caretNode.data.length);
+ }
+
+ if (targetCaretNode.nodeType == 1) {
+ rng.setEnd(targetCaretNode, 0);
+ } else {
+ rng.setEndBefore(targetCaretNode);
+ }
+ }
+ }
+
+ return rng;
+ }
+
+ function handleTextBlockMergeDelete(isForward) {
+ var rng = selection.getRng();
+
+ rng = expandBetweenBlocks(rng, isForward);
+
+ if (deleteRangeBetweenTextBlocks(rng)) {
+ return true;
+ }
+ }
+
+ /**
+ * This retains the formatting if the last character is to be deleted.
+ *
+ * Backspace on this:
a|
would become
|
in WebKit.
+ * With this patch:
|
+ */
+ function handleLastBlockCharacterDelete(isForward, rng) {
+ var path, blockElm, newBlockElm, clonedBlockElm, sibling,
+ container, offset, br, currentFormatNodes;
+
+ function cloneTextBlockWithFormats(blockElm, node) {
+ currentFormatNodes = $(node).parents().filter(function(idx, node) {
+ return !!editor.schema.getTextInlineElements()[node.nodeName];
+ });
+
+ newBlockElm = blockElm.cloneNode(false);
+
+ currentFormatNodes = Tools.map(currentFormatNodes, function(formatNode) {
+ formatNode = formatNode.cloneNode(false);
+
+ if (newBlockElm.hasChildNodes()) {
+ formatNode.appendChild(newBlockElm.firstChild);
+ newBlockElm.appendChild(formatNode);
+ } else {
+ newBlockElm.appendChild(formatNode);
+ }
+
+ newBlockElm.appendChild(formatNode);
+
+ return formatNode;
+ });
+
+ if (currentFormatNodes.length) {
+ br = dom.create('br');
+ currentFormatNodes[0].appendChild(br);
+ dom.replace(newBlockElm, blockElm);
+
+ rng.setStartBefore(br);
+ rng.setEndBefore(br);
+ editor.selection.setRng(rng);
+
+ return br;
+ }
+
+ return null;
+ }
+
+ function isTextBlock(node) {
+ return node && editor.schema.getTextBlockElements()[node.tagName];
+ }
+
+ if (!rng.collapsed) {
+ return;
+ }
+
+ container = rng.startContainer;
+ offset = rng.startOffset;
+ blockElm = dom.getParent(container, dom.isBlock);
+ if (!isTextBlock(blockElm)) {
+ return;
+ }
+
+ if (container.nodeType == 1) {
+ container = container.childNodes[offset];
+ if (container && container.tagName != 'BR') {
+ return;
+ }
+
+ if (isForward) {
+ sibling = blockElm.nextSibling;
+ } else {
+ sibling = blockElm.previousSibling;
+ }
+
+ if (dom.isEmpty(blockElm) && isTextBlock(sibling) && dom.isEmpty(sibling)) {
+ if (cloneTextBlockWithFormats(blockElm, container)) {
+ dom.remove(sibling);
+ return true;
+ }
+ }
+ } else if (container.nodeType == 3) {
+ path = NodePath.create(blockElm, container);
+ clonedBlockElm = blockElm.cloneNode(true);
+ container = NodePath.resolve(clonedBlockElm, path);
+
+ if (isForward) {
+ if (offset >= container.data.length) {
+ return;
+ }
+
+ container.deleteData(offset, 1);
+ } else {
+ if (offset <= 0) {
+ return;
+ }
+
+ container.deleteData(offset - 1, 1);
+ }
+
+ if (dom.isEmpty(clonedBlockElm)) {
+ return cloneTextBlockWithFormats(blockElm, container);
+ }
+ }
+ }
+
+ function customDelete(isForward) {
+ var mutationObserver, rng, caretElement;
+
+ if (handleTextBlockMergeDelete(isForward)) {
+ return;
+ }
+
+ Tools.each(editor.getBody().getElementsByTagName('*'), function(elm) {
+ // Mark existing spans
+ if (elm.tagName == 'SPAN') {
+ elm.setAttribute('mce-data-marked', 1);
+ }
+
+ // Make sure all elements has a data-mce-style attribute
+ if (!elm.hasAttribute('data-mce-style') && elm.hasAttribute('style')) {
+ editor.dom.setAttrib(elm, 'style', editor.dom.getAttrib(elm, 'style'));
+ }
+ });
+
+ // Observe added nodes and style attribute changes
+ mutationObserver = new MutationObserver(function() {});
+ mutationObserver.observe(editor.getDoc(), {
+ childList: true,
+ attributes: true,
+ subtree: true,
+ attributeFilter: ['style']
+ });
+
+ editor.getDoc().execCommand(isForward ? 'ForwardDelete' : 'Delete', false, null);
+
+ rng = editor.selection.getRng();
+ caretElement = rng.startContainer.parentNode;
+
+ Tools.each(mutationObserver.takeRecords(), function(record) {
+ if (!dom.isChildOf(record.target, editor.getBody())) {
+ return;
+ }
+
+ // Restore style attribute to previous value
+ if (record.attributeName == "style") {
+ var oldValue = record.target.getAttribute('data-mce-style');
+
+ if (oldValue) {
+ record.target.setAttribute("style", oldValue);
+ } else {
+ record.target.removeAttribute("style");
+ }
+ }
+
+ // Remove all spans that aren't marked and retain selection
+ Tools.each(record.addedNodes, function(node) {
+ if (node.nodeName == "SPAN" && !node.getAttribute('mce-data-marked')) {
+ var offset, container;
+
+ if (node == caretElement) {
+ offset = rng.startOffset;
+ container = node.firstChild;
+ }
+
+ dom.remove(node, true);
+
+ if (container) {
+ rng.setStart(container, offset);
+ rng.setEnd(container, offset);
+ editor.selection.setRng(rng);
+ }
+ }
+ });
+ });
+
+ mutationObserver.disconnect();
+
+ // Remove any left over marks
+ Tools.each(editor.dom.select('span[mce-data-marked]'), function(span) {
+ span.removeAttribute('mce-data-marked');
+ });
+ }
+
+ editor.on('keydown', function(e) {
+ var isForward = e.keyCode == DELETE, isMetaOrCtrl = e.ctrlKey || e.metaKey;
+
+ if (!isDefaultPrevented(e) && (isForward || e.keyCode == BACKSPACE)) {
+ var rng = editor.selection.getRng(), container = rng.startContainer, offset = rng.startOffset;
+
+ // Shift+Delete is cut
+ if (isForward && e.shiftKey) {
+ return;
+ }
+
+ if (handleLastBlockCharacterDelete(isForward, rng)) {
+ e.preventDefault();
+ return;
+ }
+
+ // Ignore non meta delete in the where there is text before/after the caret
+ if (!isMetaOrCtrl && rng.collapsed && container.nodeType == 3) {
+ if (isForward ? offset < container.data.length : offset > 0) {
+ return;
+ }
+ }
+
+ e.preventDefault();
+
+ if (isMetaOrCtrl) {
+ editor.selection.getSel().modify("extend", isForward ? "forward" : "backward", e.metaKey ? "lineboundary" : "word");
+ }
+
+ customDelete(isForward);
+ }
+ });
+
+ // Handle case where text is deleted by typing over
+ editor.on('keypress', function(e) {
+ if (!isDefaultPrevented(e) && !selection.isCollapsed() && e.charCode > 31 && !VK.metaKeyPressed(e)) {
+ var rng, currentFormatNodes, fragmentNode, blockParent, caretNode, charText;
+
+ rng = editor.selection.getRng();
+ charText = String.fromCharCode(e.charCode);
+ e.preventDefault();
+
+ // Keep track of current format nodes
+ currentFormatNodes = $(rng.startContainer).parents().filter(function(idx, node) {
+ return !!editor.schema.getTextInlineElements()[node.nodeName];
+ });
+
+ customDelete(true);
+
+ // Check if the browser removed them
+ currentFormatNodes = currentFormatNodes.filter(function(idx, node) {
+ return !$.contains(editor.getBody(), node);
+ });
+
+ // Then re-add them
+ if (currentFormatNodes.length) {
+ fragmentNode = dom.createFragment();
+
+ currentFormatNodes.each(function(idx, formatNode) {
+ formatNode = formatNode.cloneNode(false);
+
+ if (fragmentNode.hasChildNodes()) {
+ formatNode.appendChild(fragmentNode.firstChild);
+ fragmentNode.appendChild(formatNode);
+ } else {
+ caretNode = formatNode;
+ fragmentNode.appendChild(formatNode);
+ }
+
+ fragmentNode.appendChild(formatNode);
+ });
+
+ caretNode.appendChild(editor.getDoc().createTextNode(charText));
+
+ // Prevent edge case where older WebKit would add an extra BR element
+ blockParent = dom.getParent(rng.startContainer, dom.isBlock);
+ if (dom.isEmpty(blockParent)) {
+ $(blockParent).empty().append(fragmentNode);
+ } else {
+ rng.insertNode(fragmentNode);
+ }
+
+ rng.setStart(caretNode.firstChild, 1);
+ rng.setEnd(caretNode.firstChild, 1);
+ editor.selection.setRng(rng);
+ } else {
+ editor.selection.setContent(charText);
+ }
+ }
+ });
+
+ editor.addCommand('Delete', function() {
+ customDelete();
+ });
+
+ editor.addCommand('ForwardDelete', function() {
+ customDelete(true);
+ });
+
+ // Older WebKits doesn't properly handle the clipboard so we can't add the rest
+ if (olderWebKit) {
+ return;
+ }
+
+ editor.on('dragstart', function(e) {
+ dragStartRng = selection.getRng();
+ setMceInternalContent(e);
+ });
+
+ editor.on('drop', function(e) {
+ if (!isDefaultPrevented(e)) {
+ var internalContent = getMceInternalContent(e);
+
+ if (internalContent) {
+ e.preventDefault();
+
+ // Safari has a weird issue where drag/dropping images sometimes
+ // produces a green plus icon. When this happens the caretRangeFromPoint
+ // will return "null" even though the x, y coordinate is correct.
+ // But if we detach the insert from the drop event we will get a proper range
+ Delay.setEditorTimeout(editor, function() {
+ var pointRng = RangeUtils.getCaretRangeFromPoint(e.x, e.y, doc);
+
+ if (dragStartRng) {
+ selection.setRng(dragStartRng);
+ dragStartRng = null;
+ }
+
+ customDelete();
+ selection.setRng(pointRng);
+ insertClipboardContents(internalContent.html);
+ });
+ }
+ }
+ });
+
+ editor.on('cut', function(e) {
+ if (!isDefaultPrevented(e) && e.clipboardData && !editor.selection.isCollapsed()) {
+ e.preventDefault();
+ e.clipboardData.clearData();
+ e.clipboardData.setData('text/html', editor.selection.getContent());
+ e.clipboardData.setData('text/plain', editor.selection.getContent({format: 'text'}));
+
+ // Needed delay for https://code.google.com/p/chromium/issues/detail?id=363288#c3
+ // Nested delete/forwardDelete not allowed on execCommand("cut")
+ // This is ugly but not sure how to work around it otherwise
+ Delay.setEditorTimeout(editor, function() {
+ customDelete(true);
+ });
+ }
+ });
+ }
+
+ /**
+ * Makes sure that the editor body becomes empty when backspace or delete is pressed in empty editors.
+ *
+ * For example:
+ *
|
+ *
+ * Or:
+ *
|
+ *
+ * Or:
+ * [
]
+ */
+ function emptyEditorWhenDeleting() {
+ function serializeRng(rng) {
+ var body = dom.create("body");
+ var contents = rng.cloneContents();
+ body.appendChild(contents);
+ return selection.serializer.serialize(body, {format: 'html'});
+ }
+
+ function allContentsSelected(rng) {
+ if (!rng.setStart) {
+ if (rng.item) {
+ return false;
+ }
+
+ var bodyRng = rng.duplicate();
+ bodyRng.moveToElementText(editor.getBody());
+ return RangeUtils.compareRanges(rng, bodyRng);
+ }
+
+ var selection = serializeRng(rng);
+
+ var allRng = dom.createRng();
+ allRng.selectNode(editor.getBody());
+
+ var allSelection = serializeRng(allRng);
+ return selection === allSelection;
+ }
+
+ editor.on('keydown', function(e) {
+ var keyCode = e.keyCode, isCollapsed, body;
+
+ // Empty the editor if it's needed for example backspace at
|
+ if (!isDefaultPrevented(e) && (keyCode == DELETE || keyCode == BACKSPACE)) {
+ isCollapsed = editor.selection.isCollapsed();
+ body = editor.getBody();
+
+ // Selection is collapsed but the editor isn't empty
+ if (isCollapsed && !dom.isEmpty(body)) {
+ return;
+ }
+
+ // Selection isn't collapsed but not all the contents is selected
+ if (!isCollapsed && !allContentsSelected(editor.selection.getRng())) {
+ return;
+ }
+
+ // Manually empty the editor
+ e.preventDefault();
+ editor.setContent('');
+
+ if (body.firstChild && dom.isBlock(body.firstChild)) {
+ editor.selection.setCursorLocation(body.firstChild, 0);
+ } else {
+ editor.selection.setCursorLocation(body, 0);
+ }
+
+ editor.nodeChanged();
+ }
+ });
+ }
+
+ /**
+ * WebKit doesn't select all the nodes in the body when you press Ctrl+A.
+ * IE selects more than the contents [
a
] instead of
[a] see bug #6438
+ * This selects the whole body so that backspace/delete logic will delete everything
+ */
+ function selectAll() {
+ editor.shortcuts.add('meta+a', null, 'SelectAll');
+ }
+
+ /**
+ * WebKit has a weird issue where it some times fails to properly convert keypresses to input method keystrokes.
+ * The IME on Mac doesn't initialize when it doesn't fire a proper focus event.
+ *
+ * This seems to happen when the user manages to click the documentElement element then the window doesn't get proper focus until
+ * you enter a character into the editor.
+ *
+ * It also happens when the first focus in made to the body.
+ *
+ * See: https://bugs.webkit.org/show_bug.cgi?id=83566
+ */
+ function inputMethodFocus() {
+ if (!editor.settings.content_editable) {
+ // Case 1 IME doesn't initialize if you focus the document
+ // Disabled since it was interferring with the cE=false logic
+ // Also coultn't reproduce the issue on Safari 9
+ /*dom.bind(editor.getDoc(), 'focusin', function() {
+ selection.setRng(selection.getRng());
+ });*/
+
+ // Case 2 IME doesn't initialize if you click the documentElement it also doesn't properly fire the focusin event
+ // Needs to be both down/up due to weird rendering bug on Chrome Windows
+ dom.bind(editor.getDoc(), 'mousedown mouseup', function(e) {
+ var rng;
+
+ if (e.target == editor.getDoc().documentElement) {
+ rng = selection.getRng();
+ editor.getBody().focus();
+
+ if (e.type == 'mousedown') {
+ if (CaretContainer.isCaretContainer(rng.startContainer)) {
+ return;
+ }
+
+ // Edge case for mousedown, drag select and mousedown again within selection on Chrome Windows to render caret
+ selection.placeCaretAt(e.clientX, e.clientY);
+ } else {
+ selection.setRng(rng);
+ }
+ }
+ });
+ }
+ }
+
+ /**
+ * Backspacing in FireFox/IE from a paragraph into a horizontal rule results in a floating text node because the
+ * browser just deletes the paragraph - the browser fails to merge the text node with a horizontal rule so it is
+ * left there. TinyMCE sees a floating text node and wraps it in a paragraph on the key up event (ForceBlocks.js
+ * addRootBlocks), meaning the action does nothing. With this code, FireFox/IE matche the behaviour of other
+ * browsers.
+ *
+ * It also fixes a bug on Firefox where it's impossible to delete HR elements.
+ */
+ function removeHrOnBackspace() {
+ editor.on('keydown', function(e) {
+ if (!isDefaultPrevented(e) && e.keyCode === BACKSPACE) {
+ // Check if there is any HR elements this is faster since getRng on IE 7 & 8 is slow
+ if (!editor.getBody().getElementsByTagName('hr').length) {
+ return;
+ }
+
+ if (selection.isCollapsed() && selection.getRng(true).startOffset === 0) {
+ var node = selection.getNode();
+ var previousSibling = node.previousSibling;
+
+ if (node.nodeName == 'HR') {
+ dom.remove(node);
+ e.preventDefault();
+ return;
+ }
+
+ if (previousSibling && previousSibling.nodeName && previousSibling.nodeName.toLowerCase() === "hr") {
+ dom.remove(previousSibling);
+ e.preventDefault();
+ }
+ }
+ }
+ });
+ }
+
+ /**
+ * Firefox 3.x has an issue where the body element won't get proper focus if you click out
+ * side it's rectangle.
+ */
+ function focusBody() {
+ // Fix for a focus bug in FF 3.x where the body element
+ // wouldn't get proper focus if the user clicked on the HTML element
+ if (!window.Range.prototype.getClientRects) { // Detect getClientRects got introduced in FF 4
+ editor.on('mousedown', function(e) {
+ if (!isDefaultPrevented(e) && e.target.nodeName === "HTML") {
+ var body = editor.getBody();
+
+ // Blur the body it's focused but not correctly focused
+ body.blur();
+
+ // Refocus the body after a little while
+ Delay.setEditorTimeout(editor, function() {
+ body.focus();
+ });
+ }
+ });
+ }
+ }
+
+ /**
+ * WebKit has a bug where it isn't possible to select image, hr or anchor elements
+ * by clicking on them so we need to fake that.
+ */
+ function selectControlElements() {
+ editor.on('click', function(e) {
+ var target = e.target;
+
+ // Workaround for bug, http://bugs.webkit.org/show_bug.cgi?id=12250
+ // WebKit can't even do simple things like selecting an image
+ // Needs to be the setBaseAndExtend or it will fail to select floated images
+ if (/^(IMG|HR)$/.test(target.nodeName) && dom.getContentEditableParent(target) !== "false") {
+ e.preventDefault();
+ selection.getSel().setBaseAndExtent(target, 0, target, 1);
+ editor.nodeChanged();
+ }
+
+ if (target.nodeName == 'A' && dom.hasClass(target, 'mce-item-anchor')) {
+ e.preventDefault();
+ selection.select(target);
+ }
+ });
+ }
+
+ /**
+ * Fixes a Gecko bug where the style attribute gets added to the wrong element when deleting between two block elements.
+ *
+ * Fixes do backspace/delete on this:
+ *
bla[ck
r]ed
+ *
+ * Would become:
+ *
bla|ed
+ *
+ * Instead of:
+ *
bla|ed
+ */
+ function removeStylesWhenDeletingAcrossBlockElements() {
+ function getAttributeApplyFunction() {
+ var template = dom.getAttribs(selection.getStart().cloneNode(false));
+
+ return function() {
+ var target = selection.getStart();
+
+ if (target !== editor.getBody()) {
+ dom.setAttrib(target, "style", null);
+
+ each(template, function(attr) {
+ target.setAttributeNode(attr.cloneNode(true));
+ });
+ }
+ };
+ }
+
+ function isSelectionAcrossElements() {
+ return !selection.isCollapsed() &&
+ dom.getParent(selection.getStart(), dom.isBlock) != dom.getParent(selection.getEnd(), dom.isBlock);
+ }
+
+ editor.on('keypress', function(e) {
+ var applyAttributes;
+
+ if (!isDefaultPrevented(e) && (e.keyCode == 8 || e.keyCode == 46) && isSelectionAcrossElements()) {
+ applyAttributes = getAttributeApplyFunction();
+ editor.getDoc().execCommand('delete', false, null);
+ applyAttributes();
+ e.preventDefault();
+ return false;
+ }
+ });
+
+ dom.bind(editor.getDoc(), 'cut', function(e) {
+ var applyAttributes;
+
+ if (!isDefaultPrevented(e) && isSelectionAcrossElements()) {
+ applyAttributes = getAttributeApplyFunction();
+
+ Delay.setEditorTimeout(editor, function() {
+ applyAttributes();
+ });
+ }
+ });
+ }
+
+ /**
+ * Screen readers on IE needs to have the role application set on the body.
+ */
+ function ensureBodyHasRoleApplication() {
+ document.body.setAttribute("role", "application");
+ }
+
+ /**
+ * Backspacing into a table behaves differently depending upon browser type.
+ * Therefore, disable Backspace when cursor immediately follows a table.
+ */
+ function disableBackspaceIntoATable() {
+ editor.on('keydown', function(e) {
+ if (!isDefaultPrevented(e) && e.keyCode === BACKSPACE) {
+ if (selection.isCollapsed() && selection.getRng(true).startOffset === 0) {
+ var previousSibling = selection.getNode().previousSibling;
+ if (previousSibling && previousSibling.nodeName && previousSibling.nodeName.toLowerCase() === "table") {
+ e.preventDefault();
+ return false;
+ }
+ }
+ }
+ });
+ }
+
+ /**
+ * Old IE versions can't properly render BR elements in PRE tags white in contentEditable mode. So this
+ * logic adds a \n before the BR so that it will get rendered.
+ */
+ function addNewLinesBeforeBrInPre() {
+ // IE8+ rendering mode does the right thing with BR in PRE
+ if (getDocumentMode() > 7) {
+ return;
+ }
+
+ // Enable display: none in area and add a specific class that hides all BR elements in PRE to
+ // avoid the caret from getting stuck at the BR elements while pressing the right arrow key
+ setEditorCommandState('RespectVisibilityInDesign', true);
+ editor.contentStyles.push('.mceHideBrInPre pre br {display: none}');
+ dom.addClass(editor.getBody(), 'mceHideBrInPre');
+
+ // Adds a \n before all BR elements in PRE to get them visual
+ parser.addNodeFilter('pre', function(nodes) {
+ var i = nodes.length, brNodes, j, brElm, sibling;
+
+ while (i--) {
+ brNodes = nodes[i].getAll('br');
+ j = brNodes.length;
+ while (j--) {
+ brElm = brNodes[j];
+
+ // Add \n before BR in PRE elements on older IE:s so the new lines get rendered
+ sibling = brElm.prev;
+ if (sibling && sibling.type === 3 && sibling.value.charAt(sibling.value - 1) != '\n') {
+ sibling.value += '\n';
+ } else {
+ brElm.parent.insert(new Node('#text', 3), brElm, true).value = '\n';
+ }
+ }
+ }
+ });
+
+ // Removes any \n before BR elements in PRE since other browsers and in contentEditable=false mode they will be visible
+ serializer.addNodeFilter('pre', function(nodes) {
+ var i = nodes.length, brNodes, j, brElm, sibling;
+
+ while (i--) {
+ brNodes = nodes[i].getAll('br');
+ j = brNodes.length;
+ while (j--) {
+ brElm = brNodes[j];
+ sibling = brElm.prev;
+ if (sibling && sibling.type == 3) {
+ sibling.value = sibling.value.replace(/\r?\n$/, '');
+ }
+ }
+ }
+ });
+ }
+
+ /**
+ * Moves style width/height to attribute width/height when the user resizes an image on IE.
+ */
+ function removePreSerializedStylesWhenSelectingControls() {
+ dom.bind(editor.getBody(), 'mouseup', function() {
+ var value, node = selection.getNode();
+
+ // Moved styles to attributes on IMG eements
+ if (node.nodeName == 'IMG') {
+ // Convert style width to width attribute
+ if ((value = dom.getStyle(node, 'width'))) {
+ dom.setAttrib(node, 'width', value.replace(/[^0-9%]+/g, ''));
+ dom.setStyle(node, 'width', '');
+ }
+
+ // Convert style height to height attribute
+ if ((value = dom.getStyle(node, 'height'))) {
+ dom.setAttrib(node, 'height', value.replace(/[^0-9%]+/g, ''));
+ dom.setStyle(node, 'height', '');
+ }
+ }
+ });
+ }
+
+ /**
+ * Removes a blockquote when backspace is pressed at the beginning of it.
+ *
+ * For example:
+ *
|x
+ *
+ * Becomes:
+ *
|x
+ */
+ function removeBlockQuoteOnBackSpace() {
+ // Add block quote deletion handler
+ editor.on('keydown', function(e) {
+ var rng, container, offset, root, parent;
+
+ if (isDefaultPrevented(e) || e.keyCode != VK.BACKSPACE) {
+ return;
+ }
+
+ rng = selection.getRng();
+ container = rng.startContainer;
+ offset = rng.startOffset;
+ root = dom.getRoot();
+ parent = container;
+
+ if (!rng.collapsed || offset !== 0) {
+ return;
+ }
+
+ while (parent && parent.parentNode && parent.parentNode.firstChild == parent && parent.parentNode != root) {
+ parent = parent.parentNode;
+ }
+
+ // Is the cursor at the beginning of a blockquote?
+ if (parent.tagName === 'BLOCKQUOTE') {
+ // Remove the blockquote
+ editor.formatter.toggle('blockquote', null, parent);
+
+ // Move the caret to the beginning of container
+ rng = dom.createRng();
+ rng.setStart(container, 0);
+ rng.setEnd(container, 0);
+ selection.setRng(rng);
+ }
+ });
+ }
+
+ /**
+ * Sets various Gecko editing options on mouse down and before a execCommand to disable inline table editing that is broken etc.
+ */
+ function setGeckoEditingOptions() {
+ function setOpts() {
+ refreshContentEditable();
+
+ setEditorCommandState("StyleWithCSS", false);
+ setEditorCommandState("enableInlineTableEditing", false);
+
+ if (!settings.object_resizing) {
+ setEditorCommandState("enableObjectResizing", false);
+ }
+ }
+
+ if (!settings.readonly) {
+ editor.on('BeforeExecCommand MouseDown', setOpts);
+ }
+ }
+
+ /**
+ * Fixes a gecko link bug, when a link is placed at the end of block elements there is
+ * no way to move the caret behind the link. This fix adds a bogus br element after the link.
+ *
+ * For example this:
+ *
x
+ *
+ * Becomes this:
+ *
x
+ */
+ function addBrAfterLastLinks() {
+ function fixLinks() {
+ each(dom.select('a'), function(node) {
+ var parentNode = node.parentNode, root = dom.getRoot();
+
+ if (parentNode.lastChild === node) {
+ while (parentNode && !dom.isBlock(parentNode)) {
+ if (parentNode.parentNode.lastChild !== parentNode || parentNode === root) {
+ return;
+ }
+
+ parentNode = parentNode.parentNode;
+ }
+
+ dom.add(parentNode, 'br', {'data-mce-bogus': 1});
+ }
+ });
+ }
+
+ editor.on('SetContent ExecCommand', function(e) {
+ if (e.type == "setcontent" || e.command === 'mceInsertLink') {
+ fixLinks();
+ }
+ });
+ }
+
+ /**
+ * WebKit will produce DIV elements here and there by default. But since TinyMCE uses paragraphs by
+ * default we want to change that behavior.
+ */
+ function setDefaultBlockType() {
+ if (settings.forced_root_block) {
+ editor.on('init', function() {
+ setEditorCommandState('DefaultParagraphSeparator', settings.forced_root_block);
+ });
+ }
+ }
+
+ /**
+ * Deletes the selected image on IE instead of navigating to previous page.
+ */
+ function deleteControlItemOnBackSpace() {
+ editor.on('keydown', function(e) {
+ var rng;
+
+ if (!isDefaultPrevented(e) && e.keyCode == BACKSPACE) {
+ rng = editor.getDoc().selection.createRange();
+ if (rng && rng.item) {
+ e.preventDefault();
+ editor.undoManager.beforeChange();
+ dom.remove(rng.item(0));
+ editor.undoManager.add();
+ }
+ }
+ });
+ }
+
+ /**
+ * IE10 doesn't properly render block elements with the right height until you add contents to them.
+ * This fixes that by adding a padding-right to all empty text block elements.
+ * See: https://connect.microsoft.com/IE/feedback/details/743881
+ */
+ function renderEmptyBlocksFix() {
+ var emptyBlocksCSS;
+
+ // IE10+
+ if (getDocumentMode() >= 10) {
+ emptyBlocksCSS = '';
+ each('p div h1 h2 h3 h4 h5 h6'.split(' '), function(name, i) {
+ emptyBlocksCSS += (i > 0 ? ',' : '') + name + ':empty';
+ });
+
+ editor.contentStyles.push(emptyBlocksCSS + '{padding-right: 1px !important}');
+ }
+ }
+
+ /**
+ * Old IE versions can't retain contents within noscript elements so this logic will store the contents
+ * as a attribute and the insert that value as it's raw text when the DOM is serialized.
+ */
+ function keepNoScriptContents() {
+ if (getDocumentMode() < 9) {
+ parser.addNodeFilter('noscript', function(nodes) {
+ var i = nodes.length, node, textNode;
+
+ while (i--) {
+ node = nodes[i];
+ textNode = node.firstChild;
+
+ if (textNode) {
+ node.attr('data-mce-innertext', textNode.value);
+ }
+ }
+ });
+
+ serializer.addNodeFilter('noscript', function(nodes) {
+ var i = nodes.length, node, textNode, value;
+
+ while (i--) {
+ node = nodes[i];
+ textNode = nodes[i].firstChild;
+
+ if (textNode) {
+ textNode.value = Entities.decode(textNode.value);
+ } else {
+ // Old IE can't retain noscript value so an attribute is used to store it
+ value = node.attributes.map['data-mce-innertext'];
+ if (value) {
+ node.attr('data-mce-innertext', null);
+ textNode = new Node('#text', 3);
+ textNode.value = value;
+ textNode.raw = true;
+ node.append(textNode);
+ }
+ }
+ }
+ });
+ }
+ }
+
+ /**
+ * IE has an issue where you can't select/move the caret by clicking outside the body if the document is in standards mode.
+ */
+ function fixCaretSelectionOfDocumentElementOnIe() {
+ var doc = dom.doc, body = doc.body, started, startRng, htmlElm;
+
+ // Return range from point or null if it failed
+ function rngFromPoint(x, y) {
+ var rng = body.createTextRange();
+
+ try {
+ rng.moveToPoint(x, y);
+ } catch (ex) {
+ // IE sometimes throws and exception, so lets just ignore it
+ rng = null;
+ }
+
+ return rng;
+ }
+
+ // Fires while the selection is changing
+ function selectionChange(e) {
+ var pointRng;
+
+ // Check if the button is down or not
+ if (e.button) {
+ // Create range from mouse position
+ pointRng = rngFromPoint(e.x, e.y);
+
+ if (pointRng) {
+ // Check if pointRange is before/after selection then change the endPoint
+ if (pointRng.compareEndPoints('StartToStart', startRng) > 0) {
+ pointRng.setEndPoint('StartToStart', startRng);
+ } else {
+ pointRng.setEndPoint('EndToEnd', startRng);
+ }
+
+ pointRng.select();
+ }
+ } else {
+ endSelection();
+ }
+ }
+
+ // Removes listeners
+ function endSelection() {
+ var rng = doc.selection.createRange();
+
+ // If the range is collapsed then use the last start range
+ if (startRng && !rng.item && rng.compareEndPoints('StartToEnd', rng) === 0) {
+ startRng.select();
+ }
+
+ dom.unbind(doc, 'mouseup', endSelection);
+ dom.unbind(doc, 'mousemove', selectionChange);
+ startRng = started = 0;
+ }
+
+ // Make HTML element unselectable since we are going to handle selection by hand
+ doc.documentElement.unselectable = true;
+
+ // Detect when user selects outside BODY
+ dom.bind(doc, 'mousedown contextmenu', function(e) {
+ if (e.target.nodeName === 'HTML') {
+ if (started) {
+ endSelection();
+ }
+
+ // Detect vertical scrollbar, since IE will fire a mousedown on the scrollbar and have target set as HTML
+ htmlElm = doc.documentElement;
+ if (htmlElm.scrollHeight > htmlElm.clientHeight) {
+ return;
+ }
+
+ started = 1;
+ // Setup start position
+ startRng = rngFromPoint(e.x, e.y);
+ if (startRng) {
+ // Listen for selection change events
+ dom.bind(doc, 'mouseup', endSelection);
+ dom.bind(doc, 'mousemove', selectionChange);
+
+ dom.getRoot().focus();
+ startRng.select();
+ }
+ }
+ });
+ }
+
+ /**
+ * Fixes selection issues where the caret can be placed between two inline elements like
a|
b
+ * this fix will lean the caret right into the closest inline element.
+ */
+ function normalizeSelection() {
+ // Normalize selection for example
a|a becomes
a|a except for Ctrl+A since it selects everything
+ editor.on('keyup focusin mouseup', function(e) {
+ if (e.keyCode != 65 || !VK.metaKeyPressed(e)) {
+ selection.normalize();
+ }
+ }, true);
+ }
+
+ /**
+ * Forces Gecko to render a broken image icon if it fails to load an image.
+ */
+ function showBrokenImageIcon() {
+ editor.contentStyles.push(
+ 'img:-moz-broken {' +
+ '-moz-force-broken-image-icon:1;' +
+ 'min-width:24px;' +
+ 'min-height:24px' +
+ '}'
+ );
+ }
+
+ /**
+ * iOS has a bug where it's impossible to type if the document has a touchstart event
+ * bound and the user touches the document while having the on screen keyboard visible.
+ *
+ * The touch event moves the focus to the parent document while having the caret inside the iframe
+ * this fix moves the focus back into the iframe document.
+ */
+ function restoreFocusOnKeyDown() {
+ if (!editor.inline) {
+ editor.on('keydown', function() {
+ if (document.activeElement == document.body) {
+ editor.getWin().focus();
+ }
+ });
+ }
+ }
+
+ /**
+ * IE 11 has an annoying issue where you can't move focus into the editor
+ * by clicking on the white area HTML element. We used to be able to to fix this with
+ * the fixCaretSelectionOfDocumentElementOnIe fix. But since M$ removed the selection
+ * object it's not possible anymore. So we need to hack in a ungly CSS to force the
+ * body to be at least 150px. If the user clicks the HTML element out side this 150px region
+ * we simply move the focus into the first paragraph. Not ideal since you loose the
+ * positioning of the caret but goot enough for most cases.
+ */
+ function bodyHeight() {
+ if (!editor.inline) {
+ editor.contentStyles.push('body {min-height: 150px}');
+ editor.on('click', function(e) {
+ var rng;
+
+ if (e.target.nodeName == 'HTML') {
+ // Edge seems to only need focus if we set the range
+ // the caret will become invisible and moved out of the iframe!!
+ if (Env.ie > 11) {
+ editor.getBody().focus();
+ return;
+ }
+
+ // Need to store away non collapsed ranges since the focus call will mess that up see #7382
+ rng = editor.selection.getRng();
+ editor.getBody().focus();
+ editor.selection.setRng(rng);
+ editor.selection.normalize();
+ editor.nodeChanged();
+ }
+ });
+ }
+ }
+
+ /**
+ * Firefox on Mac OS will move the browser back to the previous page if you press CMD+Left arrow.
+ * You might then loose all your work so we need to block that behavior and replace it with our own.
+ */
+ function blockCmdArrowNavigation() {
+ if (Env.mac) {
+ editor.on('keydown', function(e) {
+ if (VK.metaKeyPressed(e) && !e.shiftKey && (e.keyCode == 37 || e.keyCode == 39)) {
+ e.preventDefault();
+ editor.selection.getSel().modify('move', e.keyCode == 37 ? 'backward' : 'forward', 'lineboundary');
+ }
+ });
+ }
+ }
+
+ /**
+ * Disables the autolinking in IE 9+ this is then re-enabled by the autolink plugin.
+ */
+ function disableAutoUrlDetect() {
+ setEditorCommandState("AutoUrlDetect", false);
+ }
+
+ /**
+ * iOS 7.1 introduced two new bugs:
+ * 1) It's possible to open links within a contentEditable area by clicking on them.
+ * 2) If you hold down the finger it will display the link/image touch callout menu.
+ */
+ function tapLinksAndImages() {
+ editor.on('click', function(e) {
+ var elm = e.target;
+
+ do {
+ if (elm.tagName === 'A') {
+ e.preventDefault();
+ return;
+ }
+ } while ((elm = elm.parentNode));
+ });
+
+ editor.contentStyles.push('.mce-content-body {-webkit-touch-callout: none}');
+ }
+
+ /**
+ * iOS Safari and possible other browsers have a bug where it won't fire
+ * a click event when a contentEditable is focused. This function fakes click events
+ * by using touchstart/touchend and measuring the time and distance travelled.
+ */
+ /*
+ function touchClickEvent() {
+ editor.on('touchstart', function(e) {
+ var elm, time, startTouch, changedTouches;
+
+ elm = e.target;
+ time = new Date().getTime();
+ changedTouches = e.changedTouches;
+
+ if (!changedTouches || changedTouches.length > 1) {
+ return;
+ }
+
+ startTouch = changedTouches[0];
+
+ editor.once('touchend', function(e) {
+ var endTouch = e.changedTouches[0], args;
+
+ if (new Date().getTime() - time > 500) {
+ return;
+ }
+
+ if (Math.abs(startTouch.clientX - endTouch.clientX) > 5) {
+ return;
+ }
+
+ if (Math.abs(startTouch.clientY - endTouch.clientY) > 5) {
+ return;
+ }
+
+ args = {
+ target: elm
+ };
+
+ each('pageX pageY clientX clientY screenX screenY'.split(' '), function(key) {
+ args[key] = endTouch[key];
+ });
+
+ args = editor.fire('click', args);
+
+ if (!args.isDefaultPrevented()) {
+ // iOS WebKit can't place the caret properly once
+ // you bind touch events so we need to do this manually
+ // TODO: Expand to the closest word? Touble tap still works.
+ editor.selection.placeCaretAt(endTouch.clientX, endTouch.clientY);
+ editor.nodeChanged();
+ }
+ });
+ });
+ }
+ */
+
+ /**
+ * WebKit has a bug where it will allow forms to be submitted if they are inside a contentEditable element.
+ * For example this:
+ */
+ function blockFormSubmitInsideEditor() {
+ editor.on('init', function() {
+ editor.dom.bind(editor.getBody(), 'submit', function(e) {
+ e.preventDefault();
+ });
+ });
+ }
+
+ /**
+ * Sometimes WebKit/Blink generates BR elements with the Apple-interchange-newline class.
+ *
+ * Scenario:
+ * 1) Create a table 2x2.
+ * 2) Select and copy cells A2-B2.
+ * 3) Paste and it will add BR element to table cell.
+ */
+ function removeAppleInterchangeBrs() {
+ parser.addNodeFilter('br', function(nodes) {
+ var i = nodes.length;
+
+ while (i--) {
+ if (nodes[i].attr('class') == 'Apple-interchange-newline') {
+ nodes[i].remove();
+ }
+ }
+ });
+ }
+
+ /**
+ * IE cannot set custom contentType's on drag events, and also does not properly drag/drop between
+ * editors. This uses a special data:text/mce-internal URL to pass data when drag/drop between editors.
+ */
+ function ieInternalDragAndDrop() {
+ editor.on('dragstart', function(e) {
+ setMceInternalContent(e);
+ });
+
+ editor.on('drop', function(e) {
+ if (!isDefaultPrevented(e)) {
+ var internalContent = getMceInternalContent(e);
+
+ if (internalContent && internalContent.id != editor.id) {
+ e.preventDefault();
+
+ var rng = RangeUtils.getCaretRangeFromPoint(e.x, e.y, editor.getDoc());
+ selection.setRng(rng);
+ insertClipboardContents(internalContent.html);
+ }
+ }
+ });
+ }
+
+ function refreshContentEditable() {
+ var body, parent;
+
+ // Check if the editor was hidden and the re-initialize contentEditable mode by removing and adding the body again
+ if (isHidden()) {
+ body = editor.getBody();
+ parent = body.parentNode;
+
+ parent.removeChild(body);
+ parent.appendChild(body);
+
+ body.focus();
+ }
+ }
+
+ function isHidden() {
+ var sel;
+
+ if (!isGecko) {
+ return 0;
+ }
+
+ // Weird, wheres that cursor selection?
+ sel = editor.selection.getSel();
+ return (!sel || !sel.rangeCount || sel.rangeCount === 0);
+ }
+
+ /**
+ * Properly empties the editor if all contents is selected and deleted this to
+ * prevent empty paragraphs from being produced at beginning/end of contents.
+ */
+ function emptyEditorOnDeleteEverything() {
+ function isEverythingSelected(editor) {
+ var caretWalker = new CaretWalker(editor.getBody());
+ var rng = editor.selection.getRng();
+ var startCaretPos = CaretPosition.fromRangeStart(rng);
+ var endCaretPos = CaretPosition.fromRangeEnd(rng);
+
+ return !editor.selection.isCollapsed() && !caretWalker.prev(startCaretPos) && !caretWalker.next(endCaretPos);
+ }
+
+ // Type over case delete and insert this won't cover typeover with a IME but at least it covers the common case
+ editor.on('keypress', function (e) {
+ if (!isDefaultPrevented(e) && !selection.isCollapsed() && e.charCode > 31 && !VK.metaKeyPressed(e)) {
+ if (isEverythingSelected(editor)) {
+ e.preventDefault();
+ editor.setContent(String.fromCharCode(e.charCode));
+ editor.selection.select(editor.getBody(), true);
+ editor.selection.collapse(false);
+ editor.nodeChanged();
+ }
+ }
+ });
+
+ editor.on('keydown', function (e) {
+ var keyCode = e.keyCode;
+
+ if (!isDefaultPrevented(e) && (keyCode == DELETE || keyCode == BACKSPACE)) {
+ if (isEverythingSelected(editor)) {
+ e.preventDefault();
+ editor.setContent('');
+ editor.nodeChanged();
+ }
+ }
+ });
+ }
+
+ // All browsers
+ removeBlockQuoteOnBackSpace();
+ emptyEditorWhenDeleting();
+
+ // Windows phone will return a range like [body, 0] on mousedown so
+ // it will always normalize to the wrong location
+ if (!Env.windowsPhone) {
+ normalizeSelection();
+ }
+
+ // WebKit
+ if (isWebKit) {
+ emptyEditorOnDeleteEverything();
+ cleanupStylesWhenDeleting();
+ inputMethodFocus();
+ selectControlElements();
+ setDefaultBlockType();
+ blockFormSubmitInsideEditor();
+ disableBackspaceIntoATable();
+ removeAppleInterchangeBrs();
+
+ //touchClickEvent();
+
+ // iOS
+ if (Env.iOS) {
+ restoreFocusOnKeyDown();
+ bodyHeight();
+ tapLinksAndImages();
+ } else {
+ selectAll();
+ }
+ }
+
+ // IE
+ if (isIE && Env.ie < 11) {
+ removeHrOnBackspace();
+ ensureBodyHasRoleApplication();
+ addNewLinesBeforeBrInPre();
+ removePreSerializedStylesWhenSelectingControls();
+ deleteControlItemOnBackSpace();
+ renderEmptyBlocksFix();
+ keepNoScriptContents();
+ fixCaretSelectionOfDocumentElementOnIe();
+ }
+
+ if (Env.ie >= 11) {
+ bodyHeight();
+ disableBackspaceIntoATable();
+ }
+
+ if (Env.ie) {
+ selectAll();
+ disableAutoUrlDetect();
+ ieInternalDragAndDrop();
+ }
+
+ // Gecko
+ if (isGecko) {
+ emptyEditorOnDeleteEverything();
+ removeHrOnBackspace();
+ focusBody();
+ removeStylesWhenDeletingAcrossBlockElements();
+ setGeckoEditingOptions();
+ addBrAfterLastLinks();
+ showBrokenImageIcon();
+ blockCmdArrowNavigation();
+ disableBackspaceIntoATable();
+ }
+
+ return {
+ refreshContentEditable: refreshContentEditable,
+ isHidden: isHidden
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/EditorObservable.js
+
+/**
+ * EditorObservable.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This mixin contains the event logic for the tinymce.Editor class.
+ *
+ * @mixin tinymce.EditorObservable
+ * @extends tinymce.util.Observable
+ */
+define("tinymce/EditorObservable", [
+ "tinymce/util/Observable",
+ "tinymce/dom/DOMUtils",
+ "tinymce/util/Tools"
+], function(Observable, DOMUtils, Tools) {
+ var DOM = DOMUtils.DOM, customEventRootDelegates;
+
+ /**
+ * Returns the event target so for the specified event. Some events fire
+ * only on document, some fire on documentElement etc. This also handles the
+ * custom event root setting where it returns that element instead of the body.
+ *
+ * @private
+ * @param {tinymce.Editor} editor Editor instance to get event target from.
+ * @param {String} eventName Name of the event for example "click".
+ * @return {Element/Document} HTML Element or document target to bind on.
+ */
+ function getEventTarget(editor, eventName) {
+ if (eventName == 'selectionchange') {
+ return editor.getDoc();
+ }
+
+ // Need to bind mousedown/mouseup etc to document not body in iframe mode
+ // Since the user might click on the HTML element not the BODY
+ if (!editor.inline && /^mouse|touch|click|contextmenu|drop|dragover|dragend/.test(eventName)) {
+ return editor.getDoc().documentElement;
+ }
+
+ // Bind to event root instead of body if it's defined
+ if (editor.settings.event_root) {
+ if (!editor.eventRoot) {
+ editor.eventRoot = DOM.select(editor.settings.event_root)[0];
+ }
+
+ return editor.eventRoot;
+ }
+
+ return editor.getBody();
+ }
+
+ /**
+ * Binds a event delegate for the specified name this delegate will fire
+ * the event to the editor dispatcher.
+ *
+ * @private
+ * @param {tinymce.Editor} editor Editor instance to get event target from.
+ * @param {String} eventName Name of the event for example "click".
+ */
+ function bindEventDelegate(editor, eventName) {
+ var eventRootElm = getEventTarget(editor, eventName), delegate;
+
+ function isListening(editor) {
+ return !editor.hidden && !editor.readonly;
+ }
+
+ if (!editor.delegates) {
+ editor.delegates = {};
+ }
+
+ if (editor.delegates[eventName]) {
+ return;
+ }
+
+ if (editor.settings.event_root) {
+ if (!customEventRootDelegates) {
+ customEventRootDelegates = {};
+ editor.editorManager.on('removeEditor', function() {
+ var name;
+
+ if (!editor.editorManager.activeEditor) {
+ if (customEventRootDelegates) {
+ for (name in customEventRootDelegates) {
+ editor.dom.unbind(getEventTarget(editor, name));
+ }
+
+ customEventRootDelegates = null;
+ }
+ }
+ });
+ }
+
+ if (customEventRootDelegates[eventName]) {
+ return;
+ }
+
+ delegate = function(e) {
+ var target = e.target, editors = editor.editorManager.editors, i = editors.length;
+
+ while (i--) {
+ var body = editors[i].getBody();
+
+ if (body === target || DOM.isChildOf(target, body)) {
+ if (isListening(editors[i])) {
+ editors[i].fire(eventName, e);
+ }
+ }
+ }
+ };
+
+ customEventRootDelegates[eventName] = delegate;
+ DOM.bind(eventRootElm, eventName, delegate);
+ } else {
+ delegate = function(e) {
+ if (isListening(editor)) {
+ editor.fire(eventName, e);
+ }
+ };
+
+ DOM.bind(eventRootElm, eventName, delegate);
+ editor.delegates[eventName] = delegate;
+ }
+ }
+
+ var EditorObservable = {
+ /**
+ * Bind any pending event delegates. This gets executed after the target body/document is created.
+ *
+ * @private
+ */
+ bindPendingEventDelegates: function() {
+ var self = this;
+
+ Tools.each(self._pendingNativeEvents, function(name) {
+ bindEventDelegate(self, name);
+ });
+ },
+
+ /**
+ * Toggles a native event on/off this is called by the EventDispatcher when
+ * the first native event handler is added and when the last native event handler is removed.
+ *
+ * @private
+ */
+ toggleNativeEvent: function(name, state) {
+ var self = this;
+
+ // Never bind focus/blur since the FocusManager fakes those
+ if (name == "focus" || name == "blur") {
+ return;
+ }
+
+ if (state) {
+ if (self.initialized) {
+ bindEventDelegate(self, name);
+ } else {
+ if (!self._pendingNativeEvents) {
+ self._pendingNativeEvents = [name];
+ } else {
+ self._pendingNativeEvents.push(name);
+ }
+ }
+ } else if (self.initialized) {
+ self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
+ delete self.delegates[name];
+ }
+ },
+
+ /**
+ * Unbinds all native event handlers that means delegates, custom events bound using the Events API etc.
+ *
+ * @private
+ */
+ unbindAllNativeEvents: function() {
+ var self = this, name;
+
+ if (self.delegates) {
+ for (name in self.delegates) {
+ self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
+ }
+
+ delete self.delegates;
+ }
+
+ if (!self.inline) {
+ self.getBody().onload = null;
+ self.dom.unbind(self.getWin());
+ self.dom.unbind(self.getDoc());
+ }
+
+ self.dom.unbind(self.getBody());
+ self.dom.unbind(self.getContainer());
+ }
+ };
+
+ EditorObservable = Tools.extend({}, Observable, EditorObservable);
+
+ return EditorObservable;
+});
+
+// Included from: js/tinymce/classes/Mode.js
+
+/**
+ * Mode.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Mode switcher logic.
+ *
+ * @private
+ * @class tinymce.Mode
+ */
+define("tinymce/Mode", [], function() {
+ function setEditorCommandState(editor, cmd, state) {
+ try {
+ editor.getDoc().execCommand(cmd, false, state);
+ } catch (ex) {
+ // Ignore
+ }
+ }
+
+ function clickBlocker(editor) {
+ var target, handler;
+
+ target = editor.getBody();
+
+ handler = function(e) {
+ if (editor.dom.getParents(e.target, 'a').length > 0) {
+ e.preventDefault();
+ }
+ };
+
+ editor.dom.bind(target, 'click', handler);
+
+ return {
+ unbind: function() {
+ editor.dom.unbind(target, 'click', handler);
+ }
+ };
+ }
+
+ function toggleReadOnly(editor, state) {
+ if (editor._clickBlocker) {
+ editor._clickBlocker.unbind();
+ editor._clickBlocker = null;
+ }
+
+ if (state) {
+ editor._clickBlocker = clickBlocker(editor);
+ editor.selection.controlSelection.hideResizeRect();
+ editor.readonly = true;
+ editor.getBody().contentEditable = false;
+ } else {
+ editor.readonly = false;
+ editor.getBody().contentEditable = true;
+ setEditorCommandState(editor, "StyleWithCSS", false);
+ setEditorCommandState(editor, "enableInlineTableEditing", false);
+ setEditorCommandState(editor, "enableObjectResizing", false);
+ editor.focus();
+ editor.nodeChanged();
+ }
+ }
+
+ function setMode(editor, mode) {
+ var currentMode = editor.readonly ? 'readonly' : 'design';
+
+ if (mode == currentMode) {
+ return;
+ }
+
+ if (editor.initialized) {
+ toggleReadOnly(editor, mode == 'readonly');
+ } else {
+ editor.on('init', function() {
+ toggleReadOnly(editor, mode == 'readonly');
+ });
+ }
+
+ // Event is NOT preventable
+ editor.fire('SwitchMode', {mode: mode});
+ }
+
+ return {
+ setMode: setMode
+ };
+});
+
+// Included from: js/tinymce/classes/Shortcuts.js
+
+/**
+ * Shortcuts.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Contains all logic for handling of keyboard shortcuts.
+ *
+ * @class tinymce.Shortcuts
+ * @example
+ * editor.shortcuts.add('ctrl+a', function() {});
+ * editor.shortcuts.add('meta+a', function() {}); // "meta" maps to Command on Mac and Ctrl on PC
+ * editor.shortcuts.add('ctrl+alt+a', function() {});
+ * editor.shortcuts.add('access+a', function() {}); // "access" maps to ctrl+alt on Mac and shift+alt on PC
+ */
+define("tinymce/Shortcuts", [
+ "tinymce/util/Tools",
+ "tinymce/Env"
+], function(Tools, Env) {
+ var each = Tools.each, explode = Tools.explode;
+
+ var keyCodeLookup = {
+ "f9": 120,
+ "f10": 121,
+ "f11": 122
+ };
+
+ var modifierNames = Tools.makeMap('alt,ctrl,shift,meta,access');
+
+ return function(editor) {
+ var self = this, shortcuts = {}, pendingPatterns = [];
+
+ function parseShortcut(pattern) {
+ var id, key, shortcut = {};
+
+ // Parse modifiers and keys ctrl+alt+b for example
+ each(explode(pattern, '+'), function(value) {
+ if (value in modifierNames) {
+ shortcut[value] = true;
+ } else {
+ // Allow numeric keycodes like ctrl+219 for ctrl+[
+ if (/^[0-9]{2,}$/.test(value)) {
+ shortcut.keyCode = parseInt(value, 10);
+ } else {
+ shortcut.charCode = value.charCodeAt(0);
+ shortcut.keyCode = keyCodeLookup[value] || value.toUpperCase().charCodeAt(0);
+ }
+ }
+ });
+
+ // Generate unique id for modifier combination and set default state for unused modifiers
+ id = [shortcut.keyCode];
+ for (key in modifierNames) {
+ if (shortcut[key]) {
+ id.push(key);
+ } else {
+ shortcut[key] = false;
+ }
+ }
+ shortcut.id = id.join(',');
+
+ // Handle special access modifier differently depending on Mac/Win
+ if (shortcut.access) {
+ shortcut.alt = true;
+
+ if (Env.mac) {
+ shortcut.ctrl = true;
+ } else {
+ shortcut.shift = true;
+ }
+ }
+
+ // Handle special meta modifier differently depending on Mac/Win
+ if (shortcut.meta) {
+ if (Env.mac) {
+ shortcut.meta = true;
+ } else {
+ shortcut.ctrl = true;
+ shortcut.meta = false;
+ }
+ }
+
+ return shortcut;
+ }
+
+ function createShortcut(pattern, desc, cmdFunc, scope) {
+ var shortcuts;
+
+ shortcuts = Tools.map(explode(pattern, '>'), parseShortcut);
+ shortcuts[shortcuts.length - 1] = Tools.extend(shortcuts[shortcuts.length - 1], {
+ func: cmdFunc,
+ scope: scope || editor
+ });
+
+ return Tools.extend(shortcuts[0], {
+ desc: editor.translate(desc),
+ subpatterns: shortcuts.slice(1)
+ });
+ }
+
+ function hasModifier(e) {
+ return e.altKey || e.ctrlKey || e.metaKey;
+ }
+
+ function isFunctionKey(e) {
+ return e.keyCode >= 112 && e.keyCode <= 123;
+ }
+
+ function matchShortcut(e, shortcut) {
+ if (!shortcut) {
+ return false;
+ }
+
+ if (shortcut.ctrl != e.ctrlKey || shortcut.meta != e.metaKey) {
+ return false;
+ }
+
+ if (shortcut.alt != e.altKey || shortcut.shift != e.shiftKey) {
+ return false;
+ }
+
+ if (e.keyCode == shortcut.keyCode || (e.charCode && e.charCode == shortcut.charCode)) {
+ e.preventDefault();
+ return true;
+ }
+
+ return false;
+ }
+
+ function executeShortcutAction(shortcut) {
+ return shortcut.func ? shortcut.func.call(shortcut.scope) : null;
+ }
+
+ editor.on('keyup keypress keydown', function(e) {
+ if ((hasModifier(e) || isFunctionKey(e)) && !e.isDefaultPrevented()) {
+ each(shortcuts, function(shortcut) {
+ if (matchShortcut(e, shortcut)) {
+ pendingPatterns = shortcut.subpatterns.slice(0);
+
+ if (e.type == "keydown") {
+ executeShortcutAction(shortcut);
+ }
+
+ return true;
+ }
+ });
+
+ if (matchShortcut(e, pendingPatterns[0])) {
+ if (pendingPatterns.length === 1) {
+ if (e.type == "keydown") {
+ executeShortcutAction(pendingPatterns[0]);
+ }
+ }
+
+ pendingPatterns.shift();
+ }
+ }
+ });
+
+ /**
+ * Adds a keyboard shortcut for some command or function.
+ *
+ * @method addShortcut
+ * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
+ * @param {String} desc Text description for the command.
+ * @param {String/Function} cmdFunc Command name string or function to execute when the key is pressed.
+ * @param {Object} scope Optional scope to execute the function in.
+ * @return {Boolean} true/false state if the shortcut was added or not.
+ */
+ self.add = function(pattern, desc, cmdFunc, scope) {
+ var cmd;
+
+ cmd = cmdFunc;
+
+ if (typeof cmdFunc === 'string') {
+ cmdFunc = function() {
+ editor.execCommand(cmd, false, null);
+ };
+ } else if (Tools.isArray(cmd)) {
+ cmdFunc = function() {
+ editor.execCommand(cmd[0], cmd[1], cmd[2]);
+ };
+ }
+
+ each(explode(Tools.trim(pattern.toLowerCase())), function(pattern) {
+ var shortcut = createShortcut(pattern, desc, cmdFunc, scope);
+ shortcuts[shortcut.id] = shortcut;
+ });
+
+ return true;
+ };
+
+ /**
+ * Remove a keyboard shortcut by pattern.
+ *
+ * @method remove
+ * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
+ * @return {Boolean} true/false state if the shortcut was removed or not.
+ */
+ self.remove = function(pattern) {
+ var shortcut = createShortcut(pattern);
+
+ if (shortcuts[shortcut.id]) {
+ delete shortcuts[shortcut.id];
+ return true;
+ }
+
+ return false;
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/file/Uploader.js
+
+/**
+ * Uploader.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Upload blobs or blob infos to the specified URL or handler.
+ *
+ * @private
+ * @class tinymce.file.Uploader
+ * @example
+ * var uploader = new Uploader({
+ * url: '/upload.php',
+ * basePath: '/base/path',
+ * credentials: true,
+ * handler: function(data, success, failure) {
+ * ...
+ * }
+ * });
+ *
+ * uploader.upload(blobInfos).then(function(result) {
+ * ...
+ * });
+ */
+define("tinymce/file/Uploader", [
+ "tinymce/util/Promise",
+ "tinymce/util/Tools",
+ "tinymce/util/Fun"
+], function(Promise, Tools, Fun) {
+ return function(uploadStatus, settings) {
+ var pendingPromises = {};
+
+ function fileName(blobInfo) {
+ var ext, extensions;
+
+ extensions = {
+ 'image/jpeg': 'jpg',
+ 'image/jpg': 'jpg',
+ 'image/gif': 'gif',
+ 'image/png': 'png'
+ };
+
+ ext = extensions[blobInfo.blob().type.toLowerCase()] || 'dat';
+
+ return blobInfo.id() + '.' + ext;
+ }
+
+ function pathJoin(path1, path2) {
+ if (path1) {
+ return path1.replace(/\/$/, '') + '/' + path2.replace(/^\//, '');
+ }
+
+ return path2;
+ }
+
+ function blobInfoToData(blobInfo) {
+ return {
+ id: blobInfo.id,
+ blob: blobInfo.blob,
+ base64: blobInfo.base64,
+ filename: Fun.constant(fileName(blobInfo))
+ };
+ }
+
+ function defaultHandler(blobInfo, success, failure, progress) {
+ var xhr, formData;
+
+ xhr = new XMLHttpRequest();
+ xhr.open('POST', settings.url);
+ xhr.withCredentials = settings.credentials;
+
+ xhr.upload.onprogress = function(e) {
+ progress(e.loaded / e.total * 100);
+ };
+
+ xhr.onerror = function() {
+ failure("Image upload failed due to a XHR Transport error. Code: " + xhr.status);
+ };
+
+ xhr.onload = function() {
+ var json;
+
+ if (xhr.status != 200) {
+ failure("HTTP Error: " + xhr.status);
+ return;
+ }
+
+ json = JSON.parse(xhr.responseText);
+
+ if (!json || typeof json.location != "string") {
+ failure("Invalid JSON: " + xhr.responseText);
+ return;
+ }
+
+ success(pathJoin(settings.basePath, json.location));
+ };
+
+ formData = new FormData();
+ formData.append('file', blobInfo.blob(), fileName(blobInfo));
+
+ xhr.send(formData);
+ }
+
+ function noUpload() {
+ return new Promise(function(resolve) {
+ resolve([]);
+ });
+ }
+
+ function handlerSuccess(blobInfo, url) {
+ return {
+ url: url,
+ blobInfo: blobInfo,
+ status: true
+ };
+ }
+
+ function handlerFailure(blobInfo, error) {
+ return {
+ url: '',
+ blobInfo: blobInfo,
+ status: false,
+ error: error
+ };
+ }
+
+ function resolvePending(blobUri, result) {
+ Tools.each(pendingPromises[blobUri], function(resolve) {
+ resolve(result);
+ });
+
+ delete pendingPromises[blobUri];
+ }
+
+ function uploadBlobInfo(blobInfo, handler, openNotification) {
+ uploadStatus.markPending(blobInfo.blobUri());
+
+ return new Promise(function(resolve) {
+ var notification, progress;
+
+ var noop = function() {
+ };
+
+ try {
+ var closeNotification = function() {
+ if (notification) {
+ notification.close();
+ progress = noop; // Once it's closed it's closed
+ }
+ };
+
+ var success = function(url) {
+ closeNotification();
+ uploadStatus.markUploaded(blobInfo.blobUri(), url);
+ resolvePending(blobInfo.blobUri(), handlerSuccess(blobInfo, url));
+ resolve(handlerSuccess(blobInfo, url));
+ };
+
+ var failure = function() {
+ closeNotification();
+ uploadStatus.removeFailed(blobInfo.blobUri());
+ resolvePending(blobInfo.blobUri(), handlerFailure(blobInfo, failure));
+ resolve(handlerFailure(blobInfo, failure));
+ };
+
+ progress = function(percent) {
+ if (percent < 0 || percent > 100) {
+ return;
+ }
+
+ if (!notification) {
+ notification = openNotification();
+ }
+
+ notification.progressBar.value(percent);
+ };
+
+ handler(blobInfoToData(blobInfo), success, failure, progress);
+ } catch (ex) {
+ resolve(handlerFailure(blobInfo, ex.message));
+ }
+ });
+ }
+
+ function isDefaultHandler(handler) {
+ return handler === defaultHandler;
+ }
+
+ function pendingUploadBlobInfo(blobInfo) {
+ var blobUri = blobInfo.blobUri();
+
+ return new Promise(function(resolve) {
+ pendingPromises[blobUri] = pendingPromises[blobUri] || [];
+ pendingPromises[blobUri].push(resolve);
+ });
+ }
+
+ function uploadBlobs(blobInfos, openNotification) {
+ blobInfos = Tools.grep(blobInfos, function(blobInfo) {
+ return !uploadStatus.isUploaded(blobInfo.blobUri());
+ });
+
+ return Promise.all(Tools.map(blobInfos, function(blobInfo) {
+ return uploadStatus.isPending(blobInfo.blobUri()) ?
+ pendingUploadBlobInfo(blobInfo) : uploadBlobInfo(blobInfo, settings.handler, openNotification);
+ }));
+ }
+
+ function upload(blobInfos, openNotification) {
+ return (!settings.url && isDefaultHandler(settings.handler)) ? noUpload() : uploadBlobs(blobInfos, openNotification);
+ }
+
+ settings = Tools.extend({
+ credentials: false,
+ // We are adding a notify argument to this (at the moment, until it doesn't work)
+ handler: defaultHandler
+ }, settings);
+
+ return {
+ upload: upload
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/file/Conversions.js
+
+/**
+ * Conversions.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Converts blob/uris back and forth.
+ *
+ * @private
+ * @class tinymce.file.Conversions
+ */
+define("tinymce/file/Conversions", [
+ "tinymce/util/Promise"
+], function(Promise) {
+ function blobUriToBlob(url) {
+ return new Promise(function(resolve) {
+ var xhr = new XMLHttpRequest();
+
+ xhr.open('GET', url, true);
+ xhr.responseType = 'blob';
+
+ xhr.onload = function() {
+ if (this.status == 200) {
+ resolve(this.response);
+ }
+ };
+
+ xhr.send();
+ });
+ }
+
+ function parseDataUri(uri) {
+ var type, matches;
+
+ uri = decodeURIComponent(uri).split(',');
+
+ matches = /data:([^;]+)/.exec(uri[0]);
+ if (matches) {
+ type = matches[1];
+ }
+
+ return {
+ type: type,
+ data: uri[1]
+ };
+ }
+
+ function dataUriToBlob(uri) {
+ return new Promise(function(resolve) {
+ var str, arr, i;
+
+ uri = parseDataUri(uri);
+
+ // Might throw error if data isn't proper base64
+ try {
+ str = atob(uri.data);
+ } catch (e) {
+ resolve(new Blob([]));
+ return;
+ }
+
+ arr = new Uint8Array(str.length);
+
+ for (i = 0; i < arr.length; i++) {
+ arr[i] = str.charCodeAt(i);
+ }
+
+ resolve(new Blob([arr], {type: uri.type}));
+ });
+ }
+
+ function uriToBlob(url) {
+ if (url.indexOf('blob:') === 0) {
+ return blobUriToBlob(url);
+ }
+
+ if (url.indexOf('data:') === 0) {
+ return dataUriToBlob(url);
+ }
+
+ return null;
+ }
+
+ function blobToDataUri(blob) {
+ return new Promise(function(resolve) {
+ var reader = new FileReader();
+
+ reader.onloadend = function() {
+ resolve(reader.result);
+ };
+
+ reader.readAsDataURL(blob);
+ });
+ }
+
+ return {
+ uriToBlob: uriToBlob,
+ blobToDataUri: blobToDataUri,
+ parseDataUri: parseDataUri
+ };
+});
+
+// Included from: js/tinymce/classes/file/ImageScanner.js
+
+/**
+ * ImageScanner.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Finds images with data uris or blob uris. If data uris are found it will convert them into blob uris.
+ *
+ * @private
+ * @class tinymce.file.ImageScanner
+ */
+define("tinymce/file/ImageScanner", [
+ "tinymce/util/Promise",
+ "tinymce/util/Arr",
+ "tinymce/util/Fun",
+ "tinymce/file/Conversions",
+ "tinymce/Env"
+], function(Promise, Arr, Fun, Conversions, Env) {
+ var count = 0;
+
+ return function(uploadStatus, blobCache) {
+ var cachedPromises = {};
+
+ function findAll(elm, predicate) {
+ var images, promises;
+
+ function imageToBlobInfo(img, resolve) {
+ var base64, blobInfo;
+
+ if (img.src.indexOf('blob:') === 0) {
+ blobInfo = blobCache.getByUri(img.src);
+
+ if (blobInfo) {
+ resolve({
+ image: img,
+ blobInfo: blobInfo
+ });
+ }
+
+ return;
+ }
+
+ base64 = Conversions.parseDataUri(img.src).data;
+ blobInfo = blobCache.findFirst(function(cachedBlobInfo) {
+ return cachedBlobInfo.base64() === base64;
+ });
+
+ if (blobInfo) {
+ resolve({
+ image: img,
+ blobInfo: blobInfo
+ });
+ } else {
+ Conversions.uriToBlob(img.src).then(function(blob) {
+ var blobInfoId = 'blobid' + (count++),
+ blobInfo = blobCache.create(blobInfoId, blob, base64);
+
+ blobCache.add(blobInfo);
+
+ resolve({
+ image: img,
+ blobInfo: blobInfo
+ });
+ });
+ }
+ }
+
+ if (!predicate) {
+ predicate = Fun.constant(true);
+ }
+
+ images = Arr.filter(elm.getElementsByTagName('img'), function(img) {
+ var src = img.src;
+
+ if (!Env.fileApi) {
+ return false;
+ }
+
+ if (img.hasAttribute('data-mce-bogus')) {
+ return false;
+ }
+
+ if (img.hasAttribute('data-mce-placeholder')) {
+ return false;
+ }
+
+ if (!src || src == Env.transparentSrc) {
+ return false;
+ }
+
+ if (src.indexOf('blob:') === 0) {
+ return !uploadStatus.isUploaded(src);
+ }
+
+ if (src.indexOf('data:') === 0) {
+ return predicate(img);
+ }
+
+ return false;
+ });
+
+ promises = Arr.map(images, function(img) {
+ var newPromise;
+
+ if (cachedPromises[img.src]) {
+ // Since the cached promise will return the cached image
+ // We need to wrap it and resolve with the actual image
+ return new Promise(function(resolve) {
+ cachedPromises[img.src].then(function(imageInfo) {
+ resolve({
+ image: img,
+ blobInfo: imageInfo.blobInfo
+ });
+ });
+ });
+ }
+
+ newPromise = new Promise(function(resolve) {
+ imageToBlobInfo(img, resolve);
+ }).then(function(result) {
+ delete cachedPromises[result.image.src];
+ return result;
+ })['catch'](function(error) {
+ delete cachedPromises[img.src];
+ return error;
+ });
+
+ cachedPromises[img.src] = newPromise;
+
+ return newPromise;
+ });
+
+ return Promise.all(promises);
+ }
+
+ return {
+ findAll: findAll
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/file/BlobCache.js
+
+/**
+ * BlobCache.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Hold blob info objects where a blob has extra internal information.
+ *
+ * @private
+ * @class tinymce.file.BlobCache
+ */
+define("tinymce/file/BlobCache", [
+ "tinymce/util/Arr",
+ "tinymce/util/Fun"
+], function(Arr, Fun) {
+ return function() {
+ var cache = [], constant = Fun.constant;
+
+ function create(id, blob, base64) {
+ return {
+ id: constant(id),
+ blob: constant(blob),
+ base64: constant(base64),
+ blobUri: constant(URL.createObjectURL(blob))
+ };
+ }
+
+ function add(blobInfo) {
+ if (!get(blobInfo.id())) {
+ cache.push(blobInfo);
+ }
+ }
+
+ function get(id) {
+ return findFirst(function(cachedBlobInfo) {
+ return cachedBlobInfo.id() === id;
+ });
+ }
+
+ function findFirst(predicate) {
+ return Arr.filter(cache, predicate)[0];
+ }
+
+ function getByUri(blobUri) {
+ return findFirst(function(blobInfo) {
+ return blobInfo.blobUri() == blobUri;
+ });
+ }
+
+ function removeByUri(blobUri) {
+ cache = Arr.filter(cache, function(blobInfo) {
+ if (blobInfo.blobUri() === blobUri) {
+ URL.revokeObjectURL(blobInfo.blobUri());
+ return false;
+ }
+
+ return true;
+ });
+ }
+
+ function destroy() {
+ Arr.each(cache, function(cachedBlobInfo) {
+ URL.revokeObjectURL(cachedBlobInfo.blobUri());
+ });
+
+ cache = [];
+ }
+
+ return {
+ create: create,
+ add: add,
+ get: get,
+ getByUri: getByUri,
+ findFirst: findFirst,
+ removeByUri: removeByUri,
+ destroy: destroy
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/file/UploadStatus.js
+
+/**
+ * UploadStatus.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2016 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Holds the current status of a blob uri, if it's pending or uploaded and what the result urls was.
+ *
+ * @private
+ * @class tinymce.file.UploadStatus
+ */
+define("tinymce/file/UploadStatus", [
+], function() {
+ return function() {
+ var PENDING = 1, UPLOADED = 2;
+ var blobUriStatuses = {};
+
+ function createStatus(status, resultUri) {
+ return {
+ status: status,
+ resultUri: resultUri
+ };
+ }
+
+ function hasBlobUri(blobUri) {
+ return blobUri in blobUriStatuses;
+ }
+
+ function getResultUri(blobUri) {
+ var result = blobUriStatuses[blobUri];
+
+ return result ? result.resultUri : null;
+ }
+
+ function isPending(blobUri) {
+ return hasBlobUri(blobUri) ? blobUriStatuses[blobUri].status === PENDING : false;
+ }
+
+ function isUploaded(blobUri) {
+ return hasBlobUri(blobUri) ? blobUriStatuses[blobUri].status === UPLOADED : false;
+ }
+
+ function markPending(blobUri) {
+ blobUriStatuses[blobUri] = createStatus(PENDING, null);
+ }
+
+ function markUploaded(blobUri, resultUri) {
+ blobUriStatuses[blobUri] = createStatus(UPLOADED, resultUri);
+ }
+
+ function removeFailed(blobUri) {
+ delete blobUriStatuses[blobUri];
+ }
+
+ function destroy() {
+ blobUriStatuses = {};
+ }
+
+ return {
+ hasBlobUri: hasBlobUri,
+ getResultUri: getResultUri,
+ isPending: isPending,
+ isUploaded: isUploaded,
+ markPending: markPending,
+ markUploaded: markUploaded,
+ removeFailed: removeFailed,
+ destroy: destroy
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/EditorUpload.js
+
+/**
+ * EditorUpload.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Handles image uploads, updates undo stack and patches over various internal functions.
+ *
+ * @private
+ * @class tinymce.EditorUpload
+ */
+define("tinymce/EditorUpload", [
+ "tinymce/util/Arr",
+ "tinymce/file/Uploader",
+ "tinymce/file/ImageScanner",
+ "tinymce/file/BlobCache",
+ "tinymce/file/UploadStatus"
+], function(Arr, Uploader, ImageScanner, BlobCache, UploadStatus) {
+ return function(editor) {
+ var blobCache = new BlobCache(), uploader, imageScanner, settings = editor.settings;
+ var uploadStatus = new UploadStatus();
+
+ function aliveGuard(callback) {
+ return function(result) {
+ if (editor.selection) {
+ return callback(result);
+ }
+
+ return [];
+ };
+ }
+
+ // Replaces strings without regexps to avoid FF regexp to big issue
+ function replaceString(content, search, replace) {
+ var index = 0;
+
+ do {
+ index = content.indexOf(search, index);
+
+ if (index !== -1) {
+ content = content.substring(0, index) + replace + content.substr(index + search.length);
+ index += replace.length - search.length + 1;
+ }
+ } while (index !== -1);
+
+ return content;
+ }
+
+ function replaceImageUrl(content, targetUrl, replacementUrl) {
+ content = replaceString(content, 'src="' + targetUrl + '"', 'src="' + replacementUrl + '"');
+ content = replaceString(content, 'data-mce-src="' + targetUrl + '"', 'data-mce-src="' + replacementUrl + '"');
+
+ return content;
+ }
+
+ function replaceUrlInUndoStack(targetUrl, replacementUrl) {
+ Arr.each(editor.undoManager.data, function(level) {
+ level.content = replaceImageUrl(level.content, targetUrl, replacementUrl);
+ });
+ }
+
+ function openNotification() {
+ return editor.notificationManager.open({
+ text: editor.translate('Image uploading...'),
+ type: 'info',
+ timeout: -1,
+ progressBar: true
+ });
+ }
+
+ function replaceImageUri(image, resultUri) {
+ blobCache.removeByUri(image.src);
+ replaceUrlInUndoStack(image.src, resultUri);
+
+ editor.$(image).attr({
+ src: resultUri,
+ 'data-mce-src': editor.convertURL(resultUri, 'src')
+ });
+ }
+
+ function uploadImages(callback) {
+ if (!uploader) {
+ uploader = new Uploader(uploadStatus, {
+ url: settings.images_upload_url,
+ basePath: settings.images_upload_base_path,
+ credentials: settings.images_upload_credentials,
+ handler: settings.images_upload_handler
+ });
+ }
+
+ return scanForImages().then(aliveGuard(function(imageInfos) {
+ var blobInfos;
+
+ blobInfos = Arr.map(imageInfos, function(imageInfo) {
+ return imageInfo.blobInfo;
+ });
+
+ return uploader.upload(blobInfos, openNotification).then(aliveGuard(function(result) {
+ result = Arr.map(result, function(uploadInfo, index) {
+ var image = imageInfos[index].image;
+
+ if (uploadInfo.status && editor.settings.images_replace_blob_uris !== false) {
+ replaceImageUri(image, uploadInfo.url);
+ }
+
+ return {
+ element: image,
+ status: uploadInfo.status
+ };
+ });
+
+ if (callback) {
+ callback(result);
+ }
+
+ return result;
+ }));
+ }));
+ }
+
+ function uploadImagesAuto(callback) {
+ if (settings.automatic_uploads !== false) {
+ return uploadImages(callback);
+ }
+ }
+
+ function isValidDataUriImage(imgElm) {
+ return settings.images_dataimg_filter ? settings.images_dataimg_filter(imgElm) : true;
+ }
+
+ function scanForImages() {
+ if (!imageScanner) {
+ imageScanner = new ImageScanner(uploadStatus, blobCache);
+ }
+
+ return imageScanner.findAll(editor.getBody(), isValidDataUriImage).then(aliveGuard(function(result) {
+ Arr.each(result, function(resultItem) {
+ replaceUrlInUndoStack(resultItem.image.src, resultItem.blobInfo.blobUri());
+ resultItem.image.src = resultItem.blobInfo.blobUri();
+ resultItem.image.removeAttribute('data-mce-src');
+ });
+
+ return result;
+ }));
+ }
+
+ function destroy() {
+ blobCache.destroy();
+ uploadStatus.destroy();
+ imageScanner = uploader = null;
+ }
+
+ function replaceBlobUris(content) {
+ return content.replace(/src="(blob:[^"]+)"/g, function(match, blobUri) {
+ var resultUri = uploadStatus.getResultUri(blobUri);
+
+ if (resultUri) {
+ return 'src="' + resultUri + '"';
+ }
+
+ var blobInfo = blobCache.getByUri(blobUri);
+
+ if (!blobInfo) {
+ blobInfo = Arr.reduce(editor.editorManager.editors, function(result, editor) {
+ return result || editor.editorUpload.blobCache.getByUri(blobUri);
+ }, null);
+ }
+
+ if (blobInfo) {
+ return 'src="data:' + blobInfo.blob().type + ';base64,' + blobInfo.base64() + '"';
+ }
+
+ return match;
+ });
+ }
+
+ editor.on('setContent', function() {
+ if (editor.settings.automatic_uploads !== false) {
+ uploadImagesAuto();
+ } else {
+ scanForImages();
+ }
+ });
+
+ editor.on('RawSaveContent', function(e) {
+ e.content = replaceBlobUris(e.content);
+ });
+
+ editor.on('getContent', function(e) {
+ if (e.source_view || e.format == 'raw') {
+ return;
+ }
+
+ e.content = replaceBlobUris(e.content);
+ });
+
+ editor.on('PostRender', function() {
+ editor.parser.addNodeFilter('img', function(images) {
+ Arr.each(images, function(img) {
+ var src = img.attr('src');
+
+ if (blobCache.getByUri(src)) {
+ return;
+ }
+
+ var resultUri = uploadStatus.getResultUri(src);
+ if (resultUri) {
+ img.attr('src', resultUri);
+ }
+ });
+ });
+ });
+
+ return {
+ blobCache: blobCache,
+ uploadImages: uploadImages,
+ uploadImagesAuto: uploadImagesAuto,
+ scanForImages: scanForImages,
+ destroy: destroy
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/caret/FakeCaret.js
+
+/**
+ * FakeCaret.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module contains logic for rendering a fake visual caret.
+ *
+ * @private
+ * @class tinymce.caret.FakeCaret
+ */
+define("tinymce/caret/FakeCaret", [
+ "tinymce/caret/CaretContainer",
+ "tinymce/caret/CaretPosition",
+ "tinymce/dom/NodeType",
+ "tinymce/dom/RangeUtils",
+ "tinymce/dom/DomQuery",
+ "tinymce/geom/ClientRect",
+ "tinymce/util/Delay"
+], function(CaretContainer, CaretPosition, NodeType, RangeUtils, $, ClientRect, Delay) {
+ var isContentEditableFalse = NodeType.isContentEditableFalse;
+
+ return function(rootNode, isBlock) {
+ var cursorInterval, $lastVisualCaret, caretContainerNode;
+
+ function getAbsoluteClientRect(node, before) {
+ var clientRect = ClientRect.collapse(node.getBoundingClientRect(), before),
+ docElm, scrollX, scrollY, margin, rootRect;
+
+ if (rootNode.tagName == 'BODY') {
+ docElm = rootNode.ownerDocument.documentElement;
+ scrollX = rootNode.scrollLeft || docElm.scrollLeft;
+ scrollY = rootNode.scrollTop || docElm.scrollTop;
+ } else {
+ rootRect = rootNode.getBoundingClientRect();
+ scrollX = rootNode.scrollLeft - rootRect.left;
+ scrollY = rootNode.scrollTop - rootRect.top;
+ }
+
+ clientRect.left += scrollX;
+ clientRect.right += scrollX;
+ clientRect.top += scrollY;
+ clientRect.bottom += scrollY;
+ clientRect.width = 1;
+
+ margin = node.offsetWidth - node.clientWidth;
+
+ if (margin > 0) {
+ if (before) {
+ margin *= -1;
+ }
+
+ clientRect.left += margin;
+ clientRect.right += margin;
+ }
+
+ return clientRect;
+ }
+
+ function trimInlineCaretContainers() {
+ var contentEditableFalseNodes, node, sibling, i, data;
+
+ contentEditableFalseNodes = $('*[contentEditable=false]', rootNode);
+ for (i = 0; i < contentEditableFalseNodes.length; i++) {
+ node = contentEditableFalseNodes[i];
+
+ sibling = node.previousSibling;
+ if (CaretContainer.endsWithCaretContainer(sibling)) {
+ data = sibling.data;
+
+ if (data.length == 1) {
+ sibling.parentNode.removeChild(sibling);
+ } else {
+ sibling.deleteData(data.length - 1, 1);
+ }
+ }
+
+ sibling = node.nextSibling;
+ if (CaretContainer.startsWithCaretContainer(sibling)) {
+ data = sibling.data;
+
+ if (data.length == 1) {
+ sibling.parentNode.removeChild(sibling);
+ } else {
+ sibling.deleteData(0, 1);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ function show(before, node) {
+ var clientRect, rng, container;
+
+ hide();
+
+ if (isBlock(node)) {
+ caretContainerNode = CaretContainer.insertBlock('p', node, before);
+ clientRect = getAbsoluteClientRect(node, before);
+ $(caretContainerNode).css('top', clientRect.top);
+
+ $lastVisualCaret = $('
').css(clientRect).appendTo(rootNode);
+
+ if (before) {
+ $lastVisualCaret.addClass('mce-visual-caret-before');
+ }
+
+ startBlink();
+
+ rng = node.ownerDocument.createRange();
+ container = caretContainerNode.firstChild;
+ rng.setStart(container, 0);
+ rng.setEnd(container, 1);
+ } else {
+ caretContainerNode = CaretContainer.insertInline(node, before);
+ rng = node.ownerDocument.createRange();
+
+ if (isContentEditableFalse(caretContainerNode.nextSibling)) {
+ rng.setStart(caretContainerNode, 0);
+ rng.setEnd(caretContainerNode, 0);
+ } else {
+ rng.setStart(caretContainerNode, 1);
+ rng.setEnd(caretContainerNode, 1);
+ }
+
+ return rng;
+ }
+
+ return rng;
+ }
+
+ function hide() {
+ trimInlineCaretContainers();
+
+ if (caretContainerNode) {
+ CaretContainer.remove(caretContainerNode);
+ caretContainerNode = null;
+ }
+
+ if ($lastVisualCaret) {
+ $lastVisualCaret.remove();
+ $lastVisualCaret = null;
+ }
+
+ clearInterval(cursorInterval);
+ }
+
+ function startBlink() {
+ cursorInterval = Delay.setInterval(function() {
+ $('div.mce-visual-caret', rootNode).toggleClass('mce-visual-caret-hidden');
+ }, 500);
+ }
+
+ function destroy() {
+ Delay.clearInterval(cursorInterval);
+ }
+
+ function getCss() {
+ return (
+ '.mce-visual-caret {' +
+ 'position: absolute;' +
+ 'background-color: black;' +
+ 'background-color: currentcolor;' +
+ '}' +
+ '.mce-visual-caret-hidden {' +
+ 'display: none;' +
+ '}' +
+ '*[data-mce-caret] {' +
+ 'position: absolute;' +
+ 'left: -1000px;' +
+ 'right: auto;' +
+ 'top: 0;' +
+ 'margin: 0;' +
+ 'padding: 0;' +
+ '}'
+ );
+ }
+
+ return {
+ show: show,
+ hide: hide,
+ getCss: getCss,
+ destroy: destroy
+ };
+ };
+});
+
+// Included from: js/tinymce/classes/dom/Dimensions.js
+
+/**
+ * Dimensions.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module measures nodes and returns client rects. The client rects has an
+ * extra node property.
+ *
+ * @private
+ * @class tinymce.dom.Dimensions
+ */
+define("tinymce/dom/Dimensions", [
+ "tinymce/util/Arr",
+ "tinymce/dom/NodeType",
+ "tinymce/geom/ClientRect"
+], function(Arr, NodeType, ClientRect) {
+
+ function getClientRects(node) {
+ function toArrayWithNode(clientRects) {
+ return Arr.map(clientRects, function(clientRect) {
+ clientRect = ClientRect.clone(clientRect);
+ clientRect.node = node;
+
+ return clientRect;
+ });
+ }
+
+ if (Arr.isArray(node)) {
+ return Arr.reduce(node, function(result, node) {
+ return result.concat(getClientRects(node));
+ }, []);
+ }
+
+ if (NodeType.isElement(node)) {
+ return toArrayWithNode(node.getClientRects());
+ }
+
+ if (NodeType.isText(node)) {
+ var rng = node.ownerDocument.createRange();
+
+ rng.setStart(node, 0);
+ rng.setEnd(node, node.data.length);
+
+ return toArrayWithNode(rng.getClientRects());
+ }
+ }
+
+ return {
+ /**
+ * Returns the client rects for a specific node.
+ *
+ * @method getClientRects
+ * @param {Array/DOMNode} node Node or array of nodes to get client rects on.
+ * @param {Array} Array of client rects with a extra node property.
+ */
+ getClientRects: getClientRects
+ };
+});
+
+// Included from: js/tinymce/classes/caret/LineWalker.js
+
+/**
+ * LineWalker.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module lets you walk the document line by line
+ * returing nodes and client rects for each line.
+ *
+ * @private
+ * @class tinymce.caret.LineWalker
+ */
+define("tinymce/caret/LineWalker", [
+ "tinymce/util/Fun",
+ "tinymce/util/Arr",
+ "tinymce/dom/Dimensions",
+ "tinymce/caret/CaretCandidate",
+ "tinymce/caret/CaretUtils",
+ "tinymce/caret/CaretWalker",
+ "tinymce/caret/CaretPosition",
+ "tinymce/geom/ClientRect"
+], function(Fun, Arr, Dimensions, CaretCandidate, CaretUtils, CaretWalker, CaretPosition, ClientRect) {
+ var curry = Fun.curry;
+
+ function findUntil(direction, rootNode, predicateFn, node) {
+ while ((node = CaretUtils.findNode(node, direction, CaretCandidate.isEditableCaretCandidate, rootNode))) {
+ if (predicateFn(node)) {
+ return;
+ }
+ }
+ }
+
+ function walkUntil(direction, isAboveFn, isBeflowFn, rootNode, predicateFn, caretPosition) {
+ var line = 0, node, result = [], targetClientRect;
+
+ function add(node) {
+ var i, clientRect, clientRects;
+
+ clientRects = Dimensions.getClientRects(node);
+ if (direction == -1) {
+ clientRects = clientRects.reverse();
+ }
+
+ for (i = 0; i < clientRects.length; i++) {
+ clientRect = clientRects[i];
+ if (isBeflowFn(clientRect, targetClientRect)) {
+ continue;
+ }
+
+ if (result.length > 0 && isAboveFn(clientRect, Arr.last(result))) {
+ line++;
+ }
+
+ clientRect.line = line;
+
+ if (predicateFn(clientRect)) {
+ return true;
+ }
+
+ result.push(clientRect);
+ }
+ }
+
+ targetClientRect = Arr.last(caretPosition.getClientRects());
+ if (!targetClientRect) {
+ return result;
+ }
+
+ node = caretPosition.getNode();
+ add(node);
+ findUntil(direction, rootNode, add, node);
+
+ return result;
+ }
+
+ function aboveLineNumber(lineNumber, clientRect) {
+ return clientRect.line > lineNumber;
+ }
+
+ function isLine(lineNumber, clientRect) {
+ return clientRect.line === lineNumber;
+ }
+
+ var upUntil = curry(walkUntil, -1, ClientRect.isAbove, ClientRect.isBelow);
+ var downUntil = curry(walkUntil, 1, ClientRect.isBelow, ClientRect.isAbove);
+
+ function positionsUntil(direction, rootNode, predicateFn, node) {
+ var caretWalker = new CaretWalker(rootNode), walkFn, isBelowFn, isAboveFn,
+ caretPosition, result = [], line = 0, clientRect, targetClientRect;
+
+ function getClientRect(caretPosition) {
+ if (direction == 1) {
+ return Arr.last(caretPosition.getClientRects());
+ }
+
+ return Arr.last(caretPosition.getClientRects());
+ }
+
+ if (direction == 1) {
+ walkFn = caretWalker.next;
+ isBelowFn = ClientRect.isBelow;
+ isAboveFn = ClientRect.isAbove;
+ caretPosition = CaretPosition.after(node);
+ } else {
+ walkFn = caretWalker.prev;
+ isBelowFn = ClientRect.isAbove;
+ isAboveFn = ClientRect.isBelow;
+ caretPosition = CaretPosition.before(node);
+ }
+
+ targetClientRect = getClientRect(caretPosition);
+
+ do {
+ if (!caretPosition.isVisible()) {
+ continue;
+ }
+
+ clientRect = getClientRect(caretPosition);
+
+ if (isAboveFn(clientRect, targetClientRect)) {
+ continue;
+ }
+
+ if (result.length > 0 && isBelowFn(clientRect, Arr.last(result))) {
+ line++;
+ }
+
+ clientRect = ClientRect.clone(clientRect);
+ clientRect.position = caretPosition;
+ clientRect.line = line;
+
+ if (predicateFn(clientRect)) {
+ return result;
+ }
+
+ result.push(clientRect);
+ } while ((caretPosition = walkFn(caretPosition)));
+
+ return result;
+ }
+
+ return {
+ upUntil: upUntil,
+ downUntil: downUntil,
+
+ /**
+ * Find client rects with line and caret position until the predicate returns true.
+ *
+ * @method positionsUntil
+ * @param {Number} direction Direction forward/backward 1/-1.
+ * @param {DOMNode} rootNode Root node to walk within.
+ * @param {function} predicateFn Gets the client rect as it's input.
+ * @param {DOMNode} node Node to start walking from.
+ * @return {Array} Array of client rects with line and position properties.
+ */
+ positionsUntil: positionsUntil,
+
+ isAboveLine: curry(aboveLineNumber),
+ isLine: curry(isLine)
+ };
+});
+
+// Included from: js/tinymce/classes/caret/LineUtils.js
+
+/**
+ * LineUtils.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Utility functions for working with lines.
+ *
+ * @private
+ * @class tinymce.caret.LineUtils
+ */
+define("tinymce/caret/LineUtils", [
+ "tinymce/util/Fun",
+ "tinymce/util/Arr",
+ "tinymce/dom/NodeType",
+ "tinymce/dom/Dimensions",
+ "tinymce/geom/ClientRect",
+ "tinymce/caret/CaretUtils",
+ "tinymce/caret/CaretCandidate"
+], function(Fun, Arr, NodeType, Dimensions, ClientRect, CaretUtils, CaretCandidate) {
+ var isContentEditableFalse = NodeType.isContentEditableFalse,
+ findNode = CaretUtils.findNode,
+ curry = Fun.curry;
+
+ function distanceToRectLeft(clientRect, clientX) {
+ return Math.abs(clientRect.left - clientX);
+ }
+
+ function distanceToRectRight(clientRect, clientX) {
+ return Math.abs(clientRect.right - clientX);
+ }
+
+ function findClosestClientRect(clientRects, clientX) {
+ function isInside(clientX, clientRect) {
+ return clientX >= clientRect.left && clientX <= clientRect.right;
+ }
+
+ return Arr.reduce(clientRects, function(oldClientRect, clientRect) {
+ var oldDistance, newDistance;
+
+ oldDistance = Math.min(distanceToRectLeft(oldClientRect, clientX), distanceToRectRight(oldClientRect, clientX));
+ newDistance = Math.min(distanceToRectLeft(clientRect, clientX), distanceToRectRight(clientRect, clientX));
+
+ if (isInside(clientX, clientRect)) {
+ return clientRect;
+ }
+
+ if (isInside(clientX, oldClientRect)) {
+ return oldClientRect;
+ }
+
+ // cE=false has higher priority
+ if (newDistance == oldDistance && isContentEditableFalse(clientRect.node)) {
+ return clientRect;
+ }
+
+ if (newDistance < oldDistance) {
+ return clientRect;
+ }
+
+ return oldClientRect;
+ });
+ }
+
+ function walkUntil(direction, rootNode, predicateFn, node) {
+ while ((node = findNode(node, direction, CaretCandidate.isEditableCaretCandidate, rootNode))) {
+ if (predicateFn(node)) {
+ return;
+ }
+ }
+ }
+
+ function findLineNodeRects(rootNode, targetNodeRect) {
+ var clientRects = [];
+
+ function collect(checkPosFn, node) {
+ var lineRects;
+
+ lineRects = Arr.filter(Dimensions.getClientRects(node), function(clientRect) {
+ return !checkPosFn(clientRect, targetNodeRect);
+ });
+
+ clientRects = clientRects.concat(lineRects);
+
+ return lineRects.length === 0;
+ }
+
+ clientRects.push(targetNodeRect);
+ walkUntil(-1, rootNode, curry(collect, ClientRect.isAbove), targetNodeRect.node);
+ walkUntil(1, rootNode, curry(collect, ClientRect.isBelow), targetNodeRect.node);
+
+ return clientRects;
+ }
+
+ function getContentEditableFalseChildren(rootNode) {
+ return Arr.filter(Arr.toArray(rootNode.getElementsByTagName('*')), isContentEditableFalse);
+ }
+
+ function caretInfo(clientRect, clientX) {
+ return {
+ node: clientRect.node,
+ before: distanceToRectLeft(clientRect, clientX) < distanceToRectRight(clientRect, clientX)
+ };
+ }
+
+ function closestCaret(rootNode, clientX, clientY) {
+ var contentEditableFalseNodeRects, closestNodeRect;
+
+ contentEditableFalseNodeRects = Dimensions.getClientRects(getContentEditableFalseChildren(rootNode));
+ contentEditableFalseNodeRects = Arr.filter(contentEditableFalseNodeRects, function(clientRect) {
+ return clientY >= clientRect.top && clientY <= clientRect.bottom;
+ });
+
+ closestNodeRect = findClosestClientRect(contentEditableFalseNodeRects, clientX);
+ if (closestNodeRect) {
+ closestNodeRect = findClosestClientRect(findLineNodeRects(rootNode, closestNodeRect), clientX);
+ if (closestNodeRect && isContentEditableFalse(closestNodeRect.node)) {
+ return caretInfo(closestNodeRect, clientX);
+ }
+ }
+
+ return null;
+ }
+
+ return {
+ findClosestClientRect: findClosestClientRect,
+ findLineNodeRects: findLineNodeRects,
+ closestCaret: closestCaret
+ };
+});
+
+// Included from: js/tinymce/classes/dom/MousePosition.js
+
+/**
+ * MousePosition.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2016 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module calculates an absolute coordinate inside the editor body for both local and global mouse events.
+ *
+ * @private
+ * @class tinymce.dom.MousePosition
+ */
+define("tinymce/dom/MousePosition", [
+], function() {
+ var getAbsolutePosition = function (elm) {
+ var doc, docElem, win, clientRect;
+
+ clientRect = elm.getBoundingClientRect();
+ doc = elm.ownerDocument;
+ docElem = doc.documentElement;
+ win = doc.defaultView;
+
+ return {
+ top: clientRect.top + win.pageYOffset - docElem.clientTop,
+ left: clientRect.left + win.pageXOffset - docElem.clientLeft
+ };
+ };
+
+ var getBodyPosition = function (editor) {
+ return editor.inline ? getAbsolutePosition(editor.getBody()) : {left: 0, top: 0};
+ };
+
+ var getScrollPosition = function (editor) {
+ var body = editor.getBody();
+ return editor.inline ? {left: body.scrollLeft, top: body.scrollTop} : {left: 0, top: 0};
+ };
+
+ var getBodyScroll = function (editor) {
+ var body = editor.getBody(), docElm = editor.getDoc().documentElement;
+ var inlineScroll = {left: body.scrollLeft, top: body.scrollTop};
+ var iframeScroll = {left: body.scrollLeft || docElm.scrollLeft, top: body.scrollTop || docElm.scrollTop};
+
+ return editor.inline ? inlineScroll : iframeScroll;
+ };
+
+ var getMousePosition = function (editor, event) {
+ if (event.target.ownerDocument !== editor.getDoc()) {
+ var iframePosition = getAbsolutePosition(editor.getContentAreaContainer());
+ var scrollPosition = getBodyScroll(editor);
+
+ return {
+ left: event.pageX - iframePosition.left + scrollPosition.left,
+ top: event.pageY - iframePosition.top + scrollPosition.top
+ };
+ }
+
+ return {
+ left: event.pageX,
+ top: event.pageY
+ };
+ };
+
+ var calculatePosition = function (bodyPosition, scrollPosition, mousePosition) {
+ return {
+ pageX: (mousePosition.left - bodyPosition.left) + scrollPosition.left,
+ pageY: (mousePosition.top - bodyPosition.top) + scrollPosition.top
+ };
+ };
+
+ var calc = function (editor, event) {
+ return calculatePosition(getBodyPosition(editor), getScrollPosition(editor), getMousePosition(editor, event));
+ };
+
+ return {
+ calc: calc
+ };
+});
+
+// Included from: js/tinymce/classes/DragDropOverrides.js
+
+/**
+ * DragDropOverrides.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module contains logic overriding the drag/drop logic of the editor.
+ *
+ * @private
+ * @class tinymce.DragDropOverrides
+ */
+define("tinymce/DragDropOverrides", [
+ "tinymce/dom/NodeType",
+ "tinymce/util/Arr",
+ "tinymce/util/Fun",
+ "tinymce/util/Delay",
+ "tinymce/dom/DOMUtils",
+ "tinymce/dom/MousePosition"
+], function(
+ NodeType, Arr, Fun, Delay, DOMUtils, MousePosition
+) {
+ var isContentEditableFalse = NodeType.isContentEditableFalse,
+ isContentEditableTrue = NodeType.isContentEditableTrue;
+
+ var isDraggable = function (elm) {
+ return isContentEditableFalse(elm);
+ };
+
+ var isValidDropTarget = function (editor, targetElement, dragElement) {
+ if (targetElement === dragElement || editor.dom.isChildOf(targetElement, dragElement)) {
+ return false;
+ }
+
+ if (isContentEditableFalse(targetElement)) {
+ return false;
+ }
+
+ return true;
+ };
+
+ var cloneElement = function (elm) {
+ var cloneElm = elm.cloneNode(true);
+ cloneElm.removeAttribute('data-mce-selected');
+ return cloneElm;
+ };
+
+ var createGhost = function (editor, elm, width, height) {
+ var clonedElm = elm.cloneNode(true);
+
+ editor.dom.setStyles(clonedElm, {width: width, height: height});
+ editor.dom.setAttrib(clonedElm, 'data-mce-selected', null);
+
+ var ghostElm = editor.dom.create('div', {
+ 'class': 'mce-drag-container',
+ 'data-mce-bogus': 'all',
+ unselectable: 'on',
+ contenteditable: 'false'
+ });
+
+ editor.dom.setStyles(ghostElm, {
+ position: 'absolute',
+ opacity: 0.5,
+ overflow: 'hidden',
+ border: 0,
+ padding: 0,
+ margin: 0,
+ width: width,
+ height: height
+ });
+
+ editor.dom.setStyles(clonedElm, {
+ margin: 0,
+ boxSizing: 'border-box'
+ });
+
+ ghostElm.appendChild(clonedElm);
+
+ return ghostElm;
+ };
+
+ var appendGhostToBody = function (ghostElm, bodyElm) {
+ if (ghostElm.parentNode !== bodyElm) {
+ bodyElm.appendChild(ghostElm);
+ }
+ };
+
+ var moveGhost = function (ghostElm, position, width, height, maxX, maxY) {
+ var overflowX = 0, overflowY = 0;
+
+ ghostElm.style.left = position.pageX + 'px';
+ ghostElm.style.top = position.pageY + 'px';
+
+ if (position.pageX + width > maxX) {
+ overflowX = (position.pageX + width) - maxX;
+ }
+
+ if (position.pageY + height > maxY) {
+ overflowY = (position.pageY + height) - maxY;
+ }
+
+ ghostElm.style.width = (width - overflowX) + 'px';
+ ghostElm.style.height = (height - overflowY) + 'px';
+ };
+
+ var removeElement = function (elm) {
+ if (elm && elm.parentNode) {
+ elm.parentNode.removeChild(elm);
+ }
+ };
+
+ var isLeftMouseButtonPressed = function (e) {
+ return e.button === 0;
+ };
+
+ var hasDraggableElement = function (state) {
+ return state.element;
+ };
+
+ var applyRelPos = function (state, position) {
+ return {
+ pageX: position.pageX - state.relX,
+ pageY: position.pageY + 5
+ };
+ };
+
+ var start = function (state, editor) {
+ return function (e) {
+ if (isLeftMouseButtonPressed(e)) {
+ var ceElm = Arr.find(editor.dom.getParents(e.target), Fun.or(isContentEditableFalse, isContentEditableTrue));
+
+ if (isDraggable(ceElm)) {
+ var elmPos = editor.dom.getPos(ceElm);
+ var bodyElm = editor.getBody();
+ var docElm = editor.getDoc().documentElement;
+
+ state.element = ceElm;
+ state.screenX = e.screenX;
+ state.screenY = e.screenY;
+ state.maxX = (editor.inline ? bodyElm.scrollWidth : docElm.offsetWidth) - 2;
+ state.maxY = (editor.inline ? bodyElm.scrollHeight : docElm.offsetHeight) - 2;
+ state.relX = e.pageX - elmPos.x;
+ state.relY = e.pageY - elmPos.y;
+ state.width = ceElm.offsetWidth;
+ state.height = ceElm.offsetHeight;
+ state.ghost = createGhost(editor, ceElm, state.width, state.height);
+ }
+ }
+ };
+ };
+
+ var move = function (state, editor) {
+ // Reduces laggy drag behavior on Gecko
+ var throttledPlaceCaretAt = Delay.throttle(function (clientX, clientY) {
+ editor._selectionOverrides.hideFakeCaret();
+ editor.selection.placeCaretAt(clientX, clientY);
+ }, 0);
+
+ return function (e) {
+ var movement = Math.max(Math.abs(e.screenX - state.screenX), Math.abs(e.screenY - state.screenY));
+
+ if (hasDraggableElement(state) && !state.dragging && movement > 10) {
+ var args = editor.fire('dragstart', {target: state.element});
+ if (args.isDefaultPrevented()) {
+ return;
+ }
+
+ state.dragging = true;
+ editor.focus();
+ }
+
+ if (state.dragging) {
+ var targetPos = applyRelPos(state, MousePosition.calc(editor, e));
+
+ appendGhostToBody(state.ghost, editor.getBody());
+ moveGhost(state.ghost, targetPos, state.width, state.height, state.maxX, state.maxY);
+
+ throttledPlaceCaretAt(e.clientX, e.clientY);
+ }
+ };
+ };
+
+ var drop = function (state, editor) {
+ return function (e) {
+ if (state.dragging) {
+ if (isValidDropTarget(editor, editor.selection.getNode(), state.element)) {
+ var targetClone = cloneElement(state.element);
+
+ var args = editor.fire('drop', {
+ targetClone: targetClone,
+ clientX: e.clientX,
+ clientY: e.clientY
+ });
+
+ if (!args.isDefaultPrevented()) {
+ targetClone = args.targetClone;
+
+ editor.undoManager.transact(function() {
+ removeElement(state.element);
+ editor.insertContent(editor.dom.getOuterHTML(targetClone));
+ editor._selectionOverrides.hideFakeCaret();
+ });
+ }
+ }
+ }
+
+ removeDragState(state);
+ };
+ };
+
+ var stop = function (state, editor) {
+ return function () {
+ removeDragState(state);
+ if (state.dragging) {
+ editor.fire('dragend');
+ }
+ };
+ };
+
+ var removeDragState = function (state) {
+ state.dragging = false;
+ state.element = null;
+ removeElement(state.ghost);
+ };
+
+ var bindFakeDragEvents = function (editor) {
+ var state = {}, pageDom, dragStartHandler, dragHandler, dropHandler, dragEndHandler, rootDocument;
+
+ pageDom = DOMUtils.DOM;
+ rootDocument = document;
+ dragStartHandler = start(state, editor);
+ dragHandler = move(state, editor);
+ dropHandler = drop(state, editor);
+ dragEndHandler = stop(state, editor);
+
+ editor.on('mousedown', dragStartHandler);
+ editor.on('mousemove', dragHandler);
+ editor.on('mouseup', dropHandler);
+
+ pageDom.bind(rootDocument, 'mousemove', dragHandler);
+ pageDom.bind(rootDocument, 'mouseup', dragEndHandler);
+
+ editor.on('remove', function () {
+ pageDom.unbind(rootDocument, 'mousemove', dragHandler);
+ pageDom.unbind(rootDocument, 'mouseup', dragEndHandler);
+ });
+ };
+
+ var blockIeDrop = function (editor) {
+ editor.on('drop', function(e) {
+ // FF doesn't pass out clientX/clientY for drop since this is for IE we just use null instead
+ var realTarget = typeof e.clientX !== 'undefined' ? editor.getDoc().elementFromPoint(e.clientX, e.clientY) : null;
+
+ if (isContentEditableFalse(realTarget) || isContentEditableFalse(editor.dom.getContentEditableParent(realTarget))) {
+ e.preventDefault();
+ }
+ });
+ };
+
+ var init = function (editor) {
+ bindFakeDragEvents(editor);
+ blockIeDrop(editor);
+ };
+
+ return {
+ init: init
+ };
+});
+
+// Included from: js/tinymce/classes/SelectionOverrides.js
+
+/**
+ * SelectionOverrides.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module contains logic overriding the selection with keyboard/mouse
+ * around contentEditable=false regions.
+ *
+ * @example
+ * // Disable the default cE=false selection
+ * tinymce.activeEditor.on('ShowCaret BeforeObjectSelected', function(e) {
+ * e.preventDefault();
+ * });
+ *
+ * @private
+ * @class tinymce.SelectionOverrides
+ */
+define("tinymce/SelectionOverrides", [
+ "tinymce/Env",
+ "tinymce/caret/CaretWalker",
+ "tinymce/caret/CaretPosition",
+ "tinymce/caret/CaretContainer",
+ "tinymce/caret/CaretUtils",
+ "tinymce/caret/FakeCaret",
+ "tinymce/caret/LineWalker",
+ "tinymce/caret/LineUtils",
+ "tinymce/dom/NodeType",
+ "tinymce/dom/RangeUtils",
+ "tinymce/geom/ClientRect",
+ "tinymce/util/VK",
+ "tinymce/util/Fun",
+ "tinymce/util/Arr",
+ "tinymce/util/Delay",
+ "tinymce/DragDropOverrides",
+ "tinymce/text/Zwsp"
+], function(
+ Env, CaretWalker, CaretPosition, CaretContainer, CaretUtils, FakeCaret, LineWalker,
+ LineUtils, NodeType, RangeUtils, ClientRect, VK, Fun, Arr, Delay, DragDropOverrides, Zwsp
+) {
+ var curry = Fun.curry,
+ isContentEditableTrue = NodeType.isContentEditableTrue,
+ isContentEditableFalse = NodeType.isContentEditableFalse,
+ isElement = NodeType.isElement,
+ isAfterContentEditableFalse = CaretUtils.isAfterContentEditableFalse,
+ isBeforeContentEditableFalse = CaretUtils.isBeforeContentEditableFalse,
+ getSelectedNode = RangeUtils.getSelectedNode;
+
+ function getVisualCaretPosition(walkFn, caretPosition) {
+ while ((caretPosition = walkFn(caretPosition))) {
+ if (caretPosition.isVisible()) {
+ return caretPosition;
+ }
+ }
+
+ return caretPosition;
+ }
+
+ function SelectionOverrides(editor) {
+ var rootNode = editor.getBody(), caretWalker = new CaretWalker(rootNode);
+ var getNextVisualCaretPosition = curry(getVisualCaretPosition, caretWalker.next);
+ var getPrevVisualCaretPosition = curry(getVisualCaretPosition, caretWalker.prev),
+ fakeCaret = new FakeCaret(editor.getBody(), isBlock),
+ realSelectionId = 'sel-' + editor.dom.uniqueId(),
+ selectedContentEditableNode, $ = editor.$;
+
+ function getRealSelectionElement() {
+ var container = editor.dom.get(realSelectionId);
+ return container ? container.getElementsByTagName('*')[0] : container;
+ }
+
+ function isBlock(node) {
+ return editor.dom.isBlock(node);
+ }
+
+ function setRange(range) {
+ //console.log('setRange', range);
+ if (range) {
+ editor.selection.setRng(range);
+ }
+ }
+
+ function getRange() {
+ return editor.selection.getRng();
+ }
+
+ function scrollIntoView(node, alignToTop) {
+ editor.selection.scrollIntoView(node, alignToTop);
+ }
+
+ function showCaret(direction, node, before) {
+ var e;
+
+ e = editor.fire('ShowCaret', {
+ target: node,
+ direction: direction,
+ before: before
+ });
+
+ if (e.isDefaultPrevented()) {
+ return null;
+ }
+
+ scrollIntoView(node, direction === -1);
+
+ return fakeCaret.show(before, node);
+ }
+
+ function selectNode(node) {
+ var e;
+
+ fakeCaret.hide();
+
+ e = editor.fire('BeforeObjectSelected', {target: node});
+ if (e.isDefaultPrevented()) {
+ return null;
+ }
+
+ return getNodeRange(node);
+ }
+
+ function getNodeRange(node) {
+ var rng = node.ownerDocument.createRange();
+
+ rng.selectNode(node);
+
+ return rng;
+ }
+
+ function isMoveInsideSameBlock(fromCaretPosition, toCaretPosition) {
+ var inSameBlock = CaretUtils.isInSameBlock(fromCaretPosition, toCaretPosition);
+
+ // Handle bogus BR
abc|
+ if (!inSameBlock && NodeType.isBr(fromCaretPosition.getNode())) {
+ return true;
+ }
+
+ return inSameBlock;
+ }
+
+ function getNormalizedRangeEndPoint(direction, range) {
+ range = CaretUtils.normalizeRange(direction, rootNode, range);
+
+ if (direction == -1) {
+ return CaretPosition.fromRangeStart(range);
+ }
+
+ return CaretPosition.fromRangeEnd(range);
+ }
+
+ function isRangeInCaretContainerBlock(range) {
+ return CaretContainer.isCaretContainerBlock(range.startContainer);
+ }
+
+ function moveToCeFalseHorizontally(direction, getNextPosFn, isBeforeContentEditableFalseFn, range) {
+ var node, caretPosition, peekCaretPosition, rangeIsInContainerBlock;
+
+ if (!range.collapsed) {
+ node = getSelectedNode(range);
+ if (isContentEditableFalse(node)) {
+ return showCaret(direction, node, direction == -1);
+ }
+ }
+
+ rangeIsInContainerBlock = isRangeInCaretContainerBlock(range);
+ caretPosition = getNormalizedRangeEndPoint(direction, range);
+
+ if (isBeforeContentEditableFalseFn(caretPosition)) {
+ return selectNode(caretPosition.getNode(direction == -1));
+ }
+
+ caretPosition = getNextPosFn(caretPosition);
+ if (!caretPosition) {
+ if (rangeIsInContainerBlock) {
+ return range;
+ }
+
+ return null;
+ }
+
+ if (isBeforeContentEditableFalseFn(caretPosition)) {
+ return showCaret(direction, caretPosition.getNode(direction == -1), direction == 1);
+ }
+
+ // Peek ahead for handling of ab|c
-> abc|
+ peekCaretPosition = getNextPosFn(caretPosition);
+ if (isBeforeContentEditableFalseFn(peekCaretPosition)) {
+ if (isMoveInsideSameBlock(caretPosition, peekCaretPosition)) {
+ return showCaret(direction, peekCaretPosition.getNode(direction == -1), direction == 1);
+ }
+ }
+
+ if (rangeIsInContainerBlock) {
+ return renderRangeCaret(caretPosition.toRange());
+ }
+
+ return null;
+ }
+
+ function moveToCeFalseVertically(direction, walkerFn, range) {
+ var caretPosition, linePositions, nextLinePositions,
+ closestNextLineRect, caretClientRect, clientX,
+ dist1, dist2, contentEditableFalseNode;
+
+ contentEditableFalseNode = getSelectedNode(range);
+ caretPosition = getNormalizedRangeEndPoint(direction, range);
+ linePositions = walkerFn(rootNode, LineWalker.isAboveLine(1), caretPosition);
+ nextLinePositions = Arr.filter(linePositions, LineWalker.isLine(1));
+ caretClientRect = Arr.last(caretPosition.getClientRects());
+
+ if (isBeforeContentEditableFalse(caretPosition)) {
+ contentEditableFalseNode = caretPosition.getNode();
+ }
+
+ if (isAfterContentEditableFalse(caretPosition)) {
+ contentEditableFalseNode = caretPosition.getNode(true);
+ }
+
+ if (!caretClientRect) {
+ return null;
+ }
+
+ clientX = caretClientRect.left;
+
+ closestNextLineRect = LineUtils.findClosestClientRect(nextLinePositions, clientX);
+ if (closestNextLineRect) {
+ if (isContentEditableFalse(closestNextLineRect.node)) {
+ dist1 = Math.abs(clientX - closestNextLineRect.left);
+ dist2 = Math.abs(clientX - closestNextLineRect.right);
+
+ return showCaret(direction, closestNextLineRect.node, dist1 < dist2);
+ }
+ }
+
+ if (contentEditableFalseNode) {
+ var caretPositions = LineWalker.positionsUntil(direction, rootNode, LineWalker.isAboveLine(1), contentEditableFalseNode);
+
+ closestNextLineRect = LineUtils.findClosestClientRect(Arr.filter(caretPositions, LineWalker.isLine(1)), clientX);
+ if (closestNextLineRect) {
+ return renderRangeCaret(closestNextLineRect.position.toRange());
+ }
+
+ closestNextLineRect = Arr.last(Arr.filter(caretPositions, LineWalker.isLine(0)));
+ if (closestNextLineRect) {
+ return renderRangeCaret(closestNextLineRect.position.toRange());
+ }
+ }
+ }
+
+ function exitPreBlock(direction, range) {
+ var pre, caretPos, newBlock;
+
+ function createTextBlock() {
+ var textBlock = editor.dom.create(editor.settings.forced_root_block);
+
+ if (!Env.ie || Env.ie >= 11) {
+ textBlock.innerHTML = '
';
+ }
+
+ return textBlock;
+ }
+
+ if (range.collapsed && editor.settings.forced_root_block) {
+ pre = editor.dom.getParent(range.startContainer, 'PRE');
+ if (!pre) {
+ return;
+ }
+
+ if (direction == 1) {
+ caretPos = getNextVisualCaretPosition(CaretPosition.fromRangeStart(range));
+ } else {
+ caretPos = getPrevVisualCaretPosition(CaretPosition.fromRangeStart(range));
+ }
+
+ if (!caretPos) {
+ newBlock = createTextBlock();
+
+ if (direction == 1) {
+ editor.$(pre).after(newBlock);
+ } else {
+ editor.$(pre).before(newBlock);
+ }
+
+ editor.selection.select(newBlock, true);
+ editor.selection.collapse();
+ }
+ }
+ }
+
+ function moveH(direction, getNextPosFn, isBeforeContentEditableFalseFn, range) {
+ var newRange;
+
+ newRange = moveToCeFalseHorizontally(direction, getNextPosFn, isBeforeContentEditableFalseFn, range);
+ if (newRange) {
+ return newRange;
+ }
+
+ newRange = exitPreBlock(direction, range);
+ if (newRange) {
+ return newRange;
+ }
+
+ return null;
+ }
+
+ function moveV(direction, walkerFn, range) {
+ var newRange;
+
+ newRange = moveToCeFalseVertically(direction, walkerFn, range);
+ if (newRange) {
+ return newRange;
+ }
+
+ newRange = exitPreBlock(direction, range);
+ if (newRange) {
+ return newRange;
+ }
+
+ return null;
+ }
+
+ function getBlockCaretContainer() {
+ return $('*[data-mce-caret]')[0];
+ }
+
+ function showBlockCaretContainer(blockCaretContainer) {
+ blockCaretContainer = $(blockCaretContainer);
+
+ if (blockCaretContainer.attr('data-mce-caret')) {
+ fakeCaret.hide();
+ blockCaretContainer.removeAttr('data-mce-caret');
+ blockCaretContainer.removeAttr('data-mce-bogus');
+ blockCaretContainer.removeAttr('style');
+
+ // Removes control rect on IE
+ setRange(getRange());
+ scrollIntoView(blockCaretContainer[0]);
+ }
+ }
+
+ function renderCaretAtRange(range) {
+ var caretPosition, ceRoot;
+
+ range = CaretUtils.normalizeRange(1, rootNode, range);
+ caretPosition = CaretPosition.fromRangeStart(range);
+
+ if (isContentEditableFalse(caretPosition.getNode())) {
+ return showCaret(1, caretPosition.getNode(), !caretPosition.isAtEnd());
+ }
+
+ if (isContentEditableFalse(caretPosition.getNode(true))) {
+ return showCaret(1, caretPosition.getNode(true), false);
+ }
+
+ // TODO: Should render caret before/after depending on where you click on the page forces after now
+ ceRoot = editor.dom.getParent(caretPosition.getNode(), Fun.or(isContentEditableFalse, isContentEditableTrue));
+ if (isContentEditableFalse(ceRoot)) {
+ return showCaret(1, ceRoot, false);
+ }
+
+ fakeCaret.hide();
+
+ return null;
+ }
+
+ function renderRangeCaret(range) {
+ var caretRange;
+
+ if (!range || !range.collapsed) {
+ return range;
+ }
+
+ caretRange = renderCaretAtRange(range);
+ if (caretRange) {
+ return caretRange;
+ }
+
+ return range;
+ }
+
+ function deleteContentEditableNode(node) {
+ var nextCaretPosition, prevCaretPosition, prevCeFalseElm, nextElement;
+
+ if (!isContentEditableFalse(node)) {
+ return null;
+ }
+
+ if (isContentEditableFalse(node.previousSibling)) {
+ prevCeFalseElm = node.previousSibling;
+ }
+
+ prevCaretPosition = getPrevVisualCaretPosition(CaretPosition.before(node));
+ if (!prevCaretPosition) {
+ nextCaretPosition = getNextVisualCaretPosition(CaretPosition.after(node));
+ }
+
+ if (nextCaretPosition && isElement(nextCaretPosition.getNode())) {
+ nextElement = nextCaretPosition.getNode();
+ }
+
+ CaretContainer.remove(node.previousSibling);
+ CaretContainer.remove(node.nextSibling);
+ editor.dom.remove(node);
+ clearContentEditableSelection();
+
+ if (editor.dom.isEmpty(editor.getBody())) {
+ editor.setContent('');
+ editor.focus();
+ return;
+ }
+
+ if (prevCeFalseElm) {
+ return CaretPosition.after(prevCeFalseElm).toRange();
+ }
+
+ if (nextElement) {
+ return CaretPosition.before(nextElement).toRange();
+ }
+
+ if (prevCaretPosition) {
+ return prevCaretPosition.toRange();
+ }
+
+ if (nextCaretPosition) {
+ return nextCaretPosition.toRange();
+ }
+
+ return null;
+ }
+
+ function isTextBlock(node) {
+ var textBlocks = editor.schema.getTextBlockElements();
+ return node.nodeName in textBlocks;
+ }
+
+ function isEmpty(elm) {
+ return editor.dom.isEmpty(elm);
+ }
+
+ function mergeTextBlocks(direction, fromCaretPosition, toCaretPosition) {
+ var dom = editor.dom, fromBlock, toBlock, node, ceTarget;
+
+ fromBlock = dom.getParent(fromCaretPosition.getNode(), dom.isBlock);
+ toBlock = dom.getParent(toCaretPosition.getNode(), dom.isBlock);
+
+ if (direction === -1) {
+ ceTarget = toCaretPosition.getNode(true);
+ if (isAfterContentEditableFalse(toCaretPosition) && isBlock(ceTarget)) {
+ if (isTextBlock(fromBlock)) {
+ if (isEmpty(fromBlock)) {
+ dom.remove(fromBlock);
+ }
+
+ return CaretPosition.after(ceTarget).toRange();
+ }
+
+ return deleteContentEditableNode(toCaretPosition.getNode(true));
+ }
+ } else {
+ ceTarget = fromCaretPosition.getNode();
+ if (isBeforeContentEditableFalse(fromCaretPosition) && isBlock(ceTarget)) {
+ if (isTextBlock(toBlock)) {
+ if (isEmpty(toBlock)) {
+ dom.remove(toBlock);
+ }
+
+ return CaretPosition.before(ceTarget).toRange();
+ }
+
+ return deleteContentEditableNode(fromCaretPosition.getNode());
+ }
+ }
+
+ // Verify that both blocks are text blocks
+ if (fromBlock === toBlock || !isTextBlock(fromBlock) || !isTextBlock(toBlock)) {
+ return null;
+ }
+
+ while ((node = fromBlock.firstChild)) {
+ toBlock.appendChild(node);
+ }
+
+ editor.dom.remove(fromBlock);
+
+ return toCaretPosition.toRange();
+ }
+
+ function backspaceDelete(direction, beforeFn, afterFn, range) {
+ var node, caretPosition, peekCaretPosition, newCaretPosition;
+
+ if (!range.collapsed) {
+ node = getSelectedNode(range);
+ if (isContentEditableFalse(node)) {
+ return renderRangeCaret(deleteContentEditableNode(node));
+ }
+ }
+
+ caretPosition = getNormalizedRangeEndPoint(direction, range);
+
+ if (afterFn(caretPosition) && CaretContainer.isCaretContainerBlock(range.startContainer)) {
+ newCaretPosition = direction == -1 ? caretWalker.prev(caretPosition) : caretWalker.next(caretPosition);
+ return newCaretPosition ? renderRangeCaret(newCaretPosition.toRange()) : range;
+ }
+
+ if (beforeFn(caretPosition)) {
+ return renderRangeCaret(deleteContentEditableNode(caretPosition.getNode(direction == -1)));
+ }
+
+ peekCaretPosition = direction == -1 ? caretWalker.prev(caretPosition) : caretWalker.next(caretPosition);
+ if (beforeFn(peekCaretPosition)) {
+ if (direction === -1) {
+ return mergeTextBlocks(direction, caretPosition, peekCaretPosition);
+ }
+
+ return mergeTextBlocks(direction, peekCaretPosition, caretPosition);
+ }
+ }
+
+ function registerEvents() {
+ var right = curry(moveH, 1, getNextVisualCaretPosition, isBeforeContentEditableFalse);
+ var left = curry(moveH, -1, getPrevVisualCaretPosition, isAfterContentEditableFalse);
+ var deleteForward = curry(backspaceDelete, 1, isBeforeContentEditableFalse, isAfterContentEditableFalse);
+ var backspace = curry(backspaceDelete, -1, isAfterContentEditableFalse, isBeforeContentEditableFalse);
+ var up = curry(moveV, -1, LineWalker.upUntil);
+ var down = curry(moveV, 1, LineWalker.downUntil);
+
+ function override(evt, moveFn) {
+ var range = moveFn(getRange());
+
+ if (range && !evt.isDefaultPrevented()) {
+ evt.preventDefault();
+ setRange(range);
+ }
+ }
+
+ function getContentEditableRoot(node) {
+ var root = editor.getBody();
+
+ while (node && node != root) {
+ if (isContentEditableTrue(node) || isContentEditableFalse(node)) {
+ return node;
+ }
+
+ node = node.parentNode;
+ }
+
+ return null;
+ }
+
+ function isXYWithinRange(clientX, clientY, range) {
+ if (range.collapsed) {
+ return false;
+ }
+
+ return Arr.reduce(range.getClientRects(), function(state, rect) {
+ return state || ClientRect.containsXY(rect, clientX, clientY);
+ }, false);
+ }
+
+ // Some browsers (Chrome) lets you place the caret after a cE=false
+ // Make sure we render the caret container in this case
+ editor.on('mouseup', function() {
+ var range = getRange();
+
+ if (range.collapsed) {
+ setRange(renderCaretAtRange(range));
+ }
+ });
+
+ editor.on('click', function(e) {
+ var contentEditableRoot;
+
+ // Prevent clicks on links in a cE=false element
+ contentEditableRoot = getContentEditableRoot(e.target);
+ if (contentEditableRoot) {
+ if (isContentEditableFalse(contentEditableRoot)) {
+ e.preventDefault();
+ editor.focus();
+ }
+ }
+ });
+
+ function handleTouchSelect(editor) {
+ var moved = false;
+
+ editor.on('touchstart', function () {
+ moved = false;
+ });
+
+ editor.on('touchmove', function () {
+ moved = true;
+ });
+
+ editor.on('touchend', function (e) {
+ var contentEditableRoot = getContentEditableRoot(e.target);
+
+ if (isContentEditableFalse(contentEditableRoot)) {
+ if (!moved) {
+ e.preventDefault();
+ setContentEditableSelection(selectNode(contentEditableRoot));
+ }
+ } else {
+ clearContentEditableSelection();
+ }
+ });
+ }
+
+ var hasNormalCaretPosition = function (elm) {
+ var caretWalker = new CaretWalker(elm);
+
+ if (!elm.firstChild) {
+ return false;
+ }
+
+ var startPos = CaretPosition.before(elm.firstChild);
+ var newPos = caretWalker.next(startPos);
+
+ return newPos && !isBeforeContentEditableFalse(newPos) && !isAfterContentEditableFalse(newPos);
+ };
+
+ var isInSameBlock = function (node1, node2) {
+ var block1 = editor.dom.getParent(node1, editor.dom.isBlock);
+ var block2 = editor.dom.getParent(node2, editor.dom.isBlock);
+ return block1 === block2;
+ };
+
+ // Checks if the target node is in a block and if that block has a caret position better than the
+ // suggested caretNode this is to prevent the caret from being sucked in towards a cE=false block if
+ // they are adjacent on the vertical axis
+ var hasBetterMouseTarget = function (targetNode, caretNode) {
+ var targetBlock = editor.dom.getParent(targetNode, editor.dom.isBlock);
+ var caretBlock = editor.dom.getParent(caretNode, editor.dom.isBlock);
+
+ return targetBlock && !isInSameBlock(targetBlock, caretBlock) && hasNormalCaretPosition(targetBlock);
+ };
+
+ handleTouchSelect(editor);
+
+ editor.on('mousedown', function(e) {
+ var contentEditableRoot;
+
+ contentEditableRoot = getContentEditableRoot(e.target);
+ if (contentEditableRoot) {
+ if (isContentEditableFalse(contentEditableRoot)) {
+ e.preventDefault();
+ setContentEditableSelection(selectNode(contentEditableRoot));
+ } else {
+ clearContentEditableSelection();
+
+ if (!isXYWithinRange(e.clientX, e.clientY, editor.selection.getRng())) {
+ editor.selection.placeCaretAt(e.clientX, e.clientY);
+ }
+ }
+ } else {
+ clearContentEditableSelection();
+ fakeCaret.hide();
+
+ var caretInfo = LineUtils.closestCaret(rootNode, e.clientX, e.clientY);
+ if (caretInfo) {
+ if (!hasBetterMouseTarget(e.target, caretInfo.node)) {
+ e.preventDefault();
+ editor.getBody().focus();
+ setRange(showCaret(1, caretInfo.node, caretInfo.before));
+ }
+ }
+ }
+ });
+
+ editor.on('keydown', function(e) {
+ if (VK.modifierPressed(e)) {
+ return;
+ }
+
+ switch (e.keyCode) {
+ case VK.RIGHT:
+ override(e, right);
+ break;
+
+ case VK.DOWN:
+ override(e, down);
+ break;
+
+ case VK.LEFT:
+ override(e, left);
+ break;
+
+ case VK.UP:
+ override(e, up);
+ break;
+
+ case VK.DELETE:
+ override(e, deleteForward);
+ break;
+
+ case VK.BACKSPACE:
+ override(e, backspace);
+ break;
+
+ default:
+ if (isContentEditableFalse(editor.selection.getNode())) {
+ e.preventDefault();
+ }
+ break;
+ }
+ });
+
+ function paddEmptyContentEditableArea() {
+ var br, ceRoot = getContentEditableRoot(editor.selection.getNode());
+
+ if (isContentEditableTrue(ceRoot) && isBlock(ceRoot) && editor.dom.isEmpty(ceRoot)) {
+ br = editor.dom.create('br', {"data-mce-bogus": "1"});
+ editor.$(ceRoot).empty().append(br);
+ editor.selection.setRng(CaretPosition.before(br).toRange());
+ }
+ }
+
+ function handleBlockContainer(e) {
+ var blockCaretContainer = getBlockCaretContainer();
+
+ if (!blockCaretContainer) {
+ return;
+ }
+
+ if (e.type == 'compositionstart') {
+ e.preventDefault();
+ e.stopPropagation();
+ showBlockCaretContainer(blockCaretContainer);
+ return;
+ }
+
+ if (blockCaretContainer.innerHTML != ' ') {
+ showBlockCaretContainer(blockCaretContainer);
+ }
+ }
+
+ function handleEmptyBackspaceDelete(e) {
+ var prevent;
+
+ switch (e.keyCode) {
+ case VK.DELETE:
+ prevent = paddEmptyContentEditableArea();
+ break;
+
+ case VK.BACKSPACE:
+ prevent = paddEmptyContentEditableArea();
+ break;
+ }
+
+ if (prevent) {
+ e.preventDefault();
+ }
+ }
+
+ // Must be added to "top" since undoManager needs to be executed after
+ editor.on('keyup compositionstart', function(e) {
+ handleBlockContainer(e);
+ handleEmptyBackspaceDelete(e);
+ }, true);
+
+ editor.on('cut', function() {
+ var node = editor.selection.getNode();
+
+ if (isContentEditableFalse(node)) {
+ Delay.setEditorTimeout(editor, function() {
+ setRange(renderRangeCaret(deleteContentEditableNode(node)));
+ });
+ }
+ });
+
+ editor.on('getSelectionRange', function(e) {
+ var rng = e.range;
+
+ if (selectedContentEditableNode) {
+ if (!selectedContentEditableNode.parentNode) {
+ selectedContentEditableNode = null;
+ return;
+ }
+
+ rng = rng.cloneRange();
+ rng.selectNode(selectedContentEditableNode);
+ e.range = rng;
+ }
+ });
+
+ editor.on('setSelectionRange', function(e) {
+ var rng;
+
+ rng = setContentEditableSelection(e.range);
+ if (rng) {
+ e.range = rng;
+ }
+ });
+
+ editor.on('focus', function() {
+ // Make sure we have a proper fake caret on focus
+ Delay.setEditorTimeout(editor, function() {
+ editor.selection.setRng(renderRangeCaret(editor.selection.getRng()));
+ }, 0);
+ });
+
+ editor.on('copy', function (e) {
+ var clipboardData = e.clipboardData;
+
+ // Make sure we get proper html/text for the fake cE=false selection
+ // Doesn't work at all on Edge since it doesn't have proper clipboardData support
+ if (!e.isDefaultPrevented() && e.clipboardData && !Env.ie) {
+ var realSelectionElement = getRealSelectionElement();
+ if (realSelectionElement) {
+ e.preventDefault();
+ clipboardData.clearData();
+ clipboardData.setData('text/html', realSelectionElement.outerHTML);
+ clipboardData.setData('text/plain', realSelectionElement.outerText);
+ }
+ }
+ });
+
+ DragDropOverrides.init(editor);
+ }
+
+ function addCss() {
+ var styles = editor.contentStyles, rootClass = '.mce-content-body';
+
+ styles.push(fakeCaret.getCss());
+ styles.push(
+ rootClass + ' .mce-offscreen-selection {' +
+ 'position: absolute;' +
+ 'left: -9999999999px;' +
+ '}' +
+ rootClass + ' *[contentEditable=false] {' +
+ 'cursor: default;' +
+ '}' +
+ rootClass + ' *[contentEditable=true] {' +
+ 'cursor: text;' +
+ '}'
+ );
+ }
+
+ function isRangeInCaretContainer(rng) {
+ return CaretContainer.isCaretContainer(rng.startContainer) || CaretContainer.isCaretContainer(rng.endContainer);
+ }
+
+ function setContentEditableSelection(range) {
+ var node, $ = editor.$, dom = editor.dom, $realSelectionContainer, sel,
+ startContainer, startOffset, endOffset, e, caretPosition, targetClone, origTargetClone;
+
+ if (!range) {
+ clearContentEditableSelection();
+ return null;
+ }
+
+ if (range.collapsed) {
+ clearContentEditableSelection();
+
+ if (!isRangeInCaretContainer(range)) {
+ caretPosition = getNormalizedRangeEndPoint(1, range);
+
+ if (isContentEditableFalse(caretPosition.getNode())) {
+ return showCaret(1, caretPosition.getNode(), !caretPosition.isAtEnd());
+ }
+
+ if (isContentEditableFalse(caretPosition.getNode(true))) {
+ return showCaret(1, caretPosition.getNode(true), false);
+ }
+ }
+
+ return null;
+ }
+
+ startContainer = range.startContainer;
+ startOffset = range.startOffset;
+ endOffset = range.endOffset;
+
+ // Normalizes [] to []
+ if (startContainer.nodeType == 3 && startOffset == 0 && isContentEditableFalse(startContainer.parentNode)) {
+ startContainer = startContainer.parentNode;
+ startOffset = dom.nodeIndex(startContainer);
+ startContainer = startContainer.parentNode;
+ }
+
+ if (startContainer.nodeType != 1) {
+ clearContentEditableSelection();
+ return null;
+ }
+
+ if (endOffset == startOffset + 1) {
+ node = startContainer.childNodes[startOffset];
+ }
+
+ if (!isContentEditableFalse(node)) {
+ clearContentEditableSelection();
+ return null;
+ }
+
+ targetClone = origTargetClone = node.cloneNode(true);
+ e = editor.fire('ObjectSelected', {target: node, targetClone: targetClone});
+ if (e.isDefaultPrevented()) {
+ clearContentEditableSelection();
+ return null;
+ }
+
+ targetClone = e.targetClone;
+ $realSelectionContainer = $('#' + realSelectionId);
+ if ($realSelectionContainer.length === 0) {
+ $realSelectionContainer = $(
+ ''
+ ).attr('id', realSelectionId);
+
+ $realSelectionContainer.appendTo(editor.getBody());
+ }
+
+ range = editor.dom.createRng();
+
+ // WHY is IE making things so hard! Copy on x produces: x
+ if (targetClone === origTargetClone && Env.ie) {
+ $realSelectionContainer.empty().append(Zwsp.ZWSP).append(targetClone).append(Zwsp.ZWSP);
+ range.setStart($realSelectionContainer[0].firstChild, 0);
+ range.setEnd($realSelectionContainer[0].lastChild, 1);
+ } else {
+ $realSelectionContainer.empty().append('\u00a0').append(targetClone).append('\u00a0');
+ range.setStart($realSelectionContainer[0].firstChild, 1);
+ range.setEnd($realSelectionContainer[0].lastChild, 0);
+ }
+
+ $realSelectionContainer.css({
+ top: dom.getPos(node, editor.getBody()).y
+ });
+
+ $realSelectionContainer[0].focus();
+ sel = editor.selection.getSel();
+ sel.removeAllRanges();
+ sel.addRange(range);
+
+ editor.$('*[data-mce-selected]').removeAttr('data-mce-selected');
+ node.setAttribute('data-mce-selected', 1);
+ selectedContentEditableNode = node;
+
+ return range;
+ }
+
+ function clearContentEditableSelection() {
+ if (selectedContentEditableNode) {
+ selectedContentEditableNode.removeAttribute('data-mce-selected');
+ editor.$('#' + realSelectionId).remove();
+ selectedContentEditableNode = null;
+ }
+ }
+
+ function destroy() {
+ fakeCaret.destroy();
+ selectedContentEditableNode = null;
+ }
+
+ function hideFakeCaret() {
+ fakeCaret.hide();
+ }
+
+ if (Env.ceFalse) {
+ registerEvents();
+ addCss();
+ }
+
+ return {
+ showBlockCaretContainer: showBlockCaretContainer,
+ hideFakeCaret: hideFakeCaret,
+ destroy: destroy
+ };
+ }
+
+ return SelectionOverrides;
+});
+
+// Included from: js/tinymce/classes/util/Uuid.js
+
+/**
+ * Uuid.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2016 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Generates unique ids.
+ *
+ * @class tinymce.util.Uuid
+ * @private
+ */
+define("tinymce/util/Uuid", [
+], function() {
+ var count = 0;
+
+ var seed = function () {
+ var rnd = function () {
+ return Math.round(Math.random() * 0xFFFFFFFF).toString(36);
+ };
+
+ var now = new Date().getTime();
+ return 's' + now.toString(36) + rnd() + rnd() + rnd();
+ };
+
+ var uuid = function (prefix) {
+ return prefix + (count++) + seed();
+ };
+
+ return {
+ uuid: uuid
+ };
+});
+
+// Included from: js/tinymce/classes/Editor.js
+
+/**
+ * Editor.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/*jshint scripturl:true */
+
+/**
+ * Include the base event class documentation.
+ *
+ * @include ../../../tools/docs/tinymce.Event.js
+ */
+
+/**
+ * This class contains the core logic for a TinyMCE editor.
+ *
+ * @class tinymce.Editor
+ * @mixes tinymce.util.Observable
+ * @example
+ * // Add a class to all paragraphs in the editor.
+ * tinymce.activeEditor.dom.addClass(tinymce.activeEditor.dom.select('p'), 'someclass');
+ *
+ * // Gets the current editors selection as text
+ * tinymce.activeEditor.selection.getContent({format: 'text'});
+ *
+ * // Creates a new editor instance
+ * var ed = new tinymce.Editor('textareaid', {
+ * some_setting: 1
+ * }, tinymce.EditorManager);
+ *
+ * // Select each item the user clicks on
+ * ed.on('click', function(e) {
+ * ed.selection.select(e.target);
+ * });
+ *
+ * ed.render();
+ */
+define("tinymce/Editor", [
+ "tinymce/dom/DOMUtils",
+ "tinymce/dom/DomQuery",
+ "tinymce/AddOnManager",
+ "tinymce/NodeChange",
+ "tinymce/html/Node",
+ "tinymce/dom/Serializer",
+ "tinymce/html/Serializer",
+ "tinymce/dom/Selection",
+ "tinymce/Formatter",
+ "tinymce/UndoManager",
+ "tinymce/EnterKey",
+ "tinymce/ForceBlocks",
+ "tinymce/EditorCommands",
+ "tinymce/util/URI",
+ "tinymce/dom/ScriptLoader",
+ "tinymce/dom/EventUtils",
+ "tinymce/WindowManager",
+ "tinymce/NotificationManager",
+ "tinymce/html/Schema",
+ "tinymce/html/DomParser",
+ "tinymce/util/Quirks",
+ "tinymce/Env",
+ "tinymce/util/Tools",
+ "tinymce/util/Delay",
+ "tinymce/EditorObservable",
+ "tinymce/Mode",
+ "tinymce/Shortcuts",
+ "tinymce/EditorUpload",
+ "tinymce/SelectionOverrides",
+ "tinymce/util/Uuid"
+], function(
+ DOMUtils, DomQuery, AddOnManager, NodeChange, Node, DomSerializer, Serializer,
+ Selection, Formatter, UndoManager, EnterKey, ForceBlocks, EditorCommands,
+ URI, ScriptLoader, EventUtils, WindowManager, NotificationManager,
+ Schema, DomParser, Quirks, Env, Tools, Delay, EditorObservable, Mode, Shortcuts, EditorUpload,
+ SelectionOverrides, Uuid
+) {
+ // Shorten these names
+ var DOM = DOMUtils.DOM, ThemeManager = AddOnManager.ThemeManager, PluginManager = AddOnManager.PluginManager;
+ var extend = Tools.extend, each = Tools.each, explode = Tools.explode;
+ var inArray = Tools.inArray, trim = Tools.trim, resolve = Tools.resolve;
+ var Event = EventUtils.Event;
+ var isGecko = Env.gecko, ie = Env.ie;
+
+ /**
+ * Include documentation for all the events.
+ *
+ * @include ../../../tools/docs/tinymce.Editor.js
+ */
+
+ /**
+ * Constructs a editor instance by id.
+ *
+ * @constructor
+ * @method Editor
+ * @param {String} id Unique id for the editor.
+ * @param {Object} settings Settings for the editor.
+ * @param {tinymce.EditorManager} editorManager EditorManager instance.
+ */
+ function Editor(id, settings, editorManager) {
+ var self = this, documentBaseUrl, baseUri, defaultSettings;
+
+ documentBaseUrl = self.documentBaseUrl = editorManager.documentBaseURL;
+ baseUri = editorManager.baseURI;
+ defaultSettings = editorManager.defaultSettings;
+
+ /**
+ * Name/value collection with editor settings.
+ *
+ * @property settings
+ * @type Object
+ * @example
+ * // Get the value of the theme setting
+ * tinymce.activeEditor.windowManager.alert("You are using the " + tinymce.activeEditor.settings.theme + " theme");
+ */
+ settings = extend({
+ id: id,
+ theme: 'modern',
+ delta_width: 0,
+ delta_height: 0,
+ popup_css: '',
+ plugins: '',
+ document_base_url: documentBaseUrl,
+ add_form_submit_trigger: true,
+ submit_patch: true,
+ add_unload_trigger: true,
+ convert_urls: true,
+ relative_urls: true,
+ remove_script_host: true,
+ object_resizing: true,
+ doctype: '',
+ visual: true,
+ font_size_style_values: 'xx-small,x-small,small,medium,large,x-large,xx-large',
+
+ // See: http://www.w3.org/TR/CSS2/fonts.html#propdef-font-size
+ font_size_legacy_values: 'xx-small,small,medium,large,x-large,xx-large,300%',
+ forced_root_block: 'p',
+ hidden_input: true,
+ padd_empty_editor: true,
+ render_ui: true,
+ indentation: '30px',
+ inline_styles: true,
+ convert_fonts_to_spans: true,
+ indent: 'simple',
+ indent_before: 'p,h1,h2,h3,h4,h5,h6,blockquote,div,title,style,pre,script,td,th,ul,ol,li,dl,dt,dd,area,table,thead,' +
+ 'tfoot,tbody,tr,section,article,hgroup,aside,figure,figcaption,option,optgroup,datalist',
+ indent_after: 'p,h1,h2,h3,h4,h5,h6,blockquote,div,title,style,pre,script,td,th,ul,ol,li,dl,dt,dd,area,table,thead,' +
+ 'tfoot,tbody,tr,section,article,hgroup,aside,figure,figcaption,option,optgroup,datalist',
+ validate: true,
+ entity_encoding: 'named',
+ url_converter: self.convertURL,
+ url_converter_scope: self,
+ ie7_compat: true
+ }, defaultSettings, settings);
+
+ // Merge external_plugins
+ if (defaultSettings && defaultSettings.external_plugins && settings.external_plugins) {
+ settings.external_plugins = extend({}, defaultSettings.external_plugins, settings.external_plugins);
+ }
+
+ self.settings = settings;
+ AddOnManager.language = settings.language || 'en';
+ AddOnManager.languageLoad = settings.language_load;
+ AddOnManager.baseURL = editorManager.baseURL;
+
+ /**
+ * Editor instance id, normally the same as the div/textarea that was replaced.
+ *
+ * @property id
+ * @type String
+ */
+ self.id = settings.id = id;
+
+ /**
+ * State to force the editor to return false on a isDirty call.
+ *
+ * @property isNotDirty
+ * @type Boolean
+ * @deprecated Use editor.setDirty instead.
+ */
+ self.setDirty(false);
+
+ /**
+ * Name/Value object containing plugin instances.
+ *
+ * @property plugins
+ * @type Object
+ * @example
+ * // Execute a method inside a plugin directly
+ * tinymce.activeEditor.plugins.someplugin.someMethod();
+ */
+ self.plugins = {};
+
+ /**
+ * URI object to document configured for the TinyMCE instance.
+ *
+ * @property documentBaseURI
+ * @type tinymce.util.URI
+ * @example
+ * // Get relative URL from the location of document_base_url
+ * tinymce.activeEditor.documentBaseURI.toRelative('/somedir/somefile.htm');
+ *
+ * // Get absolute URL from the location of document_base_url
+ * tinymce.activeEditor.documentBaseURI.toAbsolute('somefile.htm');
+ */
+ self.documentBaseURI = new URI(settings.document_base_url || documentBaseUrl, {
+ base_uri: baseUri
+ });
+
+ /**
+ * URI object to current document that holds the TinyMCE editor instance.
+ *
+ * @property baseURI
+ * @type tinymce.util.URI
+ * @example
+ * // Get relative URL from the location of the API
+ * tinymce.activeEditor.baseURI.toRelative('/somedir/somefile.htm');
+ *
+ * // Get absolute URL from the location of the API
+ * tinymce.activeEditor.baseURI.toAbsolute('somefile.htm');
+ */
+ self.baseURI = baseUri;
+
+ /**
+ * Array with CSS files to load into the iframe.
+ *
+ * @property contentCSS
+ * @type Array
+ */
+ self.contentCSS = [];
+
+ /**
+ * Array of CSS styles to add to head of document when the editor loads.
+ *
+ * @property contentStyles
+ * @type Array
+ */
+ self.contentStyles = [];
+
+ // Creates all events like onClick, onSetContent etc see Editor.Events.js for the actual logic
+ self.shortcuts = new Shortcuts(self);
+ self.loadedCSS = {};
+ self.editorCommands = new EditorCommands(self);
+
+ if (settings.target) {
+ self.targetElm = settings.target;
+ }
+
+ self.suffix = editorManager.suffix;
+ self.editorManager = editorManager;
+ self.inline = settings.inline;
+ self.settings.content_editable = self.inline;
+
+ if (settings.cache_suffix) {
+ Env.cacheSuffix = settings.cache_suffix.replace(/^[\?\&]+/, '');
+ }
+
+ if (settings.override_viewport === false) {
+ Env.overrideViewPort = false;
+ }
+
+ // Call setup
+ editorManager.fire('SetupEditor', self);
+ self.execCallback('setup', self);
+
+ /**
+ * Dom query instance with default scope to the editor document and default element is the body of the editor.
+ *
+ * @property $
+ * @type tinymce.dom.DomQuery
+ * @example
+ * tinymce.activeEditor.$('p').css('color', 'red');
+ * tinymce.activeEditor.$().append('new
');
+ */
+ self.$ = DomQuery.overrideDefaults(function() {
+ return {
+ context: self.inline ? self.getBody() : self.getDoc(),
+ element: self.getBody()
+ };
+ });
+ }
+
+ Editor.prototype = {
+ /**
+ * Renders the editor/adds it to the page.
+ *
+ * @method render
+ */
+ render: function() {
+ var self = this, settings = self.settings, id = self.id, suffix = self.suffix;
+
+ function readyHandler() {
+ DOM.unbind(window, 'ready', readyHandler);
+ self.render();
+ }
+
+ // Page is not loaded yet, wait for it
+ if (!Event.domLoaded) {
+ DOM.bind(window, 'ready', readyHandler);
+ return;
+ }
+
+ // Element not found, then skip initialization
+ if (!self.getElement()) {
+ return;
+ }
+
+ // No editable support old iOS versions etc
+ if (!Env.contentEditable) {
+ return;
+ }
+
+ // Hide target element early to prevent content flashing
+ if (!settings.inline) {
+ self.orgVisibility = self.getElement().style.visibility;
+ self.getElement().style.visibility = 'hidden';
+ } else {
+ self.inline = true;
+ }
+
+ var form = self.getElement().form || DOM.getParent(id, 'form');
+ if (form) {
+ self.formElement = form;
+
+ // Add hidden input for non input elements inside form elements
+ if (settings.hidden_input && !/TEXTAREA|INPUT/i.test(self.getElement().nodeName)) {
+ DOM.insertAfter(DOM.create('input', {type: 'hidden', name: id}), id);
+ self.hasHiddenInput = true;
+ }
+
+ // Pass submit/reset from form to editor instance
+ self.formEventDelegate = function(e) {
+ self.fire(e.type, e);
+ };
+
+ DOM.bind(form, 'submit reset', self.formEventDelegate);
+
+ // Reset contents in editor when the form is reset
+ self.on('reset', function() {
+ self.setContent(self.startContent, {format: 'raw'});
+ });
+
+ // Check page uses id="submit" or name="submit" for it's submit button
+ if (settings.submit_patch && !form.submit.nodeType && !form.submit.length && !form._mceOldSubmit) {
+ form._mceOldSubmit = form.submit;
+ form.submit = function() {
+ self.editorManager.triggerSave();
+ self.setDirty(false);
+
+ return form._mceOldSubmit(form);
+ };
+ }
+ }
+
+ /**
+ * Window manager reference, use this to open new windows and dialogs.
+ *
+ * @property windowManager
+ * @type tinymce.WindowManager
+ * @example
+ * // Shows an alert message
+ * tinymce.activeEditor.windowManager.alert('Hello world!');
+ *
+ * // Opens a new dialog with the file.htm file and the size 320x240
+ * // It also adds a custom parameter this can be retrieved by using tinyMCEPopup.getWindowArg inside the dialog.
+ * tinymce.activeEditor.windowManager.open({
+ * url: 'file.htm',
+ * width: 320,
+ * height: 240
+ * }, {
+ * custom_param: 1
+ * });
+ */
+ self.windowManager = new WindowManager(self);
+
+ /**
+ * Notification manager reference, use this to open new windows and dialogs.
+ *
+ * @property notificationManager
+ * @type tinymce.NotificationManager
+ * @example
+ * // Shows a notification info message.
+ * tinymce.activeEditor.notificationManager.open({text: 'Hello world!', type: 'info'});
+ */
+ self.notificationManager = new NotificationManager(self);
+
+ if (settings.encoding == 'xml') {
+ self.on('GetContent', function(e) {
+ if (e.save) {
+ e.content = DOM.encode(e.content);
+ }
+ });
+ }
+
+ if (settings.add_form_submit_trigger) {
+ self.on('submit', function() {
+ if (self.initialized) {
+ self.save();
+ }
+ });
+ }
+
+ if (settings.add_unload_trigger) {
+ self._beforeUnload = function() {
+ if (self.initialized && !self.destroyed && !self.isHidden()) {
+ self.save({format: 'raw', no_events: true, set_dirty: false});
+ }
+ };
+
+ self.editorManager.on('BeforeUnload', self._beforeUnload);
+ }
+
+ // Load scripts
+ function loadScripts() {
+ var scriptLoader = ScriptLoader.ScriptLoader;
+
+ if (settings.language && settings.language != 'en' && !settings.language_url) {
+ settings.language_url = self.editorManager.baseURL + '/langs/' + settings.language + '.js';
+ }
+
+ if (settings.language_url) {
+ scriptLoader.add(settings.language_url);
+ }
+
+ if (settings.theme && typeof settings.theme != "function" &&
+ settings.theme.charAt(0) != '-' && !ThemeManager.urls[settings.theme]) {
+ var themeUrl = settings.theme_url;
+
+ if (themeUrl) {
+ themeUrl = self.documentBaseURI.toAbsolute(themeUrl);
+ } else {
+ themeUrl = 'themes/' + settings.theme + '/theme' + suffix + '.js';
+ }
+
+ ThemeManager.load(settings.theme, themeUrl);
+ }
+
+ if (Tools.isArray(settings.plugins)) {
+ settings.plugins = settings.plugins.join(' ');
+ }
+
+ each(settings.external_plugins, function(url, name) {
+ PluginManager.load(name, url);
+ settings.plugins += ' ' + name;
+ });
+
+ each(settings.plugins.split(/[ ,]/), function(plugin) {
+ plugin = trim(plugin);
+
+ if (plugin && !PluginManager.urls[plugin]) {
+ if (plugin.charAt(0) == '-') {
+ plugin = plugin.substr(1, plugin.length);
+
+ var dependencies = PluginManager.dependencies(plugin);
+
+ each(dependencies, function(dep) {
+ var defaultSettings = {
+ prefix: 'plugins/',
+ resource: dep,
+ suffix: '/plugin' + suffix + '.js'
+ };
+
+ dep = PluginManager.createUrl(defaultSettings, dep);
+ PluginManager.load(dep.resource, dep);
+ });
+ } else {
+ PluginManager.load(plugin, {
+ prefix: 'plugins/',
+ resource: plugin,
+ suffix: '/plugin' + suffix + '.js'
+ });
+ }
+ }
+ });
+
+ scriptLoader.loadQueue(function() {
+ if (!self.removed) {
+ self.init();
+ }
+ });
+ }
+
+ self.editorManager.add(self);
+ loadScripts();
+ },
+
+ /**
+ * Initializes the editor this will be called automatically when
+ * all plugins/themes and language packs are loaded by the rendered method.
+ * This method will setup the iframe and create the theme and plugin instances.
+ *
+ * @method init
+ */
+ init: function() {
+ var self = this, settings = self.settings, elm = self.getElement();
+ var w, h, minHeight, n, o, Theme, url, bodyId, bodyClass, re, i, initializedPlugins = [];
+
+ self.rtl = settings.rtl_ui || self.editorManager.i18n.rtl;
+ self.editorManager.i18n.setCode(settings.language);
+ settings.aria_label = settings.aria_label || DOM.getAttrib(elm, 'aria-label', self.getLang('aria.rich_text_area'));
+
+ self.fire('ScriptsLoaded');
+
+ /**
+ * Reference to the theme instance that was used to generate the UI.
+ *
+ * @property theme
+ * @type tinymce.Theme
+ * @example
+ * // Executes a method on the theme directly
+ * tinymce.activeEditor.theme.someMethod();
+ */
+ if (settings.theme) {
+ if (typeof settings.theme != "function") {
+ settings.theme = settings.theme.replace(/-/, '');
+ Theme = ThemeManager.get(settings.theme);
+ self.theme = new Theme(self, ThemeManager.urls[settings.theme]);
+
+ if (self.theme.init) {
+ self.theme.init(self, ThemeManager.urls[settings.theme] || self.documentBaseUrl.replace(/\/$/, ''), self.$);
+ }
+ } else {
+ self.theme = settings.theme;
+ }
+ }
+
+ function initPlugin(plugin) {
+ var Plugin = PluginManager.get(plugin), pluginUrl, pluginInstance;
+
+ pluginUrl = PluginManager.urls[plugin] || self.documentBaseUrl.replace(/\/$/, '');
+ plugin = trim(plugin);
+ if (Plugin && inArray(initializedPlugins, plugin) === -1) {
+ each(PluginManager.dependencies(plugin), function(dep) {
+ initPlugin(dep);
+ });
+
+ if (self.plugins[plugin]) {
+ return;
+ }
+
+ pluginInstance = new Plugin(self, pluginUrl, self.$);
+
+ self.plugins[plugin] = pluginInstance;
+
+ if (pluginInstance.init) {
+ pluginInstance.init(self, pluginUrl);
+ initializedPlugins.push(plugin);
+ }
+ }
+ }
+
+ // Create all plugins
+ each(settings.plugins.replace(/\-/g, '').split(/[ ,]/), initPlugin);
+
+ // Measure box
+ if (settings.render_ui && self.theme) {
+ self.orgDisplay = elm.style.display;
+
+ if (typeof settings.theme != "function") {
+ w = settings.width || elm.style.width || elm.offsetWidth;
+ h = settings.height || elm.style.height || elm.offsetHeight;
+ minHeight = settings.min_height || 100;
+ re = /^[0-9\.]+(|px)$/i;
+
+ if (re.test('' + w)) {
+ w = Math.max(parseInt(w, 10), 100);
+ }
+
+ if (re.test('' + h)) {
+ h = Math.max(parseInt(h, 10), minHeight);
+ }
+
+ // Render UI
+ o = self.theme.renderUI({
+ targetNode: elm,
+ width: w,
+ height: h,
+ deltaWidth: settings.delta_width,
+ deltaHeight: settings.delta_height
+ });
+
+ // Resize editor
+ if (!settings.content_editable) {
+ h = (o.iframeHeight || h) + (typeof h == 'number' ? (o.deltaHeight || 0) : '');
+ if (h < minHeight) {
+ h = minHeight;
+ }
+ }
+ } else {
+ o = settings.theme(self, elm);
+
+ // Convert element type to id:s
+ if (o.editorContainer.nodeType) {
+ o.editorContainer = o.editorContainer.id = o.editorContainer.id || self.id + "_parent";
+ }
+
+ // Convert element type to id:s
+ if (o.iframeContainer.nodeType) {
+ o.iframeContainer = o.iframeContainer.id = o.iframeContainer.id || self.id + "_iframecontainer";
+ }
+
+ // Use specified iframe height or the targets offsetHeight
+ h = o.iframeHeight || elm.offsetHeight;
+ }
+
+ self.editorContainer = o.editorContainer;
+ }
+
+ // Load specified content CSS last
+ if (settings.content_css) {
+ each(explode(settings.content_css), function(u) {
+ self.contentCSS.push(self.documentBaseURI.toAbsolute(u));
+ });
+ }
+
+ // Load specified content CSS last
+ if (settings.content_style) {
+ self.contentStyles.push(settings.content_style);
+ }
+
+ // Content editable mode ends here
+ if (settings.content_editable) {
+ elm = n = o = null; // Fix IE leak
+ return self.initContentBody();
+ }
+
+ self.iframeHTML = settings.doctype + '';
+
+ // We only need to override paths if we have to
+ // IE has a bug where it remove site absolute urls to relative ones if this is specified
+ if (settings.document_base_url != self.documentBaseUrl) {
+ self.iframeHTML += '';
+ }
+
+ // IE8 doesn't support carets behind images setting ie7_compat would force IE8+ to run in IE7 compat mode.
+ if (!Env.caretAfter && settings.ie7_compat) {
+ self.iframeHTML += '';
+ }
+
+ self.iframeHTML += '';
+
+ // Load the CSS by injecting them into the HTML this will reduce "flicker"
+ // However we can't do that on Chrome since # will scroll to the editor for some odd reason see #2427
+ if (!/#$/.test(document.location.href)) {
+ for (i = 0; i < self.contentCSS.length; i++) {
+ var cssUrl = self.contentCSS[i];
+ self.iframeHTML += (
+ ''
+ );
+ self.loadedCSS[cssUrl] = true;
+ }
+ }
+
+ bodyId = settings.body_id || 'tinymce';
+ if (bodyId.indexOf('=') != -1) {
+ bodyId = self.getParam('body_id', '', 'hash');
+ bodyId = bodyId[self.id] || bodyId;
+ }
+
+ bodyClass = settings.body_class || '';
+ if (bodyClass.indexOf('=') != -1) {
+ bodyClass = self.getParam('body_class', '', 'hash');
+ bodyClass = bodyClass[self.id] || '';
+ }
+
+ if (settings.content_security_policy) {
+ self.iframeHTML += '';
+ }
+
+ self.iframeHTML += '
';
+
+ /*eslint no-script-url:0 */
+ var domainRelaxUrl = 'javascript:(function(){' +
+ 'document.open();document.domain="' + document.domain + '";' +
+ 'var ed = window.parent.tinymce.get("' + self.id + '");document.write(ed.iframeHTML);' +
+ 'document.close();ed.initContentBody(true);})()';
+
+ // Domain relaxing is required since the user has messed around with document.domain
+ if (document.domain != location.hostname) {
+ // Edge seems to be able to handle domain relaxing
+ if (Env.ie && Env.ie < 12) {
+ url = domainRelaxUrl;
+ }
+ }
+
+ // Create iframe
+ // TODO: ACC add the appropriate description on this.
+ var ifr = DOM.create('iframe', {
+ id: self.id + "_ifr",
+ //src: url || 'javascript:""', // Workaround for HTTPS warning in IE6/7
+ frameBorder: '0',
+ allowTransparency: "true",
+ title: self.editorManager.translate(
+ "Rich Text Area. Press ALT-F9 for menu. " +
+ "Press ALT-F10 for toolbar. Press ALT-0 for help"
+ ),
+ style: {
+ width: '100%',
+ height: h,
+ display: 'block' // Important for Gecko to render the iframe correctly
+ }
+ });
+
+ ifr.onload = function() {
+ ifr.onload = null;
+ self.fire("load");
+ };
+
+ DOM.setAttrib(ifr, "src", url || 'javascript:""');
+
+ self.contentAreaContainer = o.iframeContainer;
+ self.iframeElement = ifr;
+
+ n = DOM.add(o.iframeContainer, ifr);
+
+ // Try accessing the document this will fail on IE when document.domain is set to the same as location.hostname
+ // Then we have to force domain relaxing using the domainRelaxUrl approach very ugly!!
+ if (ie) {
+ try {
+ self.getDoc();
+ } catch (e) {
+ n.src = url = domainRelaxUrl;
+ }
+ }
+
+ if (o.editorContainer) {
+ DOM.get(o.editorContainer).style.display = self.orgDisplay;
+ self.hidden = DOM.isHidden(o.editorContainer);
+ }
+
+ self.getElement().style.display = 'none';
+ DOM.setAttrib(self.id, 'aria-hidden', true);
+
+ if (!url) {
+ self.initContentBody();
+ }
+
+ elm = n = o = null; // Cleanup
+ },
+
+ /**
+ * This method get called by the init method once the iframe is loaded.
+ * It will fill the iframe with contents, sets up DOM and selection objects for the iframe.
+ *
+ * @method initContentBody
+ * @private
+ */
+ initContentBody: function(skipWrite) {
+ var self = this, settings = self.settings, targetElm = self.getElement(), doc = self.getDoc(), body, contentCssText;
+
+ // Restore visibility on target element
+ if (!settings.inline) {
+ self.getElement().style.visibility = self.orgVisibility;
+ }
+
+ // Setup iframe body
+ if (!skipWrite && !settings.content_editable) {
+ doc.open();
+ doc.write(self.iframeHTML);
+ doc.close();
+ }
+
+ if (settings.content_editable) {
+ self.on('remove', function() {
+ var bodyEl = this.getBody();
+
+ DOM.removeClass(bodyEl, 'mce-content-body');
+ DOM.removeClass(bodyEl, 'mce-edit-focus');
+ DOM.setAttrib(bodyEl, 'contentEditable', null);
+ });
+
+ DOM.addClass(targetElm, 'mce-content-body');
+ self.contentDocument = doc = settings.content_document || document;
+ self.contentWindow = settings.content_window || window;
+ self.bodyElement = targetElm;
+
+ // Prevent leak in IE
+ settings.content_document = settings.content_window = null;
+
+ // TODO: Fix this
+ settings.root_name = targetElm.nodeName.toLowerCase();
+ }
+
+ // It will not steal focus while setting contentEditable
+ body = self.getBody();
+ body.disabled = true;
+ self.readonly = settings.readonly;
+
+ if (!self.readonly) {
+ if (self.inline && DOM.getStyle(body, 'position', true) == 'static') {
+ body.style.position = 'relative';
+ }
+
+ body.contentEditable = self.getParam('content_editable_state', true);
+ }
+
+ body.disabled = false;
+
+ self.editorUpload = new EditorUpload(self);
+
+ /**
+ * Schema instance, enables you to validate elements and its children.
+ *
+ * @property schema
+ * @type tinymce.html.Schema
+ */
+ self.schema = new Schema(settings);
+
+ /**
+ * DOM instance for the editor.
+ *
+ * @property dom
+ * @type tinymce.dom.DOMUtils
+ * @example
+ * // Adds a class to all paragraphs within the editor
+ * tinymce.activeEditor.dom.addClass(tinymce.activeEditor.dom.select('p'), 'someclass');
+ */
+ self.dom = new DOMUtils(doc, {
+ keep_values: true,
+ url_converter: self.convertURL,
+ url_converter_scope: self,
+ hex_colors: settings.force_hex_style_colors,
+ class_filter: settings.class_filter,
+ update_styles: true,
+ root_element: self.inline ? self.getBody() : null,
+ collect: settings.content_editable,
+ schema: self.schema,
+ onSetAttrib: function(e) {
+ self.fire('SetAttrib', e);
+ }
+ });
+
+ /**
+ * HTML parser will be used when contents is inserted into the editor.
+ *
+ * @property parser
+ * @type tinymce.html.DomParser
+ */
+ self.parser = new DomParser(settings, self.schema);
+
+ // Convert src and href into data-mce-src, data-mce-href and data-mce-style
+ self.parser.addAttributeFilter('src,href,style,tabindex', function(nodes, name) {
+ var i = nodes.length, node, dom = self.dom, value, internalName;
+
+ while (i--) {
+ node = nodes[i];
+ value = node.attr(name);
+ internalName = 'data-mce-' + name;
+
+ // Add internal attribute if we need to we don't on a refresh of the document
+ if (!node.attributes.map[internalName]) {
+ // Don't duplicate these since they won't get modified by any browser
+ if (value.indexOf('data:') === 0 || value.indexOf('blob:') === 0) {
+ continue;
+ }
+
+ if (name === "style") {
+ value = dom.serializeStyle(dom.parseStyle(value), node.name);
+
+ if (!value.length) {
+ value = null;
+ }
+
+ node.attr(internalName, value);
+ node.attr(name, value);
+ } else if (name === "tabindex") {
+ node.attr(internalName, value);
+ node.attr(name, null);
+ } else {
+ node.attr(internalName, self.convertURL(value, name, node.name));
+ }
+ }
+ }
+ });
+
+ // Keep scripts from executing
+ self.parser.addNodeFilter('script', function(nodes) {
+ var i = nodes.length, node, type;
+
+ while (i--) {
+ node = nodes[i];
+ type = node.attr('type') || 'no/type';
+ if (type.indexOf('mce-') !== 0) {
+ node.attr('type', 'mce-' + type);
+ }
+ }
+ });
+
+ self.parser.addNodeFilter('#cdata', function(nodes) {
+ var i = nodes.length, node;
+
+ while (i--) {
+ node = nodes[i];
+ node.type = 8;
+ node.name = '#comment';
+ node.value = '[CDATA[' + node.value + ']]';
+ }
+ });
+
+ self.parser.addNodeFilter('p,h1,h2,h3,h4,h5,h6,div', function(nodes) {
+ var i = nodes.length, node, nonEmptyElements = self.schema.getNonEmptyElements();
+
+ while (i--) {
+ node = nodes[i];
+
+ if (node.isEmpty(nonEmptyElements)) {
+ node.append(new Node('br', 1)).shortEnded = true;
+ }
+ }
+ });
+
+ /**
+ * DOM serializer for the editor. Will be used when contents is extracted from the editor.
+ *
+ * @property serializer
+ * @type tinymce.dom.Serializer
+ * @example
+ * // Serializes the first paragraph in the editor into a string
+ * tinymce.activeEditor.serializer.serialize(tinymce.activeEditor.dom.select('p')[0]);
+ */
+ self.serializer = new DomSerializer(settings, self);
+
+ /**
+ * Selection instance for the editor.
+ *
+ * @property selection
+ * @type tinymce.dom.Selection
+ * @example
+ * // Sets some contents to the current selection in the editor
+ * tinymce.activeEditor.selection.setContent('Some contents');
+ *
+ * // Gets the current selection
+ * alert(tinymce.activeEditor.selection.getContent());
+ *
+ * // Selects the first paragraph found
+ * tinymce.activeEditor.selection.select(tinymce.activeEditor.dom.select('p')[0]);
+ */
+ self.selection = new Selection(self.dom, self.getWin(), self.serializer, self);
+
+ /**
+ * Formatter instance.
+ *
+ * @property formatter
+ * @type tinymce.Formatter
+ */
+ self.formatter = new Formatter(self);
+
+ /**
+ * Undo manager instance, responsible for handling undo levels.
+ *
+ * @property undoManager
+ * @type tinymce.UndoManager
+ * @example
+ * // Undoes the last modification to the editor
+ * tinymce.activeEditor.undoManager.undo();
+ */
+ self.undoManager = new UndoManager(self);
+
+ self.forceBlocks = new ForceBlocks(self);
+ self.enterKey = new EnterKey(self);
+ self._nodeChangeDispatcher = new NodeChange(self);
+ self._selectionOverrides = new SelectionOverrides(self);
+
+ self.fire('PreInit');
+
+ if (!settings.browser_spellcheck && !settings.gecko_spellcheck) {
+ doc.body.spellcheck = false; // Gecko
+ DOM.setAttrib(body, "spellcheck", "false");
+ }
+
+ self.quirks = new Quirks(self);
+ self.fire('PostRender');
+
+ if (settings.directionality) {
+ body.dir = settings.directionality;
+ }
+
+ if (settings.nowrap) {
+ body.style.whiteSpace = "nowrap";
+ }
+
+ if (settings.protect) {
+ self.on('BeforeSetContent', function(e) {
+ each(settings.protect, function(pattern) {
+ e.content = e.content.replace(pattern, function(str) {
+ return '';
+ });
+ });
+ });
+ }
+
+ self.on('SetContent', function() {
+ self.addVisual(self.getBody());
+ });
+
+ // Remove empty contents
+ if (settings.padd_empty_editor) {
+ self.on('PostProcess', function(e) {
+ e.content = e.content.replace(/^(]*>( | |\s|\u00a0|)<\/p>[\r\n]*|
[\r\n]*)$/, '');
+ });
+ }
+
+ self.load({initial: true, format: 'html'});
+ self.startContent = self.getContent({format: 'raw'});
+
+ /**
+ * Is set to true after the editor instance has been initialized
+ *
+ * @property initialized
+ * @type Boolean
+ * @example
+ * function isEditorInitialized(editor) {
+ * return editor && editor.initialized;
+ * }
+ */
+ self.initialized = true;
+ self.bindPendingEventDelegates();
+
+ self.fire('init');
+ self.focus(true);
+ self.nodeChanged({initial: true});
+ self.execCallback('init_instance_callback', self);
+
+ self.on('compositionstart compositionend', function(e) {
+ self.composing = e.type === 'compositionstart';
+ });
+
+ // Add editor specific CSS styles
+ if (self.contentStyles.length > 0) {
+ contentCssText = '';
+
+ each(self.contentStyles, function(style) {
+ contentCssText += style + "\r\n";
+ });
+
+ self.dom.addStyle(contentCssText);
+ }
+
+ // Load specified content CSS last
+ each(self.contentCSS, function(cssUrl) {
+ if (!self.loadedCSS[cssUrl]) {
+ self.dom.loadCSS(cssUrl);
+ self.loadedCSS[cssUrl] = true;
+ }
+ });
+
+ // Handle auto focus
+ if (settings.auto_focus) {
+ Delay.setEditorTimeout(self, function() {
+ var editor;
+
+ if (settings.auto_focus === true) {
+ editor = self;
+ } else {
+ editor = self.editorManager.get(settings.auto_focus);
+ }
+
+ if (!editor.destroyed) {
+ editor.focus();
+ }
+ }, 100);
+ }
+
+ // Clean up references for IE
+ targetElm = doc = body = null;
+ },
+
+ /**
+ * Focuses/activates the editor. This will set this editor as the activeEditor in the tinymce collection
+ * it will also place DOM focus inside the editor.
+ *
+ * @method focus
+ * @param {Boolean} skipFocus Skip DOM focus. Just set is as the active editor.
+ */
+ focus: function(skipFocus) {
+ var self = this, selection = self.selection, contentEditable = self.settings.content_editable, rng;
+ var controlElm, doc = self.getDoc(), body = self.getBody(), contentEditableHost;
+
+ function getContentEditableHost(node) {
+ return self.dom.getParent(node, function(node) {
+ return self.dom.getContentEditable(node) === "true";
+ });
+ }
+
+ if (!skipFocus) {
+ // Get selected control element
+ rng = selection.getRng();
+ if (rng.item) {
+ controlElm = rng.item(0);
+ }
+
+ self.quirks.refreshContentEditable();
+
+ // Move focus to contentEditable=true child if needed
+ contentEditableHost = getContentEditableHost(selection.getNode());
+ if (self.$.contains(body, contentEditableHost)) {
+ contentEditableHost.focus();
+ selection.normalize();
+ self.editorManager.setActive(self);
+ return;
+ }
+
+ // Focus the window iframe
+ if (!contentEditable) {
+ // WebKit needs this call to fire focusin event properly see #5948
+ // But Opera pre Blink engine will produce an empty selection so skip Opera
+ if (!Env.opera) {
+ self.getBody().focus();
+ }
+
+ self.getWin().focus();
+ }
+
+ // Focus the body as well since it's contentEditable
+ if (isGecko || contentEditable) {
+ // Check for setActive since it doesn't scroll to the element
+ if (body.setActive) {
+ // IE 11 sometimes throws "Invalid function" then fallback to focus
+ try {
+ body.setActive();
+ } catch (ex) {
+ body.focus();
+ }
+ } else {
+ body.focus();
+ }
+
+ if (contentEditable) {
+ selection.normalize();
+ }
+ }
+
+ // Restore selected control element
+ // This is needed when for example an image is selected within a
+ // layer a call to focus will then remove the control selection
+ if (controlElm && controlElm.ownerDocument == doc) {
+ rng = doc.body.createControlRange();
+ rng.addElement(controlElm);
+ rng.select();
+ }
+ }
+
+ self.editorManager.setActive(self);
+ },
+
+ /**
+ * Executes a legacy callback. This method is useful to call old 2.x option callbacks.
+ * There new event model is a better way to add callback so this method might be removed in the future.
+ *
+ * @method execCallback
+ * @param {String} name Name of the callback to execute.
+ * @return {Object} Return value passed from callback function.
+ */
+ execCallback: function(name) {
+ var self = this, callback = self.settings[name], scope;
+
+ if (!callback) {
+ return;
+ }
+
+ // Look through lookup
+ if (self.callbackLookup && (scope = self.callbackLookup[name])) {
+ callback = scope.func;
+ scope = scope.scope;
+ }
+
+ if (typeof callback === 'string') {
+ scope = callback.replace(/\.\w+$/, '');
+ scope = scope ? resolve(scope) : 0;
+ callback = resolve(callback);
+ self.callbackLookup = self.callbackLookup || {};
+ self.callbackLookup[name] = {func: callback, scope: scope};
+ }
+
+ return callback.apply(scope || self, Array.prototype.slice.call(arguments, 1));
+ },
+
+ /**
+ * Translates the specified string by replacing variables with language pack items it will also check if there is
+ * a key matching the input.
+ *
+ * @method translate
+ * @param {String} text String to translate by the language pack data.
+ * @return {String} Translated string.
+ */
+ translate: function(text) {
+ var lang = this.settings.language || 'en', i18n = this.editorManager.i18n;
+
+ if (!text) {
+ return '';
+ }
+
+ text = i18n.data[lang + '.' + text] || text.replace(/\{\#([^\}]+)\}/g, function(a, b) {
+ return i18n.data[lang + '.' + b] || '{#' + b + '}';
+ });
+
+ return this.editorManager.translate(text);
+ },
+
+ /**
+ * Returns a language pack item by name/key.
+ *
+ * @method getLang
+ * @param {String} name Name/key to get from the language pack.
+ * @param {String} defaultVal Optional default value to retrieve.
+ */
+ getLang: function(name, defaultVal) {
+ return (
+ this.editorManager.i18n.data[(this.settings.language || 'en') + '.' + name] ||
+ (defaultVal !== undefined ? defaultVal : '{#' + name + '}')
+ );
+ },
+
+ /**
+ * Returns a configuration parameter by name.
+ *
+ * @method getParam
+ * @param {String} name Configruation parameter to retrieve.
+ * @param {String} defaultVal Optional default value to return.
+ * @param {String} type Optional type parameter.
+ * @return {String} Configuration parameter value or default value.
+ * @example
+ * // Returns a specific config value from the currently active editor
+ * var someval = tinymce.activeEditor.getParam('myvalue');
+ *
+ * // Returns a specific config value from a specific editor instance by id
+ * var someval2 = tinymce.get('my_editor').getParam('myvalue');
+ */
+ getParam: function(name, defaultVal, type) {
+ var value = name in this.settings ? this.settings[name] : defaultVal, output;
+
+ if (type === 'hash') {
+ output = {};
+
+ if (typeof value === 'string') {
+ each(value.indexOf('=') > 0 ? value.split(/[;,](?![^=;,]*(?:[;,]|$))/) : value.split(','), function(value) {
+ value = value.split('=');
+
+ if (value.length > 1) {
+ output[trim(value[0])] = trim(value[1]);
+ } else {
+ output[trim(value[0])] = trim(value);
+ }
+ });
+ } else {
+ output = value;
+ }
+
+ return output;
+ }
+
+ return value;
+ },
+
+ /**
+ * Dispatches out a onNodeChange event to all observers. This method should be called when you
+ * need to update the UI states or element path etc.
+ *
+ * @method nodeChanged
+ * @param {Object} args Optional args to pass to NodeChange event handlers.
+ */
+ nodeChanged: function(args) {
+ this._nodeChangeDispatcher.nodeChanged(args);
+ },
+
+ /**
+ * Adds a button that later gets created by the theme in the editors toolbars.
+ *
+ * @method addButton
+ * @param {String} name Button name to add.
+ * @param {Object} settings Settings object with title, cmd etc.
+ * @example
+ * // Adds a custom button to the editor that inserts contents when clicked
+ * tinymce.init({
+ * ...
+ *
+ * toolbar: 'example'
+ *
+ * setup: function(ed) {
+ * ed.addButton('example', {
+ * title: 'My title',
+ * image: '../js/tinymce/plugins/example/img/example.gif',
+ * onclick: function() {
+ * ed.insertContent('Hello world!!');
+ * }
+ * });
+ * }
+ * });
+ */
+ addButton: function(name, settings) {
+ var self = this;
+
+ if (settings.cmd) {
+ settings.onclick = function() {
+ self.execCommand(settings.cmd);
+ };
+ }
+
+ if (!settings.text && !settings.icon) {
+ settings.icon = name;
+ }
+
+ self.buttons = self.buttons || {};
+ settings.tooltip = settings.tooltip || settings.title;
+ self.buttons[name] = settings;
+ },
+
+ /**
+ * Adds a menu item to be used in the menus of the theme. There might be multiple instances
+ * of this menu item for example it might be used in the main menus of the theme but also in
+ * the context menu so make sure that it's self contained and supports multiple instances.
+ *
+ * @method addMenuItem
+ * @param {String} name Menu item name to add.
+ * @param {Object} settings Settings object with title, cmd etc.
+ * @example
+ * // Adds a custom menu item to the editor that inserts contents when clicked
+ * // The context option allows you to add the menu item to an existing default menu
+ * tinymce.init({
+ * ...
+ *
+ * setup: function(ed) {
+ * ed.addMenuItem('example', {
+ * text: 'My menu item',
+ * context: 'tools',
+ * onclick: function() {
+ * ed.insertContent('Hello world!!');
+ * }
+ * });
+ * }
+ * });
+ */
+ addMenuItem: function(name, settings) {
+ var self = this;
+
+ if (settings.cmd) {
+ settings.onclick = function() {
+ self.execCommand(settings.cmd);
+ };
+ }
+
+ self.menuItems = self.menuItems || {};
+ self.menuItems[name] = settings;
+ },
+
+ /**
+ * Adds a contextual toolbar to be rendered when the selector matches.
+ *
+ * @method addContextToolbar
+ * @param {function/string} predicate Predicate that needs to return true if provided strings get converted into CSS predicates.
+ * @param {String/Array} items String or array with items to add to the context toolbar.
+ */
+ addContextToolbar: function(predicate, items) {
+ var self = this, selector;
+
+ self.contextToolbars = self.contextToolbars || [];
+
+ // Convert selector to predicate
+ if (typeof predicate == "string") {
+ selector = predicate;
+ predicate = function(elm) {
+ return self.dom.is(elm, selector);
+ };
+ }
+
+ self.contextToolbars.push({
+ id: Uuid.uuid('mcet'),
+ predicate: predicate,
+ items: items
+ });
+ },
+
+ /**
+ * Adds a custom command to the editor, you can also override existing commands with this method.
+ * The command that you add can be executed with execCommand.
+ *
+ * @method addCommand
+ * @param {String} name Command name to add/override.
+ * @param {addCommandCallback} callback Function to execute when the command occurs.
+ * @param {Object} scope Optional scope to execute the function in.
+ * @example
+ * // Adds a custom command that later can be executed using execCommand
+ * tinymce.init({
+ * ...
+ *
+ * setup: function(ed) {
+ * // Register example command
+ * ed.addCommand('mycommand', function(ui, v) {
+ * ed.windowManager.alert('Hello world!! Selection: ' + ed.selection.getContent({format: 'text'}));
+ * });
+ * }
+ * });
+ */
+ addCommand: function(name, callback, scope) {
+ /**
+ * Callback function that gets called when a command is executed.
+ *
+ * @callback addCommandCallback
+ * @param {Boolean} ui Display UI state true/false.
+ * @param {Object} value Optional value for command.
+ * @return {Boolean} True/false state if the command was handled or not.
+ */
+ this.editorCommands.addCommand(name, callback, scope);
+ },
+
+ /**
+ * Adds a custom query state command to the editor, you can also override existing commands with this method.
+ * The command that you add can be executed with queryCommandState function.
+ *
+ * @method addQueryStateHandler
+ * @param {String} name Command name to add/override.
+ * @param {addQueryStateHandlerCallback} callback Function to execute when the command state retrieval occurs.
+ * @param {Object} scope Optional scope to execute the function in.
+ */
+ addQueryStateHandler: function(name, callback, scope) {
+ /**
+ * Callback function that gets called when a queryCommandState is executed.
+ *
+ * @callback addQueryStateHandlerCallback
+ * @return {Boolean} True/false state if the command is enabled or not like is it bold.
+ */
+ this.editorCommands.addQueryStateHandler(name, callback, scope);
+ },
+
+ /**
+ * Adds a custom query value command to the editor, you can also override existing commands with this method.
+ * The command that you add can be executed with queryCommandValue function.
+ *
+ * @method addQueryValueHandler
+ * @param {String} name Command name to add/override.
+ * @param {addQueryValueHandlerCallback} callback Function to execute when the command value retrieval occurs.
+ * @param {Object} scope Optional scope to execute the function in.
+ */
+ addQueryValueHandler: function(name, callback, scope) {
+ /**
+ * Callback function that gets called when a queryCommandValue is executed.
+ *
+ * @callback addQueryValueHandlerCallback
+ * @return {Object} Value of the command or undefined.
+ */
+ this.editorCommands.addQueryValueHandler(name, callback, scope);
+ },
+
+ /**
+ * Adds a keyboard shortcut for some command or function.
+ *
+ * @method addShortcut
+ * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
+ * @param {String} desc Text description for the command.
+ * @param {String/Function} cmdFunc Command name string or function to execute when the key is pressed.
+ * @param {Object} sc Optional scope to execute the function in.
+ * @return {Boolean} true/false state if the shortcut was added or not.
+ */
+ addShortcut: function(pattern, desc, cmdFunc, scope) {
+ this.shortcuts.add(pattern, desc, cmdFunc, scope);
+ },
+
+ /**
+ * Executes a command on the current instance. These commands can be TinyMCE internal commands prefixed with "mce" or
+ * they can be build in browser commands such as "Bold". A compleate list of browser commands is available on MSDN or Mozilla.org.
+ * This function will dispatch the execCommand function on each plugin, theme or the execcommand_callback option if none of these
+ * return true it will handle the command as a internal browser command.
+ *
+ * @method execCommand
+ * @param {String} cmd Command name to execute, for example mceLink or Bold.
+ * @param {Boolean} ui True/false state if a UI (dialog) should be presented or not.
+ * @param {mixed} value Optional command value, this can be anything.
+ * @param {Object} args Optional arguments object.
+ */
+ execCommand: function(cmd, ui, value, args) {
+ return this.editorCommands.execCommand(cmd, ui, value, args);
+ },
+
+ /**
+ * Returns a command specific state, for example if bold is enabled or not.
+ *
+ * @method queryCommandState
+ * @param {string} cmd Command to query state from.
+ * @return {Boolean} Command specific state, for example if bold is enabled or not.
+ */
+ queryCommandState: function(cmd) {
+ return this.editorCommands.queryCommandState(cmd);
+ },
+
+ /**
+ * Returns a command specific value, for example the current font size.
+ *
+ * @method queryCommandValue
+ * @param {string} cmd Command to query value from.
+ * @return {Object} Command specific value, for example the current font size.
+ */
+ queryCommandValue: function(cmd) {
+ return this.editorCommands.queryCommandValue(cmd);
+ },
+
+ /**
+ * Returns true/false if the command is supported or not.
+ *
+ * @method queryCommandSupported
+ * @param {String} cmd Command that we check support for.
+ * @return {Boolean} true/false if the command is supported or not.
+ */
+ queryCommandSupported: function(cmd) {
+ return this.editorCommands.queryCommandSupported(cmd);
+ },
+
+ /**
+ * Shows the editor and hides any textarea/div that the editor is supposed to replace.
+ *
+ * @method show
+ */
+ show: function() {
+ var self = this;
+
+ if (self.hidden) {
+ self.hidden = false;
+
+ if (self.inline) {
+ self.getBody().contentEditable = true;
+ } else {
+ DOM.show(self.getContainer());
+ DOM.hide(self.id);
+ }
+
+ self.load();
+ self.fire('show');
+ }
+ },
+
+ /**
+ * Hides the editor and shows any textarea/div that the editor is supposed to replace.
+ *
+ * @method hide
+ */
+ hide: function() {
+ var self = this, doc = self.getDoc();
+
+ if (!self.hidden) {
+ // Fixed bug where IE has a blinking cursor left from the editor
+ if (ie && doc && !self.inline) {
+ doc.execCommand('SelectAll');
+ }
+
+ // We must save before we hide so Safari doesn't crash
+ self.save();
+
+ if (self.inline) {
+ self.getBody().contentEditable = false;
+
+ // Make sure the editor gets blurred
+ if (self == self.editorManager.focusedEditor) {
+ self.editorManager.focusedEditor = null;
+ }
+ } else {
+ DOM.hide(self.getContainer());
+ DOM.setStyle(self.id, 'display', self.orgDisplay);
+ }
+
+ self.hidden = true;
+ self.fire('hide');
+ }
+ },
+
+ /**
+ * Returns true/false if the editor is hidden or not.
+ *
+ * @method isHidden
+ * @return {Boolean} True/false if the editor is hidden or not.
+ */
+ isHidden: function() {
+ return !!this.hidden;
+ },
+
+ /**
+ * Sets the progress state, this will display a throbber/progess for the editor.
+ * This is ideal for asynchronous operations like an AJAX save call.
+ *
+ * @method setProgressState
+ * @param {Boolean} state Boolean state if the progress should be shown or hidden.
+ * @param {Number} time Optional time to wait before the progress gets shown.
+ * @return {Boolean} Same as the input state.
+ * @example
+ * // Show progress for the active editor
+ * tinymce.activeEditor.setProgressState(true);
+ *
+ * // Hide progress for the active editor
+ * tinymce.activeEditor.setProgressState(false);
+ *
+ * // Show progress after 3 seconds
+ * tinymce.activeEditor.setProgressState(true, 3000);
+ */
+ setProgressState: function(state, time) {
+ this.fire('ProgressState', {state: state, time: time});
+ },
+
+ /**
+ * Loads contents from the textarea or div element that got converted into an editor instance.
+ * This method will move the contents from that textarea or div into the editor by using setContent
+ * so all events etc that method has will get dispatched as well.
+ *
+ * @method load
+ * @param {Object} args Optional content object, this gets passed around through the whole load process.
+ * @return {String} HTML string that got set into the editor.
+ */
+ load: function(args) {
+ var self = this, elm = self.getElement(), html;
+
+ if (elm) {
+ args = args || {};
+ args.load = true;
+
+ html = self.setContent(elm.value !== undefined ? elm.value : elm.innerHTML, args);
+ args.element = elm;
+
+ if (!args.no_events) {
+ self.fire('LoadContent', args);
+ }
+
+ args.element = elm = null;
+
+ return html;
+ }
+ },
+
+ /**
+ * Saves the contents from a editor out to the textarea or div element that got converted into an editor instance.
+ * This method will move the HTML contents from the editor into that textarea or div by getContent
+ * so all events etc that method has will get dispatched as well.
+ *
+ * @method save
+ * @param {Object} args Optional content object, this gets passed around through the whole save process.
+ * @return {String} HTML string that got set into the textarea/div.
+ */
+ save: function(args) {
+ var self = this, elm = self.getElement(), html, form;
+
+ if (!elm || !self.initialized) {
+ return;
+ }
+
+ args = args || {};
+ args.save = true;
+
+ args.element = elm;
+ html = args.content = self.getContent(args);
+
+ if (!args.no_events) {
+ self.fire('SaveContent', args);
+ }
+
+ // Always run this internal event
+ if (args.format == 'raw') {
+ self.fire('RawSaveContent', args);
+ }
+
+ html = args.content;
+
+ if (!/TEXTAREA|INPUT/i.test(elm.nodeName)) {
+ // Update DIV element when not in inline mode
+ if (!self.inline) {
+ elm.innerHTML = html;
+ }
+
+ // Update hidden form element
+ if ((form = DOM.getParent(self.id, 'form'))) {
+ each(form.elements, function(elm) {
+ if (elm.name == self.id) {
+ elm.value = html;
+ return false;
+ }
+ });
+ }
+ } else {
+ elm.value = html;
+ }
+
+ args.element = elm = null;
+
+ if (args.set_dirty !== false) {
+ self.setDirty(false);
+ }
+
+ return html;
+ },
+
+ /**
+ * Sets the specified content to the editor instance, this will cleanup the content before it gets set using
+ * the different cleanup rules options.
+ *
+ * @method setContent
+ * @param {String} content Content to set to editor, normally HTML contents but can be other formats as well.
+ * @param {Object} args Optional content object, this gets passed around through the whole set process.
+ * @return {String} HTML string that got set into the editor.
+ * @example
+ * // Sets the HTML contents of the activeEditor editor
+ * tinymce.activeEditor.setContent('some html');
+ *
+ * // Sets the raw contents of the activeEditor editor
+ * tinymce.activeEditor.setContent('some html', {format: 'raw'});
+ *
+ * // Sets the content of a specific editor (my_editor in this example)
+ * tinymce.get('my_editor').setContent(data);
+ *
+ * // Sets the bbcode contents of the activeEditor editor if the bbcode plugin was added
+ * tinymce.activeEditor.setContent('[b]some[/b] html', {format: 'bbcode'});
+ */
+ setContent: function(content, args) {
+ var self = this, body = self.getBody(), forcedRootBlockName, padd;
+
+ // Setup args object
+ args = args || {};
+ args.format = args.format || 'html';
+ args.set = true;
+ args.content = content;
+
+ // Do preprocessing
+ if (!args.no_events) {
+ self.fire('BeforeSetContent', args);
+ }
+
+ content = args.content;
+
+ // Padd empty content in Gecko and Safari. Commands will otherwise fail on the content
+ // It will also be impossible to place the caret in the editor unless there is a BR element present
+ if (content.length === 0 || /^\s+$/.test(content)) {
+ padd = ie && ie < 11 ? '' : '
';
+
+ // Todo: There is a lot more root elements that need special padding
+ // so separate this and add all of them at some point.
+ if (body.nodeName == 'TABLE') {
+ content = '| ' + padd + ' |
';
+ } else if (/^(UL|OL)$/.test(body.nodeName)) {
+ content = '' + padd + '';
+ }
+
+ forcedRootBlockName = self.settings.forced_root_block;
+
+ // Check if forcedRootBlock is configured and that the block is a valid child of the body
+ if (forcedRootBlockName && self.schema.isValidChild(body.nodeName.toLowerCase(), forcedRootBlockName.toLowerCase())) {
+ // Padd with bogus BR elements on modern browsers and IE 7 and 8 since they don't render empty P tags properly
+ content = padd;
+ content = self.dom.createHTML(forcedRootBlockName, self.settings.forced_root_block_attrs, content);
+ } else if (!ie && !content) {
+ // We need to add a BR when forced_root_block is disabled on non IE browsers to place the caret
+ content = '
';
+ }
+
+ self.dom.setHTML(body, content);
+
+ self.fire('SetContent', args);
+ } else {
+ // Parse and serialize the html
+ if (args.format !== 'raw') {
+ content = new Serializer({
+ validate: self.validate
+ }, self.schema).serialize(
+ self.parser.parse(content, {isRootContent: true})
+ );
+ }
+
+ // Set the new cleaned contents to the editor
+ args.content = trim(content);
+ self.dom.setHTML(body, args.content);
+
+ // Do post processing
+ if (!args.no_events) {
+ self.fire('SetContent', args);
+ }
+
+ // Don't normalize selection if the focused element isn't the body in
+ // content editable mode since it will steal focus otherwise
+ /*if (!self.settings.content_editable || document.activeElement === self.getBody()) {
+ self.selection.normalize();
+ }*/
+ }
+
+ return args.content;
+ },
+
+ /**
+ * Gets the content from the editor instance, this will cleanup the content before it gets returned using
+ * the different cleanup rules options.
+ *
+ * @method getContent
+ * @param {Object} args Optional content object, this gets passed around through the whole get process.
+ * @return {String} Cleaned content string, normally HTML contents.
+ * @example
+ * // Get the HTML contents of the currently active editor
+ * console.debug(tinymce.activeEditor.getContent());
+ *
+ * // Get the raw contents of the currently active editor
+ * tinymce.activeEditor.getContent({format: 'raw'});
+ *
+ * // Get content of a specific editor:
+ * tinymce.get('content id').getContent()
+ */
+ getContent: function(args) {
+ var self = this, content, body = self.getBody();
+
+ // Setup args object
+ args = args || {};
+ args.format = args.format || 'html';
+ args.get = true;
+ args.getInner = true;
+
+ // Do preprocessing
+ if (!args.no_events) {
+ self.fire('BeforeGetContent', args);
+ }
+
+ // Get raw contents or by default the cleaned contents
+ if (args.format == 'raw') {
+ content = self.serializer.getTrimmedContent();
+ } else if (args.format == 'text') {
+ content = body.innerText || body.textContent;
+ } else {
+ content = self.serializer.serialize(body, args);
+ }
+
+ // Trim whitespace in beginning/end of HTML
+ if (args.format != 'text') {
+ args.content = trim(content);
+ } else {
+ args.content = content;
+ }
+
+ // Do post processing
+ if (!args.no_events) {
+ self.fire('GetContent', args);
+ }
+
+ return args.content;
+ },
+
+ /**
+ * Inserts content at caret position.
+ *
+ * @method insertContent
+ * @param {String} content Content to insert.
+ * @param {Object} args Optional args to pass to insert call.
+ */
+ insertContent: function(content, args) {
+ if (args) {
+ content = extend({content: content}, args);
+ }
+
+ this.execCommand('mceInsertContent', false, content);
+ },
+
+ /**
+ * Returns true/false if the editor is dirty or not. It will get dirty if the user has made modifications to the contents.
+ *
+ * The dirty state is automatically set to true if you do modifications to the content in other
+ * words when new undo levels is created or if you undo/redo to update the contents of the editor. It will also be set
+ * to false if you call editor.save().
+ *
+ * @method isDirty
+ * @return {Boolean} True/false if the editor is dirty or not. It will get dirty if the user has made modifications to the contents.
+ * @example
+ * if (tinymce.activeEditor.isDirty())
+ * alert("You must save your contents.");
+ */
+ isDirty: function() {
+ return !this.isNotDirty;
+ },
+
+ /**
+ * Explicitly sets the dirty state. This will fire the dirty event if the editor dirty state is changed from false to true
+ * by invoking this method.
+ *
+ * @method setDirty
+ * @param {Boolean} state True/false if the editor is considered dirty.
+ * @example
+ * function ajaxSave() {
+ * var editor = tinymce.get('elm1');
+ *
+ * // Save contents using some XHR call
+ * alert(editor.getContent());
+ *
+ * editor.setDirty(false); // Force not dirty state
+ * }
+ */
+ setDirty: function(state) {
+ var oldState = !this.isNotDirty;
+
+ this.isNotDirty = !state;
+
+ if (state && state != oldState) {
+ this.fire('dirty');
+ }
+ },
+
+ /**
+ * Sets the editor mode. Mode can be for example "design", "code" or "readonly".
+ *
+ * @method setMode
+ * @param {String} mode Mode to set the editor in.
+ */
+ setMode: function(mode) {
+ Mode.setMode(this, mode);
+ },
+
+ /**
+ * Returns the editors container element. The container element wrappes in
+ * all the elements added to the page for the editor. Such as UI, iframe etc.
+ *
+ * @method getContainer
+ * @return {Element} HTML DOM element for the editor container.
+ */
+ getContainer: function() {
+ var self = this;
+
+ if (!self.container) {
+ self.container = DOM.get(self.editorContainer || self.id + '_parent');
+ }
+
+ return self.container;
+ },
+
+ /**
+ * Returns the editors content area container element. The this element is the one who
+ * holds the iframe or the editable element.
+ *
+ * @method getContentAreaContainer
+ * @return {Element} HTML DOM element for the editor area container.
+ */
+ getContentAreaContainer: function() {
+ return this.contentAreaContainer;
+ },
+
+ /**
+ * Returns the target element/textarea that got replaced with a TinyMCE editor instance.
+ *
+ * @method getElement
+ * @return {Element} HTML DOM element for the replaced element.
+ */
+ getElement: function() {
+ if (!this.targetElm) {
+ this.targetElm = DOM.get(this.id);
+ }
+
+ return this.targetElm;
+ },
+
+ /**
+ * Returns the iframes window object.
+ *
+ * @method getWin
+ * @return {Window} Iframe DOM window object.
+ */
+ getWin: function() {
+ var self = this, elm;
+
+ if (!self.contentWindow) {
+ elm = self.iframeElement;
+
+ if (elm) {
+ self.contentWindow = elm.contentWindow;
+ }
+ }
+
+ return self.contentWindow;
+ },
+
+ /**
+ * Returns the iframes document object.
+ *
+ * @method getDoc
+ * @return {Document} Iframe DOM document object.
+ */
+ getDoc: function() {
+ var self = this, win;
+
+ if (!self.contentDocument) {
+ win = self.getWin();
+
+ if (win) {
+ self.contentDocument = win.document;
+ }
+ }
+
+ return self.contentDocument;
+ },
+
+ /**
+ * Returns the root element of the editable area.
+ * For a non-inline iframe-based editor, returns the iframe's body element.
+ *
+ * @method getBody
+ * @return {Element} The root element of the editable area.
+ */
+ getBody: function() {
+ var doc = this.getDoc();
+ return this.bodyElement || (doc ? doc.body : null);
+ },
+
+ /**
+ * URL converter function this gets executed each time a user adds an img, a or
+ * any other element that has a URL in it. This will be called both by the DOM and HTML
+ * manipulation functions.
+ *
+ * @method convertURL
+ * @param {string} url URL to convert.
+ * @param {string} name Attribute name src, href etc.
+ * @param {string/HTMLElement} elm Tag name or HTML DOM element depending on HTML or DOM insert.
+ * @return {string} Converted URL string.
+ */
+ convertURL: function(url, name, elm) {
+ var self = this, settings = self.settings;
+
+ // Use callback instead
+ if (settings.urlconverter_callback) {
+ return self.execCallback('urlconverter_callback', url, elm, true, name);
+ }
+
+ // Don't convert link href since thats the CSS files that gets loaded into the editor also skip local file URLs
+ if (!settings.convert_urls || (elm && elm.nodeName == 'LINK') || url.indexOf('file:') === 0 || url.length === 0) {
+ return url;
+ }
+
+ // Convert to relative
+ if (settings.relative_urls) {
+ return self.documentBaseURI.toRelative(url);
+ }
+
+ // Convert to absolute
+ url = self.documentBaseURI.toAbsolute(url, settings.remove_script_host);
+
+ return url;
+ },
+
+ /**
+ * Adds visual aid for tables, anchors etc so they can be more easily edited inside the editor.
+ *
+ * @method addVisual
+ * @param {Element} elm Optional root element to loop though to find tables etc that needs the visual aid.
+ */
+ addVisual: function(elm) {
+ var self = this, settings = self.settings, dom = self.dom, cls;
+
+ elm = elm || self.getBody();
+
+ if (self.hasVisual === undefined) {
+ self.hasVisual = settings.visual;
+ }
+
+ each(dom.select('table,a', elm), function(elm) {
+ var value;
+
+ switch (elm.nodeName) {
+ case 'TABLE':
+ cls = settings.visual_table_class || 'mce-item-table';
+ value = dom.getAttrib(elm, 'border');
+
+ if ((!value || value == '0') && self.hasVisual) {
+ dom.addClass(elm, cls);
+ } else {
+ dom.removeClass(elm, cls);
+ }
+
+ return;
+
+ case 'A':
+ if (!dom.getAttrib(elm, 'href', false)) {
+ value = dom.getAttrib(elm, 'name') || elm.id;
+ cls = settings.visual_anchor_class || 'mce-item-anchor';
+
+ if (value && self.hasVisual) {
+ dom.addClass(elm, cls);
+ } else {
+ dom.removeClass(elm, cls);
+ }
+ }
+
+ return;
+ }
+ });
+
+ self.fire('VisualAid', {element: elm, hasVisual: self.hasVisual});
+ },
+
+ /**
+ * Removes the editor from the dom and tinymce collection.
+ *
+ * @method remove
+ */
+ remove: function() {
+ var self = this;
+
+ if (!self.removed) {
+ self.save();
+ self.removed = 1;
+ self.unbindAllNativeEvents();
+
+ // Remove any hidden input
+ if (self.hasHiddenInput) {
+ DOM.remove(self.getElement().nextSibling);
+ }
+
+ if (!self.inline) {
+ // IE 9 has a bug where the selection stops working if you place the
+ // caret inside the editor then remove the iframe
+ if (ie && ie < 10) {
+ self.getDoc().execCommand('SelectAll', false, null);
+ }
+
+ DOM.setStyle(self.id, 'display', self.orgDisplay);
+ self.getBody().onload = null; // Prevent #6816
+ }
+
+ self.fire('remove');
+
+ self.editorManager.remove(self);
+ DOM.remove(self.getContainer());
+ self._selectionOverrides.destroy();
+ self.editorUpload.destroy();
+ self.destroy();
+ }
+ },
+
+ /**
+ * Destroys the editor instance by removing all events, element references or other resources
+ * that could leak memory. This method will be called automatically when the page is unloaded
+ * but you can also call it directly if you know what you are doing.
+ *
+ * @method destroy
+ * @param {Boolean} automatic Optional state if the destroy is an automatic destroy or user called one.
+ */
+ destroy: function(automatic) {
+ var self = this, form;
+
+ // One time is enough
+ if (self.destroyed) {
+ return;
+ }
+
+ // If user manually calls destroy and not remove
+ // Users seems to have logic that calls destroy instead of remove
+ if (!automatic && !self.removed) {
+ self.remove();
+ return;
+ }
+
+ if (!automatic) {
+ self.editorManager.off('beforeunload', self._beforeUnload);
+
+ // Manual destroy
+ if (self.theme && self.theme.destroy) {
+ self.theme.destroy();
+ }
+
+ // Destroy controls, selection and dom
+ self.selection.destroy();
+ self.dom.destroy();
+ }
+
+ form = self.formElement;
+ if (form) {
+ if (form._mceOldSubmit) {
+ form.submit = form._mceOldSubmit;
+ form._mceOldSubmit = null;
+ }
+
+ DOM.unbind(form, 'submit reset', self.formEventDelegate);
+ }
+
+ self.contentAreaContainer = self.formElement = self.container = self.editorContainer = null;
+ self.bodyElement = self.contentDocument = self.contentWindow = null;
+ self.iframeElement = self.targetElm = null;
+
+ if (self.selection) {
+ self.selection = self.selection.win = self.selection.dom = self.selection.dom.doc = null;
+ }
+
+ self.destroyed = 1;
+ },
+
+ /**
+ * Uploads all data uri/blob uri images in the editor contents to server.
+ *
+ * @method uploadImages
+ * @param {function} callback Optional callback with images and status for each image.
+ * @return {tinymce.util.Promise} Promise instance.
+ */
+ uploadImages: function(callback) {
+ return this.editorUpload.uploadImages(callback);
+ },
+
+ // Internal functions
+
+ _scanForImages: function() {
+ return this.editorUpload.scanForImages();
+ }
+ };
+
+ extend(Editor.prototype, EditorObservable);
+
+ return Editor;
+});
+
+// Included from: js/tinymce/classes/util/I18n.js
+
+/**
+ * I18n.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * I18n class that handles translation of TinyMCE UI.
+ * Uses po style with csharp style parameters.
+ *
+ * @class tinymce.util.I18n
+ */
+define("tinymce/util/I18n", [], function() {
+ "use strict";
+
+ var data = {}, code = "en";
+
+ return {
+ /**
+ * Sets the current language code.
+ *
+ * @method setCode
+ * @param {String} newCode Current language code.
+ */
+ setCode: function(newCode) {
+ if (newCode) {
+ code = newCode;
+ this.rtl = this.data[newCode] ? this.data[newCode]._dir === 'rtl' : false;
+ }
+ },
+
+ /**
+ * Returns the current language code.
+ *
+ * @method getCode
+ * @return {String} Current language code.
+ */
+ getCode: function() {
+ return code;
+ },
+
+ /**
+ * Property gets set to true if a RTL language pack was loaded.
+ *
+ * @property rtl
+ * @type Boolean
+ */
+ rtl: false,
+
+ /**
+ * Adds translations for a specific language code.
+ *
+ * @method add
+ * @param {String} code Language code like sv_SE.
+ * @param {Array} items Name/value array with English en_US to sv_SE.
+ */
+ add: function(code, items) {
+ var langData = data[code];
+
+ if (!langData) {
+ data[code] = langData = {};
+ }
+
+ for (var name in items) {
+ langData[name] = items[name];
+ }
+
+ this.setCode(code);
+ },
+
+ /**
+ * Translates the specified text.
+ *
+ * It has a few formats:
+ * I18n.translate("Text");
+ * I18n.translate(["Text {0}/{1}", 0, 1]);
+ * I18n.translate({raw: "Raw string"});
+ *
+ * @method translate
+ * @param {String/Object/Array} text Text to translate.
+ * @return {String} String that got translated.
+ */
+ translate: function(text) {
+ var langData;
+
+ langData = data[code];
+ if (!langData) {
+ langData = {};
+ }
+
+ if (typeof text == "undefined") {
+ return text;
+ }
+
+ if (typeof text != "string" && text.raw) {
+ return text.raw;
+ }
+
+ if (text.push) {
+ var values = text.slice(1);
+
+ text = (langData[text[0]] || text[0]).replace(/\{([0-9]+)\}/g, function(match1, match2) {
+ return values[match2];
+ });
+ }
+
+ return (langData[text] || text).replace(/{context:\w+}$/, '');
+ },
+
+ data: data
+ };
+});
+
+// Included from: js/tinymce/classes/FocusManager.js
+
+/**
+ * FocusManager.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class manages the focus/blur state of the editor. This class is needed since some
+ * browsers fire false focus/blur states when the selection is moved to a UI dialog or similar.
+ *
+ * This class will fire two events focus and blur on the editor instances that got affected.
+ * It will also handle the restore of selection when the focus is lost and returned.
+ *
+ * @class tinymce.FocusManager
+ */
+define("tinymce/FocusManager", [
+ "tinymce/dom/DOMUtils",
+ "tinymce/util/Delay",
+ "tinymce/Env"
+], function(DOMUtils, Delay, Env) {
+ var selectionChangeHandler, documentFocusInHandler, documentMouseUpHandler, DOM = DOMUtils.DOM;
+
+ /**
+ * Constructs a new focus manager instance.
+ *
+ * @constructor FocusManager
+ * @param {tinymce.EditorManager} editorManager Editor manager instance to handle focus for.
+ */
+ function FocusManager(editorManager) {
+ function getActiveElement() {
+ try {
+ return document.activeElement;
+ } catch (ex) {
+ // IE sometimes fails to get the activeElement when resizing table
+ // TODO: Investigate this
+ return document.body;
+ }
+ }
+
+ // We can't store a real range on IE 11 since it gets mutated so we need to use a bookmark object
+ // TODO: Move this to a separate range utils class since it's it's logic is present in Selection as well.
+ function createBookmark(dom, rng) {
+ if (rng && rng.startContainer) {
+ // Verify that the range is within the root of the editor
+ if (!dom.isChildOf(rng.startContainer, dom.getRoot()) || !dom.isChildOf(rng.endContainer, dom.getRoot())) {
+ return;
+ }
+
+ return {
+ startContainer: rng.startContainer,
+ startOffset: rng.startOffset,
+ endContainer: rng.endContainer,
+ endOffset: rng.endOffset
+ };
+ }
+
+ return rng;
+ }
+
+ function bookmarkToRng(editor, bookmark) {
+ var rng;
+
+ if (bookmark.startContainer) {
+ rng = editor.getDoc().createRange();
+ rng.setStart(bookmark.startContainer, bookmark.startOffset);
+ rng.setEnd(bookmark.endContainer, bookmark.endOffset);
+ } else {
+ rng = bookmark;
+ }
+
+ return rng;
+ }
+
+ function isUIElement(elm) {
+ return !!DOM.getParent(elm, FocusManager.isEditorUIElement);
+ }
+
+ function registerEvents(e) {
+ var editor = e.editor;
+
+ editor.on('init', function() {
+ // Gecko/WebKit has ghost selections in iframes and IE only has one selection per browser tab
+ if (editor.inline || Env.ie) {
+ // Use the onbeforedeactivate event when available since it works better see #7023
+ if ("onbeforedeactivate" in document && Env.ie < 9) {
+ editor.dom.bind(editor.getBody(), 'beforedeactivate', function(e) {
+ if (e.target != editor.getBody()) {
+ return;
+ }
+
+ try {
+ editor.lastRng = editor.selection.getRng();
+ } catch (ex) {
+ // IE throws "Unexcpected call to method or property access" some times so lets ignore it
+ }
+ });
+ } else {
+ // On other browsers take snapshot on nodechange in inline mode since they have Ghost selections for iframes
+ editor.on('nodechange mouseup keyup', function(e) {
+ var node = getActiveElement();
+
+ // Only act on manual nodechanges
+ if (e.type == 'nodechange' && e.selectionChange) {
+ return;
+ }
+
+ // IE 11 reports active element as iframe not body of iframe
+ if (node && node.id == editor.id + '_ifr') {
+ node = editor.getBody();
+ }
+
+ if (editor.dom.isChildOf(node, editor.getBody())) {
+ editor.lastRng = editor.selection.getRng();
+ }
+ });
+ }
+
+ // Handles the issue with WebKit not retaining selection within inline document
+ // If the user releases the mouse out side the body since a mouse up event wont occur on the body
+ if (Env.webkit && !selectionChangeHandler) {
+ selectionChangeHandler = function() {
+ var activeEditor = editorManager.activeEditor;
+
+ if (activeEditor && activeEditor.selection) {
+ var rng = activeEditor.selection.getRng();
+
+ // Store when it's non collapsed
+ if (rng && !rng.collapsed) {
+ editor.lastRng = rng;
+ }
+ }
+ };
+
+ DOM.bind(document, 'selectionchange', selectionChangeHandler);
+ }
+ }
+ });
+
+ editor.on('setcontent', function() {
+ editor.lastRng = null;
+ });
+
+ // Remove last selection bookmark on mousedown see #6305
+ editor.on('mousedown', function() {
+ editor.selection.lastFocusBookmark = null;
+ });
+
+ editor.on('focusin', function() {
+ var focusedEditor = editorManager.focusedEditor, lastRng;
+
+ if (editor.selection.lastFocusBookmark) {
+ lastRng = bookmarkToRng(editor, editor.selection.lastFocusBookmark);
+ editor.selection.lastFocusBookmark = null;
+ editor.selection.setRng(lastRng);
+ }
+
+ if (focusedEditor != editor) {
+ if (focusedEditor) {
+ focusedEditor.fire('blur', {focusedEditor: editor});
+ }
+
+ editorManager.setActive(editor);
+ editorManager.focusedEditor = editor;
+ editor.fire('focus', {blurredEditor: focusedEditor});
+ editor.focus(true);
+ }
+
+ editor.lastRng = null;
+ });
+
+ editor.on('focusout', function() {
+ Delay.setEditorTimeout(editor, function() {
+ var focusedEditor = editorManager.focusedEditor;
+
+ // Still the same editor the blur was outside any editor UI
+ if (!isUIElement(getActiveElement()) && focusedEditor == editor) {
+ editor.fire('blur', {focusedEditor: null});
+ editorManager.focusedEditor = null;
+
+ // Make sure selection is valid could be invalid if the editor is blured and removed before the timeout occurs
+ if (editor.selection) {
+ editor.selection.lastFocusBookmark = null;
+ }
+ }
+ });
+ });
+
+ // Check if focus is moved to an element outside the active editor by checking if the target node
+ // isn't within the body of the activeEditor nor a UI element such as a dialog child control
+ if (!documentFocusInHandler) {
+ documentFocusInHandler = function(e) {
+ var activeEditor = editorManager.activeEditor, target;
+
+ target = e.target;
+
+ if (activeEditor && target.ownerDocument == document) {
+ // Check to make sure we have a valid selection don't update the bookmark if it's
+ // a focusin to the body of the editor see #7025
+ if (activeEditor.selection && target != activeEditor.getBody()) {
+ activeEditor.selection.lastFocusBookmark = createBookmark(activeEditor.dom, activeEditor.lastRng);
+ }
+
+ // Fire a blur event if the element isn't a UI element
+ if (target != document.body && !isUIElement(target) && editorManager.focusedEditor == activeEditor) {
+ activeEditor.fire('blur', {focusedEditor: null});
+ editorManager.focusedEditor = null;
+ }
+ }
+ };
+
+ DOM.bind(document, 'focusin', documentFocusInHandler);
+ }
+
+ // Handle edge case when user starts the selection inside the editor and releases
+ // the mouse outside the editor producing a new selection. This weird workaround is needed since
+ // Gecko doesn't have the "selectionchange" event we need to do this. Fixes: #6843
+ if (editor.inline && !documentMouseUpHandler) {
+ documentMouseUpHandler = function(e) {
+ var activeEditor = editorManager.activeEditor, dom = activeEditor.dom;
+
+ if (activeEditor.inline && dom && !dom.isChildOf(e.target, activeEditor.getBody())) {
+ var rng = activeEditor.selection.getRng();
+
+ if (!rng.collapsed) {
+ activeEditor.lastRng = rng;
+ }
+ }
+ };
+
+ DOM.bind(document, 'mouseup', documentMouseUpHandler);
+ }
+ }
+
+ function unregisterDocumentEvents(e) {
+ if (editorManager.focusedEditor == e.editor) {
+ editorManager.focusedEditor = null;
+ }
+
+ if (!editorManager.activeEditor) {
+ DOM.unbind(document, 'selectionchange', selectionChangeHandler);
+ DOM.unbind(document, 'focusin', documentFocusInHandler);
+ DOM.unbind(document, 'mouseup', documentMouseUpHandler);
+ selectionChangeHandler = documentFocusInHandler = documentMouseUpHandler = null;
+ }
+ }
+
+ editorManager.on('AddEditor', registerEvents);
+ editorManager.on('RemoveEditor', unregisterDocumentEvents);
+ }
+
+ /**
+ * Returns true if the specified element is part of the UI for example an button or text input.
+ *
+ * @method isEditorUIElement
+ * @param {Element} elm Element to check if it's part of the UI or not.
+ * @return {Boolean} True/false state if the element is part of the UI or not.
+ */
+ FocusManager.isEditorUIElement = function(elm) {
+ // Needs to be converted to string since svg can have focus: #6776
+ return elm.className.toString().indexOf('mce-') !== -1;
+ };
+
+ return FocusManager;
+});
+
+// Included from: js/tinymce/classes/EditorManager.js
+
+/**
+ * EditorManager.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class used as a factory for manager for tinymce.Editor instances.
+ *
+ * @example
+ * tinymce.EditorManager.init({});
+ *
+ * @class tinymce.EditorManager
+ * @mixes tinymce.util.Observable
+ * @static
+ */
+define("tinymce/EditorManager", [
+ "tinymce/Editor",
+ "tinymce/dom/DomQuery",
+ "tinymce/dom/DOMUtils",
+ "tinymce/util/URI",
+ "tinymce/Env",
+ "tinymce/util/Tools",
+ "tinymce/util/Promise",
+ "tinymce/util/Observable",
+ "tinymce/util/I18n",
+ "tinymce/FocusManager"
+], function(Editor, $, DOMUtils, URI, Env, Tools, Promise, Observable, I18n, FocusManager) {
+ var DOM = DOMUtils.DOM;
+ var explode = Tools.explode, each = Tools.each, extend = Tools.extend;
+ var instanceCounter = 0, beforeUnloadDelegate, EditorManager, boundGlobalEvents = false;
+
+ function globalEventDelegate(e) {
+ each(EditorManager.editors, function(editor) {
+ if (e.type === 'scroll') {
+ editor.fire('ScrollWindow', e);
+ } else {
+ editor.fire('ResizeWindow', e);
+ }
+ });
+ }
+
+ function toggleGlobalEvents(editors, state) {
+ if (state !== boundGlobalEvents) {
+ if (state) {
+ $(window).on('resize scroll', globalEventDelegate);
+ } else {
+ $(window).off('resize scroll', globalEventDelegate);
+ }
+
+ boundGlobalEvents = state;
+ }
+ }
+
+ function removeEditorFromList(editor) {
+ var editors = EditorManager.editors, removedFromList;
+
+ delete editors[editor.id];
+
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i] == editor) {
+ editors.splice(i, 1);
+ removedFromList = true;
+ break;
+ }
+ }
+
+ // Select another editor since the active one was removed
+ if (EditorManager.activeEditor == editor) {
+ EditorManager.activeEditor = editors[0];
+ }
+
+ // Clear focusedEditor if necessary, so that we don't try to blur the destroyed editor
+ if (EditorManager.focusedEditor == editor) {
+ EditorManager.focusedEditor = null;
+ }
+
+ return removedFromList;
+ }
+
+ function purgeDestroyedEditor(editor) {
+ // User has manually destroyed the editor lets clean up the mess
+ if (editor && editor.initialized && !(editor.getContainer() || editor.getBody()).parentNode) {
+ removeEditorFromList(editor);
+ editor.unbindAllNativeEvents();
+ editor.destroy(true);
+ editor.removed = true;
+ editor = null;
+ }
+
+ return editor;
+ }
+
+ EditorManager = {
+ /**
+ * Dom query instance.
+ *
+ * @property $
+ * @type tinymce.dom.DomQuery
+ */
+ $: $,
+
+ /**
+ * Major version of TinyMCE build.
+ *
+ * @property majorVersion
+ * @type String
+ */
+ majorVersion: '4',
+
+ /**
+ * Minor version of TinyMCE build.
+ *
+ * @property minorVersion
+ * @type String
+ */
+ minorVersion: '4.3',
+
+ /**
+ * Release date of TinyMCE build.
+ *
+ * @property releaseDate
+ * @type String
+ */
+ releaseDate: '2016-09-01',
+
+ /**
+ * Collection of editor instances.
+ *
+ * @property editors
+ * @type Object
+ * @example
+ * for (edId in tinymce.editors)
+ * tinymce.editors[edId].save();
+ */
+ editors: [],
+
+ /**
+ * Collection of language pack data.
+ *
+ * @property i18n
+ * @type Object
+ */
+ i18n: I18n,
+
+ /**
+ * Currently active editor instance.
+ *
+ * @property activeEditor
+ * @type tinymce.Editor
+ * @example
+ * tinyMCE.activeEditor.selection.getContent();
+ * tinymce.EditorManager.activeEditor.selection.getContent();
+ */
+ activeEditor: null,
+
+ setup: function() {
+ var self = this, baseURL, documentBaseURL, suffix = "", preInit, src;
+
+ // Get base URL for the current document
+ documentBaseURL = URI.getDocumentBaseUrl(document.location);
+
+ // Check if the URL is a document based format like: http://site/dir/file and file:///
+ // leave other formats like applewebdata://... intact
+ if (/^[^:]+:\/\/\/?[^\/]+\//.test(documentBaseURL)) {
+ documentBaseURL = documentBaseURL.replace(/[\?#].*$/, '').replace(/[\/\\][^\/]+$/, '');
+
+ if (!/[\/\\]$/.test(documentBaseURL)) {
+ documentBaseURL += '/';
+ }
+ }
+
+ // If tinymce is defined and has a base use that or use the old tinyMCEPreInit
+ preInit = window.tinymce || window.tinyMCEPreInit;
+ if (preInit) {
+ baseURL = preInit.base || preInit.baseURL;
+ suffix = preInit.suffix;
+ } else {
+ // Get base where the tinymce script is located
+ var scripts = document.getElementsByTagName('script');
+ for (var i = 0; i < scripts.length; i++) {
+ src = scripts[i].src;
+
+ // Script types supported:
+ // tinymce.js tinymce.min.js tinymce.dev.js
+ // tinymce.jquery.js tinymce.jquery.min.js tinymce.jquery.dev.js
+ // tinymce.full.js tinymce.full.min.js tinymce.full.dev.js
+ var srcScript = src.substring(src.lastIndexOf('/'));
+ if (/tinymce(\.full|\.jquery|)(\.min|\.dev|)\.js/.test(src)) {
+ if (srcScript.indexOf('.min') != -1) {
+ suffix = '.min';
+ }
+
+ baseURL = src.substring(0, src.lastIndexOf('/'));
+ break;
+ }
+ }
+
+ // We didn't find any baseURL by looking at the script elements
+ // Try to use the document.currentScript as a fallback
+ if (!baseURL && document.currentScript) {
+ src = document.currentScript.src;
+
+ if (src.indexOf('.min') != -1) {
+ suffix = '.min';
+ }
+
+ baseURL = src.substring(0, src.lastIndexOf('/'));
+ }
+ }
+
+ /**
+ * Base URL where the root directory if TinyMCE is located.
+ *
+ * @property baseURL
+ * @type String
+ */
+ self.baseURL = new URI(documentBaseURL).toAbsolute(baseURL);
+
+ /**
+ * Document base URL where the current document is located.
+ *
+ * @property documentBaseURL
+ * @type String
+ */
+ self.documentBaseURL = documentBaseURL;
+
+ /**
+ * Absolute baseURI for the installation path of TinyMCE.
+ *
+ * @property baseURI
+ * @type tinymce.util.URI
+ */
+ self.baseURI = new URI(self.baseURL);
+
+ /**
+ * Current suffix to add to each plugin/theme that gets loaded for example ".min".
+ *
+ * @property suffix
+ * @type String
+ */
+ self.suffix = suffix;
+
+ self.focusManager = new FocusManager(self);
+ },
+
+ /**
+ * Overrides the default settings for editor instances.
+ *
+ * @method overrideDefaults
+ * @param {Object} defaultSettings Defaults settings object.
+ */
+ overrideDefaults: function(defaultSettings) {
+ var baseUrl, suffix;
+
+ baseUrl = defaultSettings.base_url;
+ if (baseUrl) {
+ this.baseURL = new URI(this.documentBaseURL).toAbsolute(baseUrl.replace(/\/+$/, ''));
+ this.baseURI = new URI(this.baseURL);
+ }
+
+ suffix = defaultSettings.suffix;
+ if (defaultSettings.suffix) {
+ this.suffix = suffix;
+ }
+
+ this.defaultSettings = defaultSettings;
+ },
+
+ /**
+ * Initializes a set of editors. This method will create editors based on various settings.
+ *
+ * @method init
+ * @param {Object} settings Settings object to be passed to each editor instance.
+ * @return {tinymce.util.Promise} Promise that gets resolved with an array of editors when all editor instances are initialized.
+ * @example
+ * // Initializes a editor using the longer method
+ * tinymce.EditorManager.init({
+ * some_settings : 'some value'
+ * });
+ *
+ * // Initializes a editor instance using the shorter version and with a promise
+ * tinymce.init({
+ * some_settings : 'some value'
+ * }).then(function(editors) {
+ * ...
+ * });
+ */
+ init: function(settings) {
+ var self = this, result, invalidInlineTargets;
+
+ invalidInlineTargets = Tools.makeMap(
+ 'area base basefont br col frame hr img input isindex link meta param embed source wbr track ' +
+ 'colgroup option tbody tfoot thead tr script noscript style textarea video audio iframe object menu',
+ ' '
+ );
+
+ function isInvalidInlineTarget(settings, elm) {
+ return settings.inline && elm.tagName.toLowerCase() in invalidInlineTargets;
+ }
+
+ function report(msg, elm) {
+ // Log in a non test environment
+ if (window.console && !window.test) {
+ window.console.log(msg, elm);
+ }
+ }
+
+ function createId(elm) {
+ var id = elm.id;
+
+ // Use element id, or unique name or generate a unique id
+ if (!id) {
+ id = elm.name;
+
+ if (id && !DOM.get(id)) {
+ id = elm.name;
+ } else {
+ // Generate unique name
+ id = DOM.uniqueId();
+ }
+
+ elm.setAttribute('id', id);
+ }
+
+ return id;
+ }
+
+ function execCallback(name) {
+ var callback = settings[name];
+
+ if (!callback) {
+ return;
+ }
+
+ return callback.apply(self, Array.prototype.slice.call(arguments, 2));
+ }
+
+ function hasClass(elm, className) {
+ return className.constructor === RegExp ? className.test(elm.className) : DOM.hasClass(elm, className);
+ }
+
+ function findTargets(settings) {
+ var l, targets = [];
+
+ if (settings.types) {
+ each(settings.types, function(type) {
+ targets = targets.concat(DOM.select(type.selector));
+ });
+
+ return targets;
+ } else if (settings.selector) {
+ return DOM.select(settings.selector);
+ } else if (settings.target) {
+ return [settings.target];
+ }
+
+ // Fallback to old setting
+ switch (settings.mode) {
+ case "exact":
+ l = settings.elements || '';
+
+ if (l.length > 0) {
+ each(explode(l), function(id) {
+ var elm;
+
+ if ((elm = DOM.get(id))) {
+ targets.push(elm);
+ } else {
+ each(document.forms, function(f) {
+ each(f.elements, function(e) {
+ if (e.name === id) {
+ id = 'mce_editor_' + instanceCounter++;
+ DOM.setAttrib(e, 'id', id);
+ targets.push(e);
+ }
+ });
+ });
+ }
+ });
+ }
+ break;
+
+ case "textareas":
+ case "specific_textareas":
+ each(DOM.select('textarea'), function(elm) {
+ if (settings.editor_deselector && hasClass(elm, settings.editor_deselector)) {
+ return;
+ }
+
+ if (!settings.editor_selector || hasClass(elm, settings.editor_selector)) {
+ targets.push(elm);
+ }
+ });
+ break;
+ }
+
+ return targets;
+ }
+
+ var provideResults = function(editors) {
+ result = editors;
+ };
+
+ function initEditors() {
+ var initCount = 0, editors = [], targets;
+
+ function createEditor(id, settings, targetElm) {
+ var editor = new Editor(id, settings, self);
+
+ editors.push(editor);
+
+ editor.on('init', function() {
+ if (++initCount === targets.length) {
+ provideResults(editors);
+ }
+ });
+
+ editor.targetElm = editor.targetElm || targetElm;
+ editor.render();
+ }
+
+ DOM.unbind(window, 'ready', initEditors);
+ execCallback('onpageload');
+
+ targets = $.unique(findTargets(settings));
+
+ // TODO: Deprecate this one
+ if (settings.types) {
+ each(settings.types, function(type) {
+ Tools.each(targets, function(elm) {
+ if (DOM.is(elm, type.selector)) {
+ createEditor(createId(elm), extend({}, settings, type), elm);
+ return false;
+ }
+
+ return true;
+ });
+ });
+
+ return;
+ }
+
+ Tools.each(targets, function(elm) {
+ purgeDestroyedEditor(self.get(elm.id));
+ });
+
+ targets = Tools.grep(targets, function(elm) {
+ return !self.get(elm.id);
+ });
+
+ each(targets, function(elm) {
+ if (isInvalidInlineTarget(settings, elm)) {
+ report('Could not initialize inline editor on invalid inline target element', elm);
+ } else {
+ createEditor(createId(elm), settings, elm);
+ }
+ });
+ }
+
+ self.settings = settings;
+ DOM.bind(window, 'ready', initEditors);
+
+ return new Promise(function(resolve) {
+ if (result) {
+ resolve(result);
+ } else {
+ provideResults = function(editors) {
+ resolve(editors);
+ };
+ }
+ });
+ },
+
+ /**
+ * Returns a editor instance by id.
+ *
+ * @method get
+ * @param {String/Number} id Editor instance id or index to return.
+ * @return {tinymce.Editor} Editor instance to return.
+ * @example
+ * // Adds an onclick event to an editor by id (shorter version)
+ * tinymce.get('mytextbox').on('click', function(e) {
+ * ed.windowManager.alert('Hello world!');
+ * });
+ *
+ * // Adds an onclick event to an editor by id (longer version)
+ * tinymce.EditorManager.get('mytextbox').on('click', function(e) {
+ * ed.windowManager.alert('Hello world!');
+ * });
+ */
+ get: function(id) {
+ if (!arguments.length) {
+ return this.editors;
+ }
+
+ return id in this.editors ? this.editors[id] : null;
+ },
+
+ /**
+ * Adds an editor instance to the editor collection. This will also set it as the active editor.
+ *
+ * @method add
+ * @param {tinymce.Editor} editor Editor instance to add to the collection.
+ * @return {tinymce.Editor} The same instance that got passed in.
+ */
+ add: function(editor) {
+ var self = this, editors = self.editors;
+
+ // Add named and index editor instance
+ editors[editor.id] = editor;
+ editors.push(editor);
+
+ toggleGlobalEvents(editors, true);
+
+ // Doesn't call setActive method since we don't want
+ // to fire a bunch of activate/deactivate calls while initializing
+ self.activeEditor = editor;
+
+ /**
+ * Fires when an editor is added to the EditorManager collection.
+ *
+ * @event AddEditor
+ * @param {Object} e Event arguments.
+ */
+ self.fire('AddEditor', {editor: editor});
+
+ if (!beforeUnloadDelegate) {
+ beforeUnloadDelegate = function() {
+ self.fire('BeforeUnload');
+ };
+
+ DOM.bind(window, 'beforeunload', beforeUnloadDelegate);
+ }
+
+ return editor;
+ },
+
+ /**
+ * Creates an editor instance and adds it to the EditorManager collection.
+ *
+ * @method createEditor
+ * @param {String} id Instance id to use for editor.
+ * @param {Object} settings Editor instance settings.
+ * @return {tinymce.Editor} Editor instance that got created.
+ */
+ createEditor: function(id, settings) {
+ return this.add(new Editor(id, settings, this));
+ },
+
+ /**
+ * Removes a editor or editors form page.
+ *
+ * @example
+ * // Remove all editors bound to divs
+ * tinymce.remove('div');
+ *
+ * // Remove all editors bound to textareas
+ * tinymce.remove('textarea');
+ *
+ * // Remove all editors
+ * tinymce.remove();
+ *
+ * // Remove specific instance by id
+ * tinymce.remove('#id');
+ *
+ * @method remove
+ * @param {tinymce.Editor/String/Object} [selector] CSS selector or editor instance to remove.
+ * @return {tinymce.Editor} The editor that got passed in will be return if it was found otherwise null.
+ */
+ remove: function(selector) {
+ var self = this, i, editors = self.editors, editor;
+
+ // Remove all editors
+ if (!selector) {
+ for (i = editors.length - 1; i >= 0; i--) {
+ self.remove(editors[i]);
+ }
+
+ return;
+ }
+
+ // Remove editors by selector
+ if (typeof selector == "string") {
+ selector = selector.selector || selector;
+
+ each(DOM.select(selector), function(elm) {
+ editor = editors[elm.id];
+
+ if (editor) {
+ self.remove(editor);
+ }
+ });
+
+ return;
+ }
+
+ // Remove specific editor
+ editor = selector;
+
+ // Not in the collection
+ if (!editors[editor.id]) {
+ return null;
+ }
+
+ /**
+ * Fires when an editor is removed from EditorManager collection.
+ *
+ * @event RemoveEditor
+ * @param {Object} e Event arguments.
+ */
+ if (removeEditorFromList(editor)) {
+ self.fire('RemoveEditor', {editor: editor});
+ }
+
+ if (!editors.length) {
+ DOM.unbind(window, 'beforeunload', beforeUnloadDelegate);
+ }
+
+ editor.remove();
+
+ toggleGlobalEvents(editors, editors.length > 0);
+
+ return editor;
+ },
+
+ /**
+ * Executes a specific command on the currently active editor.
+ *
+ * @method execCommand
+ * @param {String} cmd Command to perform for example Bold.
+ * @param {Boolean} ui Optional boolean state if a UI should be presented for the command or not.
+ * @param {String} value Optional value parameter like for example an URL to a link.
+ * @return {Boolean} true/false if the command was executed or not.
+ */
+ execCommand: function(cmd, ui, value) {
+ var self = this, editor = self.get(value);
+
+ // Manager commands
+ switch (cmd) {
+ case "mceAddEditor":
+ if (!self.get(value)) {
+ new Editor(value, self.settings, self).render();
+ }
+
+ return true;
+
+ case "mceRemoveEditor":
+ if (editor) {
+ editor.remove();
+ }
+
+ return true;
+
+ case 'mceToggleEditor':
+ if (!editor) {
+ self.execCommand('mceAddEditor', 0, value);
+ return true;
+ }
+
+ if (editor.isHidden()) {
+ editor.show();
+ } else {
+ editor.hide();
+ }
+
+ return true;
+ }
+
+ // Run command on active editor
+ if (self.activeEditor) {
+ return self.activeEditor.execCommand(cmd, ui, value);
+ }
+
+ return false;
+ },
+
+ /**
+ * Calls the save method on all editor instances in the collection. This can be useful when a form is to be submitted.
+ *
+ * @method triggerSave
+ * @example
+ * // Saves all contents
+ * tinyMCE.triggerSave();
+ */
+ triggerSave: function() {
+ each(this.editors, function(editor) {
+ editor.save();
+ });
+ },
+
+ /**
+ * Adds a language pack, this gets called by the loaded language files like en.js.
+ *
+ * @method addI18n
+ * @param {String} code Optional language code.
+ * @param {Object} items Name/value object with translations.
+ */
+ addI18n: function(code, items) {
+ I18n.add(code, items);
+ },
+
+ /**
+ * Translates the specified string using the language pack items.
+ *
+ * @method translate
+ * @param {String/Array/Object} text String to translate
+ * @return {String} Translated string.
+ */
+ translate: function(text) {
+ return I18n.translate(text);
+ },
+
+ /**
+ * Sets the active editor instance and fires the deactivate/activate events.
+ *
+ * @method setActive
+ * @param {tinymce.Editor} editor Editor instance to set as the active instance.
+ */
+ setActive: function(editor) {
+ var activeEditor = this.activeEditor;
+
+ if (this.activeEditor != editor) {
+ if (activeEditor) {
+ activeEditor.fire('deactivate', {relatedTarget: editor});
+ }
+
+ editor.fire('activate', {relatedTarget: activeEditor});
+ }
+
+ this.activeEditor = editor;
+ }
+ };
+
+ extend(EditorManager, Observable);
+
+ EditorManager.setup();
+
+ // Export EditorManager as tinymce/tinymce in global namespace
+ window.tinymce = window.tinyMCE = EditorManager;
+
+ return EditorManager;
+});
+
+// Included from: js/tinymce/classes/LegacyInput.js
+
+/**
+ * LegacyInput.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Converts legacy input to modern HTML.
+ *
+ * @class tinymce.LegacyInput
+ * @private
+ */
+define("tinymce/LegacyInput", [
+ "tinymce/EditorManager",
+ "tinymce/util/Tools"
+], function(EditorManager, Tools) {
+ var each = Tools.each, explode = Tools.explode;
+
+ EditorManager.on('AddEditor', function(e) {
+ var editor = e.editor;
+
+ editor.on('preInit', function() {
+ var filters, fontSizes, dom, settings = editor.settings;
+
+ function replaceWithSpan(node, styles) {
+ each(styles, function(value, name) {
+ if (value) {
+ dom.setStyle(node, name, value);
+ }
+ });
+
+ dom.rename(node, 'span');
+ }
+
+ function convert(e) {
+ dom = editor.dom;
+
+ if (settings.convert_fonts_to_spans) {
+ each(dom.select('font,u,strike', e.node), function(node) {
+ filters[node.nodeName.toLowerCase()](dom, node);
+ });
+ }
+ }
+
+ if (settings.inline_styles) {
+ fontSizes = explode(settings.font_size_legacy_values);
+
+ filters = {
+ font: function(dom, node) {
+ replaceWithSpan(node, {
+ backgroundColor: node.style.backgroundColor,
+ color: node.color,
+ fontFamily: node.face,
+ fontSize: fontSizes[parseInt(node.size, 10) - 1]
+ });
+ },
+
+ u: function(dom, node) {
+ // HTML5 allows U element
+ if (editor.settings.schema === "html4") {
+ replaceWithSpan(node, {
+ textDecoration: 'underline'
+ });
+ }
+ },
+
+ strike: function(dom, node) {
+ replaceWithSpan(node, {
+ textDecoration: 'line-through'
+ });
+ }
+ };
+
+ editor.on('PreProcess SetContent', convert);
+ }
+ });
+ });
+});
+
+// Included from: js/tinymce/classes/util/XHR.js
+
+/**
+ * XHR.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class enables you to send XMLHTTPRequests cross browser.
+ * @class tinymce.util.XHR
+ * @mixes tinymce.util.Observable
+ * @static
+ * @example
+ * // Sends a low level Ajax request
+ * tinymce.util.XHR.send({
+ * url: 'someurl',
+ * success: function(text) {
+ * console.debug(text);
+ * }
+ * });
+ *
+ * // Add custom header to XHR request
+ * tinymce.util.XHR.on('beforeSend', function(e) {
+ * e.xhr.setRequestHeader('X-Requested-With', 'Something');
+ * });
+ */
+define("tinymce/util/XHR", [
+ "tinymce/util/Observable",
+ "tinymce/util/Tools"
+], function(Observable, Tools) {
+ var XHR = {
+ /**
+ * Sends a XMLHTTPRequest.
+ * Consult the Wiki for details on what settings this method takes.
+ *
+ * @method send
+ * @param {Object} settings Object will target URL, callbacks and other info needed to make the request.
+ */
+ send: function(settings) {
+ var xhr, count = 0;
+
+ function ready() {
+ if (!settings.async || xhr.readyState == 4 || count++ > 10000) {
+ if (settings.success && count < 10000 && xhr.status == 200) {
+ settings.success.call(settings.success_scope, '' + xhr.responseText, xhr, settings);
+ } else if (settings.error) {
+ settings.error.call(settings.error_scope, count > 10000 ? 'TIMED_OUT' : 'GENERAL', xhr, settings);
+ }
+
+ xhr = null;
+ } else {
+ setTimeout(ready, 10);
+ }
+ }
+
+ // Default settings
+ settings.scope = settings.scope || this;
+ settings.success_scope = settings.success_scope || settings.scope;
+ settings.error_scope = settings.error_scope || settings.scope;
+ settings.async = settings.async === false ? false : true;
+ settings.data = settings.data || '';
+
+ XHR.fire('beforeInitialize', {settings: settings});
+
+ xhr = new XMLHttpRequest();
+
+ if (xhr) {
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType(settings.content_type);
+ }
+
+ xhr.open(settings.type || (settings.data ? 'POST' : 'GET'), settings.url, settings.async);
+
+ if (settings.crossDomain) {
+ xhr.withCredentials = true;
+ }
+
+ if (settings.content_type) {
+ xhr.setRequestHeader('Content-Type', settings.content_type);
+ }
+
+ if (settings.requestheaders) {
+ Tools.each(settings.requestheaders, function(header) {
+ xhr.setRequestHeader(header.key, header.value);
+ });
+ }
+
+ xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+
+ xhr = XHR.fire('beforeSend', {xhr: xhr, settings: settings}).xhr;
+ xhr.send(settings.data);
+
+ // Syncronous request
+ if (!settings.async) {
+ return ready();
+ }
+
+ // Wait for response, onReadyStateChange can not be used since it leaks memory in IE
+ setTimeout(ready, 10);
+ }
+ }
+ };
+
+ Tools.extend(XHR, Observable);
+
+ return XHR;
+});
+
+// Included from: js/tinymce/classes/util/JSON.js
+
+/**
+ * JSON.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * JSON parser and serializer class.
+ *
+ * @class tinymce.util.JSON
+ * @static
+ * @example
+ * // JSON parse a string into an object
+ * var obj = tinymce.util.JSON.parse(somestring);
+ *
+ * // JSON serialize a object into an string
+ * var str = tinymce.util.JSON.serialize(obj);
+ */
+define("tinymce/util/JSON", [], function() {
+ function serialize(o, quote) {
+ var i, v, t, name;
+
+ quote = quote || '"';
+
+ if (o === null) {
+ return 'null';
+ }
+
+ t = typeof o;
+
+ if (t == 'string') {
+ v = '\bb\tt\nn\ff\rr\""\'\'\\\\';
+
+ /*eslint no-control-regex:0 */
+ return quote + o.replace(/([\u0080-\uFFFF\x00-\x1f\"\'\\])/g, function(a, b) {
+ // Make sure single quotes never get encoded inside double quotes for JSON compatibility
+ if (quote === '"' && a === "'") {
+ return a;
+ }
+
+ i = v.indexOf(b);
+
+ if (i + 1) {
+ return '\\' + v.charAt(i + 1);
+ }
+
+ a = b.charCodeAt().toString(16);
+
+ return '\\u' + '0000'.substring(a.length) + a;
+ }) + quote;
+ }
+
+ if (t == 'object') {
+ if (o.hasOwnProperty && Object.prototype.toString.call(o) === '[object Array]') {
+ for (i = 0, v = '['; i < o.length; i++) {
+ v += (i > 0 ? ',' : '') + serialize(o[i], quote);
+ }
+
+ return v + ']';
+ }
+
+ v = '{';
+
+ for (name in o) {
+ if (o.hasOwnProperty(name)) {
+ v += typeof o[name] != 'function' ? (v.length > 1 ? ',' + quote : quote) + name +
+ quote + ':' + serialize(o[name], quote) : '';
+ }
+ }
+
+ return v + '}';
+ }
+
+ return '' + o;
+ }
+
+ return {
+ /**
+ * Serializes the specified object as a JSON string.
+ *
+ * @method serialize
+ * @param {Object} obj Object to serialize as a JSON string.
+ * @param {String} quote Optional quote string defaults to ".
+ * @return {string} JSON string serialized from input.
+ */
+ serialize: serialize,
+
+ /**
+ * Unserializes/parses the specified JSON string into a object.
+ *
+ * @method parse
+ * @param {string} s JSON String to parse into a JavaScript object.
+ * @return {Object} Object from input JSON string or undefined if it failed.
+ */
+ parse: function(text) {
+ try {
+ // Trick uglify JS
+ return window[String.fromCharCode(101) + 'val']('(' + text + ')');
+ } catch (ex) {
+ // Ignore
+ }
+ }
+
+ /**#@-*/
+ };
+});
+
+// Included from: js/tinymce/classes/util/JSONRequest.js
+
+/**
+ * JSONRequest.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class enables you to use JSON-RPC to call backend methods.
+ *
+ * @class tinymce.util.JSONRequest
+ * @example
+ * var json = new tinymce.util.JSONRequest({
+ * url: 'somebackend.php'
+ * });
+ *
+ * // Send RPC call 1
+ * json.send({
+ * method: 'someMethod1',
+ * params: ['a', 'b'],
+ * success: function(result) {
+ * console.dir(result);
+ * }
+ * });
+ *
+ * // Send RPC call 2
+ * json.send({
+ * method: 'someMethod2',
+ * params: ['a', 'b'],
+ * success: function(result) {
+ * console.dir(result);
+ * }
+ * });
+ */
+define("tinymce/util/JSONRequest", [
+ "tinymce/util/JSON",
+ "tinymce/util/XHR",
+ "tinymce/util/Tools"
+], function(JSON, XHR, Tools) {
+ var extend = Tools.extend;
+
+ function JSONRequest(settings) {
+ this.settings = extend({}, settings);
+ this.count = 0;
+ }
+
+ /**
+ * Simple helper function to send a JSON-RPC request without the need to initialize an object.
+ * Consult the Wiki API documentation for more details on what you can pass to this function.
+ *
+ * @method sendRPC
+ * @static
+ * @param {Object} o Call object where there are three field id, method and params this object should also contain callbacks etc.
+ */
+ JSONRequest.sendRPC = function(o) {
+ return new JSONRequest().send(o);
+ };
+
+ JSONRequest.prototype = {
+ /**
+ * Sends a JSON-RPC call. Consult the Wiki API documentation for more details on what you can pass to this function.
+ *
+ * @method send
+ * @param {Object} args Call object where there are three field id, method and params this object should also contain callbacks etc.
+ */
+ send: function(args) {
+ var ecb = args.error, scb = args.success;
+
+ args = extend(this.settings, args);
+
+ args.success = function(c, x) {
+ c = JSON.parse(c);
+
+ if (typeof c == 'undefined') {
+ c = {
+ error: 'JSON Parse error.'
+ };
+ }
+
+ if (c.error) {
+ ecb.call(args.error_scope || args.scope, c.error, x);
+ } else {
+ scb.call(args.success_scope || args.scope, c.result);
+ }
+ };
+
+ args.error = function(ty, x) {
+ if (ecb) {
+ ecb.call(args.error_scope || args.scope, ty, x);
+ }
+ };
+
+ args.data = JSON.serialize({
+ id: args.id || 'c' + (this.count++),
+ method: args.method,
+ params: args.params
+ });
+
+ // JSON content type for Ruby on rails. Bug: #1883287
+ args.content_type = 'application/json';
+
+ XHR.send(args);
+ }
+ };
+
+ return JSONRequest;
+});
+
+// Included from: js/tinymce/classes/util/JSONP.js
+
+/**
+ * JSONP.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+define("tinymce/util/JSONP", [
+ "tinymce/dom/DOMUtils"
+], function(DOMUtils) {
+ return {
+ callbacks: {},
+ count: 0,
+
+ send: function(settings) {
+ var self = this, dom = DOMUtils.DOM, count = settings.count !== undefined ? settings.count : self.count;
+ var id = 'tinymce_jsonp_' + count;
+
+ self.callbacks[count] = function(json) {
+ dom.remove(id);
+ delete self.callbacks[count];
+
+ settings.callback(json);
+ };
+
+ dom.add(dom.doc.body, 'script', {
+ id: id,
+ src: settings.url,
+ type: 'text/javascript'
+ });
+
+ self.count++;
+ }
+ };
+});
+
+// Included from: js/tinymce/classes/util/LocalStorage.js
+
+/**
+ * LocalStorage.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class will simulate LocalStorage on IE 7 and return the native version on modern browsers.
+ * Storage is done using userData on IE 7 and a special serialization format. The format is designed
+ * to be as small as possible by making sure that the keys and values doesn't need to be encoded. This
+ * makes it possible to store for example HTML data.
+ *
+ * Storage format for userData:
+ * ,,,,...
+ *
+ * For example this data key1=value1,key2=value2 would be:
+ * 4,key1,6,value1,4,key2,6,value2
+ *
+ * @class tinymce.util.LocalStorage
+ * @static
+ * @version 4.0
+ * @example
+ * tinymce.util.LocalStorage.setItem('key', 'value');
+ * var value = tinymce.util.LocalStorage.getItem('key');
+ */
+define("tinymce/util/LocalStorage", [], function() {
+ var LocalStorage, storageElm, items, keys, userDataKey, hasOldIEDataSupport;
+
+ // Check for native support
+ try {
+ if (window.localStorage) {
+ return localStorage;
+ }
+ } catch (ex) {
+ // Ignore
+ }
+
+ userDataKey = "tinymce";
+ storageElm = document.documentElement;
+ hasOldIEDataSupport = !!storageElm.addBehavior;
+
+ if (hasOldIEDataSupport) {
+ storageElm.addBehavior('#default#userData');
+ }
+
+ /**
+ * Gets the keys names and updates LocalStorage.length property. Since IE7 doesn't have any getters/setters.
+ */
+ function updateKeys() {
+ keys = [];
+
+ for (var key in items) {
+ keys.push(key);
+ }
+
+ LocalStorage.length = keys.length;
+ }
+
+ /**
+ * Loads the userData string and parses it into the items structure.
+ */
+ function load() {
+ var key, data, value, pos = 0;
+
+ items = {};
+
+ // localStorage can be disabled on WebKit/Gecko so make a dummy storage
+ if (!hasOldIEDataSupport) {
+ return;
+ }
+
+ function next(end) {
+ var value, nextPos;
+
+ nextPos = end !== undefined ? pos + end : data.indexOf(',', pos);
+ if (nextPos === -1 || nextPos > data.length) {
+ return null;
+ }
+
+ value = data.substring(pos, nextPos);
+ pos = nextPos + 1;
+
+ return value;
+ }
+
+ storageElm.load(userDataKey);
+ data = storageElm.getAttribute(userDataKey) || '';
+
+ do {
+ var offset = next();
+ if (offset === null) {
+ break;
+ }
+
+ key = next(parseInt(offset, 32) || 0);
+ if (key !== null) {
+ offset = next();
+ if (offset === null) {
+ break;
+ }
+
+ value = next(parseInt(offset, 32) || 0);
+
+ if (key) {
+ items[key] = value;
+ }
+ }
+ } while (key !== null);
+
+ updateKeys();
+ }
+
+ /**
+ * Saves the items structure into a the userData format.
+ */
+ function save() {
+ var value, data = '';
+
+ // localStorage can be disabled on WebKit/Gecko so make a dummy storage
+ if (!hasOldIEDataSupport) {
+ return;
+ }
+
+ for (var key in items) {
+ value = items[key];
+ data += (data ? ',' : '') + key.length.toString(32) + ',' + key + ',' + value.length.toString(32) + ',' + value;
+ }
+
+ storageElm.setAttribute(userDataKey, data);
+
+ try {
+ storageElm.save(userDataKey);
+ } catch (ex) {
+ // Ignore disk full
+ }
+
+ updateKeys();
+ }
+
+ LocalStorage = {
+ /**
+ * Length of the number of items in storage.
+ *
+ * @property length
+ * @type Number
+ * @return {Number} Number of items in storage.
+ */
+ //length:0,
+
+ /**
+ * Returns the key name by index.
+ *
+ * @method key
+ * @param {Number} index Index of key to return.
+ * @return {String} Key value or null if it wasn't found.
+ */
+ key: function(index) {
+ return keys[index];
+ },
+
+ /**
+ * Returns the value if the specified key or null if it wasn't found.
+ *
+ * @method getItem
+ * @param {String} key Key of item to retrieve.
+ * @return {String} Value of the specified item or null if it wasn't found.
+ */
+ getItem: function(key) {
+ return key in items ? items[key] : null;
+ },
+
+ /**
+ * Sets the value of the specified item by it's key.
+ *
+ * @method setItem
+ * @param {String} key Key of the item to set.
+ * @param {String} value Value of the item to set.
+ */
+ setItem: function(key, value) {
+ items[key] = "" + value;
+ save();
+ },
+
+ /**
+ * Removes the specified item by key.
+ *
+ * @method removeItem
+ * @param {String} key Key of item to remove.
+ */
+ removeItem: function(key) {
+ delete items[key];
+ save();
+ },
+
+ /**
+ * Removes all items.
+ *
+ * @method clear
+ */
+ clear: function() {
+ items = {};
+ save();
+ }
+ };
+
+ load();
+
+ return LocalStorage;
+});
+
+// Included from: js/tinymce/classes/Compat.js
+
+/**
+ * Compat.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * TinyMCE core class.
+ *
+ * @static
+ * @class tinymce
+ * @borrow-members tinymce.EditorManager
+ * @borrow-members tinymce.util.Tools
+ */
+define("tinymce/Compat", [
+ "tinymce/dom/DOMUtils",
+ "tinymce/dom/EventUtils",
+ "tinymce/dom/ScriptLoader",
+ "tinymce/AddOnManager",
+ "tinymce/util/Tools",
+ "tinymce/Env"
+], function(DOMUtils, EventUtils, ScriptLoader, AddOnManager, Tools, Env) {
+ var tinymce = window.tinymce;
+
+ /**
+ * @property {tinymce.dom.DOMUtils} DOM Global DOM instance.
+ * @property {tinymce.dom.ScriptLoader} ScriptLoader Global ScriptLoader instance.
+ * @property {tinymce.AddOnManager} PluginManager Global PluginManager instance.
+ * @property {tinymce.AddOnManager} ThemeManager Global ThemeManager instance.
+ */
+ tinymce.DOM = DOMUtils.DOM;
+ tinymce.ScriptLoader = ScriptLoader.ScriptLoader;
+ tinymce.PluginManager = AddOnManager.PluginManager;
+ tinymce.ThemeManager = AddOnManager.ThemeManager;
+
+ tinymce.dom = tinymce.dom || {};
+ tinymce.dom.Event = EventUtils.Event;
+
+ Tools.each(Tools, function(func, key) {
+ tinymce[key] = func;
+ });
+
+ Tools.each('isOpera isWebKit isIE isGecko isMac'.split(' '), function(name) {
+ tinymce[name] = Env[name.substr(2).toLowerCase()];
+ });
+
+ return {};
+});
+
+// Describe the different namespaces
+
+/**
+ * Root level namespace this contains classes directly related to the TinyMCE editor.
+ *
+ * @namespace tinymce
+ */
+
+/**
+ * Contains classes for handling the browsers DOM.
+ *
+ * @namespace tinymce.dom
+ */
+
+/**
+ * Contains html parser and serializer logic.
+ *
+ * @namespace tinymce.html
+ */
+
+/**
+ * Contains the different UI types such as buttons, listboxes etc.
+ *
+ * @namespace tinymce.ui
+ */
+
+/**
+ * Contains various utility classes such as json parser, cookies etc.
+ *
+ * @namespace tinymce.util
+ */
+
+/**
+ * Contains modules to handle data binding.
+ *
+ * @namespace tinymce.data
+ */
+
+// Included from: js/tinymce/classes/ui/Layout.js
+
+/**
+ * Layout.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Base layout manager class.
+ *
+ * @class tinymce.ui.Layout
+ */
+define("tinymce/ui/Layout", [
+ "tinymce/util/Class",
+ "tinymce/util/Tools"
+], function(Class, Tools) {
+ "use strict";
+
+ return Class.extend({
+ Defaults: {
+ firstControlClass: 'first',
+ lastControlClass: 'last'
+ },
+
+ /**
+ * Constructs a layout instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ */
+ init: function(settings) {
+ this.settings = Tools.extend({}, this.Defaults, settings);
+ },
+
+ /**
+ * This method gets invoked before the layout renders the controls.
+ *
+ * @method preRender
+ * @param {tinymce.ui.Container} container Container instance to preRender.
+ */
+ preRender: function(container) {
+ container.bodyClasses.add(this.settings.containerClass);
+ },
+
+ /**
+ * Applies layout classes to the container.
+ *
+ * @private
+ */
+ applyClasses: function(items) {
+ var self = this, settings = self.settings, firstClass, lastClass, firstItem, lastItem;
+
+ firstClass = settings.firstControlClass;
+ lastClass = settings.lastControlClass;
+
+ items.each(function(item) {
+ item.classes.remove(firstClass).remove(lastClass).add(settings.controlClass);
+
+ if (item.visible()) {
+ if (!firstItem) {
+ firstItem = item;
+ }
+
+ lastItem = item;
+ }
+ });
+
+ if (firstItem) {
+ firstItem.classes.add(firstClass);
+ }
+
+ if (lastItem) {
+ lastItem.classes.add(lastClass);
+ }
+ },
+
+ /**
+ * Renders the specified container and any layout specific HTML.
+ *
+ * @method renderHtml
+ * @param {tinymce.ui.Container} container Container to render HTML for.
+ */
+ renderHtml: function(container) {
+ var self = this, html = '';
+
+ self.applyClasses(container.items());
+
+ container.items().each(function(item) {
+ html += item.renderHtml();
+ });
+
+ return html;
+ },
+
+ /**
+ * Recalculates the positions of the controls in the specified container.
+ *
+ * @method recalc
+ * @param {tinymce.ui.Container} container Container instance to recalc.
+ */
+ recalc: function() {
+ },
+
+ /**
+ * This method gets invoked after the layout renders the controls.
+ *
+ * @method postRender
+ * @param {tinymce.ui.Container} container Container instance to postRender.
+ */
+ postRender: function() {
+ },
+
+ isNative: function() {
+ return false;
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/AbsoluteLayout.js
+
+/**
+ * AbsoluteLayout.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * LayoutManager for absolute positioning. This layout manager is more of
+ * a base class for other layouts but can be created and used directly.
+ *
+ * @-x-less AbsoluteLayout.less
+ * @class tinymce.ui.AbsoluteLayout
+ * @extends tinymce.ui.Layout
+ */
+define("tinymce/ui/AbsoluteLayout", [
+ "tinymce/ui/Layout"
+], function(Layout) {
+ "use strict";
+
+ return Layout.extend({
+ Defaults: {
+ containerClass: 'abs-layout',
+ controlClass: 'abs-layout-item'
+ },
+
+ /**
+ * Recalculates the positions of the controls in the specified container.
+ *
+ * @method recalc
+ * @param {tinymce.ui.Container} container Container instance to recalc.
+ */
+ recalc: function(container) {
+ container.items().filter(':visible').each(function(ctrl) {
+ var settings = ctrl.settings;
+
+ ctrl.layoutRect({
+ x: settings.x,
+ y: settings.y,
+ w: settings.w,
+ h: settings.h
+ });
+
+ if (ctrl.recalc) {
+ ctrl.recalc();
+ }
+ });
+ },
+
+ /**
+ * Renders the specified container and any layout specific HTML.
+ *
+ * @method renderHtml
+ * @param {tinymce.ui.Container} container Container to render HTML for.
+ */
+ renderHtml: function(container) {
+ return '' + this._super(container);
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/Button.js
+
+/**
+ * Button.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class is used to create buttons. You can create them directly or through the Factory.
+ *
+ * @example
+ * // Create and render a button to the body element
+ * tinymce.ui.Factory.create({
+ * type: 'button',
+ * text: 'My button'
+ * }).renderTo(document.body);
+ *
+ * @-x-less Button.less
+ * @class tinymce.ui.Button
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/Button", [
+ "tinymce/ui/Widget"
+], function(Widget) {
+ "use strict";
+
+ return Widget.extend({
+ Defaults: {
+ classes: "widget btn",
+ role: "button"
+ },
+
+ /**
+ * Constructs a new button instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {String} size Size of the button small|medium|large.
+ * @setting {String} image Image to use for icon.
+ * @setting {String} icon Icon to use for button.
+ */
+ init: function(settings) {
+ var self = this, size;
+
+ self._super(settings);
+ settings = self.settings;
+
+ size = self.settings.size;
+
+ self.on('click mousedown', function(e) {
+ e.preventDefault();
+ });
+
+ self.on('touchstart', function(e) {
+ self.fire('click', e);
+ e.preventDefault();
+ });
+
+ if (settings.subtype) {
+ self.classes.add(settings.subtype);
+ }
+
+ if (size) {
+ self.classes.add('btn-' + size);
+ }
+
+ if (settings.icon) {
+ self.icon(settings.icon);
+ }
+ },
+
+ /**
+ * Sets/gets the current button icon.
+ *
+ * @method icon
+ * @param {String} [icon] New icon identifier.
+ * @return {String|tinymce.ui.MenuButton} Current icon or current MenuButton instance.
+ */
+ icon: function(icon) {
+ if (!arguments.length) {
+ return this.state.get('icon');
+ }
+
+ this.state.set('icon', icon);
+
+ return this;
+ },
+
+ /**
+ * Repaints the button for example after it's been resizes by a layout engine.
+ *
+ * @method repaint
+ */
+ repaint: function() {
+ var btnElm = this.getEl().firstChild,
+ btnStyle;
+
+ if (btnElm) {
+ btnStyle = btnElm.style;
+ btnStyle.width = btnStyle.height = "100%";
+ }
+
+ this._super();
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, id = self._id, prefix = self.classPrefix;
+ var icon = self.state.get('icon'), image, text = self.state.get('text'), textHtml = '';
+
+ image = self.settings.image;
+ if (image) {
+ icon = 'none';
+
+ // Support for [high dpi, low dpi] image sources
+ if (typeof image != "string") {
+ image = window.getSelection ? image[0] : image[1];
+ }
+
+ image = ' style="background-image: url(\'' + image + '\')"';
+ } else {
+ image = '';
+ }
+
+ if (text) {
+ self.classes.add('btn-has-text');
+ textHtml = '' + self.encode(text) + '';
+ }
+
+ icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+
+ return (
+ '' +
+ '' +
+ '
'
+ );
+ },
+
+ bindStates: function() {
+ var self = this, $ = self.$, textCls = self.classPrefix + 'txt';
+
+ function setButtonText(text) {
+ var $span = $('span.' + textCls, self.getEl());
+
+ if (text) {
+ if (!$span[0]) {
+ $('button:first', self.getEl()).append('');
+ $span = $('span.' + textCls, self.getEl());
+ }
+
+ $span.html(self.encode(text));
+ } else {
+ $span.remove();
+ }
+
+ self.classes.toggle('btn-has-text', !!text);
+ }
+
+ self.state.on('change:text', function(e) {
+ setButtonText(e.value);
+ });
+
+ self.state.on('change:icon', function(e) {
+ var icon = e.value, prefix = self.classPrefix;
+
+ self.settings.icon = icon;
+ icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+
+ var btnElm = self.getEl().firstChild, iconElm = btnElm.getElementsByTagName('i')[0];
+
+ if (icon) {
+ if (!iconElm || iconElm != btnElm.firstChild) {
+ iconElm = document.createElement('i');
+ btnElm.insertBefore(iconElm, btnElm.firstChild);
+ }
+
+ iconElm.className = icon;
+ } else if (iconElm) {
+ btnElm.removeChild(iconElm);
+ }
+
+ setButtonText(self.state.get('text'));
+ });
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/ButtonGroup.js
+
+/**
+ * ButtonGroup.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This control enables you to put multiple buttons into a group. This is
+ * useful when you want to combine similar toolbar buttons into a group.
+ *
+ * @example
+ * // Create and render a buttongroup with two buttons to the body element
+ * tinymce.ui.Factory.create({
+ * type: 'buttongroup',
+ * items: [
+ * {text: 'Button A'},
+ * {text: 'Button B'}
+ * ]
+ * }).renderTo(document.body);
+ *
+ * @-x-less ButtonGroup.less
+ * @class tinymce.ui.ButtonGroup
+ * @extends tinymce.ui.Container
+ */
+define("tinymce/ui/ButtonGroup", [
+ "tinymce/ui/Container"
+], function(Container) {
+ "use strict";
+
+ return Container.extend({
+ Defaults: {
+ defaultType: 'button',
+ role: 'group'
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, layout = self._layout;
+
+ self.classes.add('btn-group');
+ self.preRender();
+ layout.preRender(self);
+
+ return (
+ '' +
+ '
' +
+ (self.settings.html || '') + layout.renderHtml(self) +
+ '
' +
+ '
' +
+ '' +
+ '' + self.encode(self.state.get('text')) + '' +
+ '
'
+ );
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ function checked(state) {
+ self.classes.toggle("checked", state);
+ self.aria('checked', state);
+ }
+
+ self.state.on('change:text', function(e) {
+ self.getEl('al').firstChild.data = self.translate(e.value);
+ });
+
+ self.state.on('change:checked change:value', function(e) {
+ self.fire('change');
+ checked(e.value);
+ });
+
+ self.state.on('change:icon', function(e) {
+ var icon = e.value, prefix = self.classPrefix;
+
+ if (typeof icon == 'undefined') {
+ return self.settings.icon;
+ }
+
+ self.settings.icon = icon;
+ icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+
+ var btnElm = self.getEl().firstChild, iconElm = btnElm.getElementsByTagName('i')[0];
+
+ if (icon) {
+ if (!iconElm || iconElm != btnElm.firstChild) {
+ iconElm = document.createElement('i');
+ btnElm.insertBefore(iconElm, btnElm.firstChild);
+ }
+
+ iconElm.className = icon;
+ } else if (iconElm) {
+ btnElm.removeChild(iconElm);
+ }
+ });
+
+ if (self.state.get('checked')) {
+ checked(true);
+ }
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/ComboBox.js
+
+/**
+ * ComboBox.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class creates a combobox control. Select box that you select a value from or
+ * type a value into.
+ *
+ * @-x-less ComboBox.less
+ * @class tinymce.ui.ComboBox
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/ComboBox", [
+ "tinymce/ui/Widget",
+ "tinymce/ui/Factory",
+ "tinymce/ui/DomUtils",
+ "tinymce/dom/DomQuery"
+], function(Widget, Factory, DomUtils, $) {
+ "use strict";
+
+ return Widget.extend({
+ /**
+ * Constructs a new control instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {String} placeholder Placeholder text to display.
+ */
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+ settings = self.settings;
+
+ self.classes.add('combobox');
+ self.subinput = true;
+ self.ariaTarget = 'inp'; // TODO: Figure out a better way
+
+ settings.menu = settings.menu || settings.values;
+
+ if (settings.menu) {
+ settings.icon = 'caret';
+ }
+
+ self.on('click', function(e) {
+ var elm = e.target, root = self.getEl();
+
+ if (!$.contains(root, elm) && elm != root) {
+ return;
+ }
+
+ while (elm && elm != root) {
+ if (elm.id && elm.id.indexOf('-open') != -1) {
+ self.fire('action');
+
+ if (settings.menu) {
+ self.showMenu();
+
+ if (e.aria) {
+ self.menu.items()[0].focus();
+ }
+ }
+ }
+
+ elm = elm.parentNode;
+ }
+ });
+
+ // TODO: Rework this
+ self.on('keydown', function(e) {
+ if (e.target.nodeName == "INPUT" && e.keyCode == 13) {
+ self.parents().reverse().each(function(ctrl) {
+ var stateValue = self.state.get('value'), inputValue = self.getEl('inp').value;
+
+ e.preventDefault();
+
+ self.state.set('value', inputValue);
+
+ if (stateValue != inputValue) {
+ self.fire('change');
+ }
+
+ if (ctrl.hasEventListeners('submit') && ctrl.toJSON) {
+ ctrl.fire('submit', {data: ctrl.toJSON()});
+ return false;
+ }
+ });
+ }
+ });
+
+ self.on('keyup', function(e) {
+ if (e.target.nodeName == "INPUT") {
+ self.state.set('value', e.target.value);
+ }
+ });
+ },
+
+ showMenu: function() {
+ var self = this, settings = self.settings, menu;
+
+ if (!self.menu) {
+ menu = settings.menu || [];
+
+ // Is menu array then auto constuct menu control
+ if (menu.length) {
+ menu = {
+ type: 'menu',
+ items: menu
+ };
+ } else {
+ menu.type = menu.type || 'menu';
+ }
+
+ self.menu = Factory.create(menu).parent(self).renderTo(self.getContainerElm());
+ self.fire('createmenu');
+ self.menu.reflow();
+ self.menu.on('cancel', function(e) {
+ if (e.control === self.menu) {
+ self.focus();
+ }
+ });
+
+ self.menu.on('show hide', function(e) {
+ e.control.items().each(function(ctrl) {
+ ctrl.active(ctrl.value() == self.value());
+ });
+ }).fire('show');
+
+ self.menu.on('select', function(e) {
+ self.value(e.control.value());
+ });
+
+ self.on('focusin', function(e) {
+ if (e.target.tagName.toUpperCase() == 'INPUT') {
+ self.menu.hide();
+ }
+ });
+
+ self.aria('expanded', true);
+ }
+
+ self.menu.show();
+ self.menu.layoutRect({w: self.layoutRect().w});
+ self.menu.moveRel(self.getEl(), self.isRtl() ? ['br-tr', 'tr-br'] : ['bl-tl', 'tl-bl']);
+ },
+
+ /**
+ * Focuses the input area of the control.
+ *
+ * @method focus
+ */
+ focus: function() {
+ this.getEl('inp').focus();
+ },
+
+ /**
+ * Repaints the control after a layout operation.
+ *
+ * @method repaint
+ */
+ repaint: function() {
+ var self = this, elm = self.getEl(), openElm = self.getEl('open'), rect = self.layoutRect();
+ var width, lineHeight;
+
+ if (openElm) {
+ width = rect.w - DomUtils.getSize(openElm).width - 10;
+ } else {
+ width = rect.w - 10;
+ }
+
+ // Detect old IE 7+8 add lineHeight to align caret vertically in the middle
+ var doc = document;
+ if (doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
+ lineHeight = (self.layoutRect().h - 2) + 'px';
+ }
+
+ $(elm.firstChild).css({
+ width: width,
+ lineHeight: lineHeight
+ });
+
+ self._super();
+
+ return self;
+ },
+
+ /**
+ * Post render method. Called after the control has been rendered to the target.
+ *
+ * @method postRender
+ * @return {tinymce.ui.ComboBox} Current combobox instance.
+ */
+ postRender: function() {
+ var self = this;
+
+ $(this.getEl('inp')).on('change', function(e) {
+ self.state.set('value', e.target.value);
+ self.fire('change', e);
+ });
+
+ return self._super();
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix;
+ var value = self.state.get('value') || '';
+ var icon, text, openBtnHtml = '', extraAttrs = '';
+
+ if ("spellcheck" in settings) {
+ extraAttrs += ' spellcheck="' + settings.spellcheck + '"';
+ }
+
+ if (settings.maxLength) {
+ extraAttrs += ' maxlength="' + settings.maxLength + '"';
+ }
+
+ if (settings.size) {
+ extraAttrs += ' size="' + settings.size + '"';
+ }
+
+ if (settings.subtype) {
+ extraAttrs += ' type="' + settings.subtype + '"';
+ }
+
+ if (self.disabled()) {
+ extraAttrs += ' disabled="disabled"';
+ }
+
+ icon = settings.icon;
+ if (icon && icon != 'caret') {
+ icon = prefix + 'ico ' + prefix + 'i-' + settings.icon;
+ }
+
+ text = self.state.get('text');
+
+ if (icon || text) {
+ openBtnHtml = (
+ '' +
+ '' +
+ '
'
+ );
+
+ self.classes.add('has-open');
+ }
+
+ return (
+ '' +
+ '' +
+ openBtnHtml +
+ '
'
+ );
+ },
+
+ value: function(value) {
+ if (arguments.length) {
+ this.state.set('value', value);
+ return this;
+ }
+
+ // Make sure the real state is in sync
+ if (this.state.get('rendered')) {
+ this.state.set('value', this.getEl('inp').value);
+ }
+
+ return this.state.get('value');
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:value', function(e) {
+ if (self.getEl('inp').value != e.value) {
+ self.getEl('inp').value = e.value;
+ }
+ });
+
+ self.state.on('change:disabled', function(e) {
+ self.getEl('inp').disabled = e.value;
+ });
+
+ return self._super();
+ },
+
+ remove: function() {
+ $(this.getEl('inp')).off();
+ this._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/ColorBox.js
+
+/**
+ * ColorBox.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This widget lets you enter colors and browse for colors by pressing the color button. It also displays
+ * a preview of the current color.
+ *
+ * @-x-less ColorBox.less
+ * @class tinymce.ui.ColorBox
+ * @extends tinymce.ui.ComboBox
+ */
+define("tinymce/ui/ColorBox", [
+ "tinymce/ui/ComboBox"
+], function(ComboBox) {
+ "use strict";
+
+ return ComboBox.extend({
+ /**
+ * Constructs a new control instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ */
+ init: function(settings) {
+ var self = this;
+
+ settings.spellcheck = false;
+
+ if (settings.onaction) {
+ settings.icon = 'none';
+ }
+
+ self._super(settings);
+
+ self.classes.add('colorbox');
+ self.on('change keyup postrender', function() {
+ self.repaintColor(self.value());
+ });
+ },
+
+ repaintColor: function(value) {
+ var elm = this.getEl().getElementsByTagName('i')[0];
+
+ if (elm) {
+ try {
+ elm.style.background = value;
+ } catch (ex) {
+ // Ignore
+ }
+ }
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:value', function(e) {
+ if (self.state.get('rendered')) {
+ self.repaintColor(e.value);
+ }
+ });
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/PanelButton.js
+
+/**
+ * PanelButton.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a new panel button.
+ *
+ * @class tinymce.ui.PanelButton
+ * @extends tinymce.ui.Button
+ */
+define("tinymce/ui/PanelButton", [
+ "tinymce/ui/Button",
+ "tinymce/ui/FloatPanel"
+], function(Button, FloatPanel) {
+ "use strict";
+
+ return Button.extend({
+ /**
+ * Shows the panel for the button.
+ *
+ * @method showPanel
+ */
+ showPanel: function() {
+ var self = this, settings = self.settings;
+
+ self.active(true);
+
+ if (!self.panel) {
+ var panelSettings = settings.panel;
+
+ // Wrap panel in grid layout if type if specified
+ // This makes it possible to add forms or other containers directly in the panel option
+ if (panelSettings.type) {
+ panelSettings = {
+ layout: 'grid',
+ items: panelSettings
+ };
+ }
+
+ panelSettings.role = panelSettings.role || 'dialog';
+ panelSettings.popover = true;
+ panelSettings.autohide = true;
+ panelSettings.ariaRoot = true;
+
+ self.panel = new FloatPanel(panelSettings).on('hide', function() {
+ self.active(false);
+ }).on('cancel', function(e) {
+ e.stopPropagation();
+ self.focus();
+ self.hidePanel();
+ }).parent(self).renderTo(self.getContainerElm());
+
+ self.panel.fire('show');
+ self.panel.reflow();
+ } else {
+ self.panel.show();
+ }
+
+ self.panel.moveRel(self.getEl(), settings.popoverAlign || (self.isRtl() ? ['bc-tr', 'bc-tc'] : ['bc-tl', 'bc-tc']));
+ },
+
+ /**
+ * Hides the panel for the button.
+ *
+ * @method hidePanel
+ */
+ hidePanel: function() {
+ var self = this;
+
+ if (self.panel) {
+ self.panel.hide();
+ }
+ },
+
+ /**
+ * Called after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this;
+
+ self.aria('haspopup', true);
+
+ self.on('click', function(e) {
+ if (e.control === self) {
+ if (self.panel && self.panel.visible()) {
+ self.hidePanel();
+ } else {
+ self.showPanel();
+ self.panel.focus(!!e.aria);
+ }
+ }
+ });
+
+ return self._super();
+ },
+
+ remove: function() {
+ if (this.panel) {
+ this.panel.remove();
+ this.panel = null;
+ }
+
+ return this._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/ColorButton.js
+
+/**
+ * ColorButton.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class creates a color button control. This is a split button in which the main
+ * button has a visual representation of the currently selected color. When clicked
+ * the caret button displays a color picker, allowing the user to select a new color.
+ *
+ * @-x-less ColorButton.less
+ * @class tinymce.ui.ColorButton
+ * @extends tinymce.ui.PanelButton
+ */
+define("tinymce/ui/ColorButton", [
+ "tinymce/ui/PanelButton",
+ "tinymce/dom/DOMUtils"
+], function(PanelButton, DomUtils) {
+ "use strict";
+
+ var DOM = DomUtils.DOM;
+
+ return PanelButton.extend({
+ /**
+ * Constructs a new ColorButton instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ */
+ init: function(settings) {
+ this._super(settings);
+ this.classes.add('colorbutton');
+ },
+
+ /**
+ * Getter/setter for the current color.
+ *
+ * @method color
+ * @param {String} [color] Color to set.
+ * @return {String|tinymce.ui.ColorButton} Current color or current instance.
+ */
+ color: function(color) {
+ if (color) {
+ this._color = color;
+ this.getEl('preview').style.backgroundColor = color;
+ return this;
+ }
+
+ return this._color;
+ },
+
+ /**
+ * Resets the current color.
+ *
+ * @method resetColor
+ * @return {tinymce.ui.ColorButton} Current instance.
+ */
+ resetColor: function() {
+ this._color = null;
+ this.getEl('preview').style.backgroundColor = null;
+ return this;
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, id = self._id, prefix = self.classPrefix, text = self.state.get('text');
+ var icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+ var image = self.settings.image ? ' style="background-image: url(\'' + self.settings.image + '\')"' : '',
+ textHtml = '';
+
+ if (text) {
+ self.classes.add('btn-has-text');
+ textHtml = '' + self.encode(text) + '';
+ }
+
+ return (
+ '' +
+ '' +
+ '' +
+ '
'
+ );
+ },
+
+ /**
+ * Called after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this, onClickHandler = self.settings.onclick;
+
+ self.on('click', function(e) {
+ if (e.aria && e.aria.key == 'down') {
+ return;
+ }
+
+ if (e.control == self && !DOM.getParent(e.target, '.' + self.classPrefix + 'open')) {
+ e.stopImmediatePropagation();
+ onClickHandler.call(self, e);
+ }
+ });
+
+ delete self.settings.onclick;
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/util/Color.js
+
+/**
+ * Color.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class lets you parse/serialize colors and convert rgb/hsb.
+ *
+ * @class tinymce.util.Color
+ * @example
+ * var white = new tinymce.util.Color({r: 255, g: 255, b: 255});
+ * var red = new tinymce.util.Color('#FF0000');
+ *
+ * console.log(white.toHex(), red.toHsv());
+ */
+define("tinymce/util/Color", [], function() {
+ var min = Math.min, max = Math.max, round = Math.round;
+
+ /**
+ * Constructs a new color instance.
+ *
+ * @constructor
+ * @method Color
+ * @param {String} value Optional initial value to parse.
+ */
+ function Color(value) {
+ var self = this, r = 0, g = 0, b = 0;
+
+ function rgb2hsv(r, g, b) {
+ var h, s, v, d, minRGB, maxRGB;
+
+ h = 0;
+ s = 0;
+ v = 0;
+ r = r / 255;
+ g = g / 255;
+ b = b / 255;
+
+ minRGB = min(r, min(g, b));
+ maxRGB = max(r, max(g, b));
+
+ if (minRGB == maxRGB) {
+ v = minRGB;
+
+ return {
+ h: 0,
+ s: 0,
+ v: v * 100
+ };
+ }
+
+ /*eslint no-nested-ternary:0 */
+ d = (r == minRGB) ? g - b : ((b == minRGB) ? r - g : b - r);
+ h = (r == minRGB) ? 3 : ((b == minRGB) ? 1 : 5);
+ h = 60 * (h - d / (maxRGB - minRGB));
+ s = (maxRGB - minRGB) / maxRGB;
+ v = maxRGB;
+
+ return {
+ h: round(h),
+ s: round(s * 100),
+ v: round(v * 100)
+ };
+ }
+
+ function hsvToRgb(hue, saturation, brightness) {
+ var side, chroma, x, match;
+
+ hue = (parseInt(hue, 10) || 0) % 360;
+ saturation = parseInt(saturation, 10) / 100;
+ brightness = parseInt(brightness, 10) / 100;
+ saturation = max(0, min(saturation, 1));
+ brightness = max(0, min(brightness, 1));
+
+ if (saturation === 0) {
+ r = g = b = round(255 * brightness);
+ return;
+ }
+
+ side = hue / 60;
+ chroma = brightness * saturation;
+ x = chroma * (1 - Math.abs(side % 2 - 1));
+ match = brightness - chroma;
+
+ switch (Math.floor(side)) {
+ case 0:
+ r = chroma;
+ g = x;
+ b = 0;
+ break;
+
+ case 1:
+ r = x;
+ g = chroma;
+ b = 0;
+ break;
+
+ case 2:
+ r = 0;
+ g = chroma;
+ b = x;
+ break;
+
+ case 3:
+ r = 0;
+ g = x;
+ b = chroma;
+ break;
+
+ case 4:
+ r = x;
+ g = 0;
+ b = chroma;
+ break;
+
+ case 5:
+ r = chroma;
+ g = 0;
+ b = x;
+ break;
+
+ default:
+ r = g = b = 0;
+ }
+
+ r = round(255 * (r + match));
+ g = round(255 * (g + match));
+ b = round(255 * (b + match));
+ }
+
+ /**
+ * Returns the hex string of the current color. For example: #ff00ff
+ *
+ * @method toHex
+ * @return {String} Hex string of current color.
+ */
+ function toHex() {
+ function hex(val) {
+ val = parseInt(val, 10).toString(16);
+
+ return val.length > 1 ? val : '0' + val;
+ }
+
+ return '#' + hex(r) + hex(g) + hex(b);
+ }
+
+ /**
+ * Returns the r, g, b values of the color. Each channel has a range from 0-255.
+ *
+ * @method toRgb
+ * @return {Object} Object with r, g, b fields.
+ */
+ function toRgb() {
+ return {
+ r: r,
+ g: g,
+ b: b
+ };
+ }
+
+ /**
+ * Returns the h, s, v values of the color. Ranges: h=0-360, s=0-100, v=0-100.
+ *
+ * @method toHsv
+ * @return {Object} Object with h, s, v fields.
+ */
+ function toHsv() {
+ return rgb2hsv(r, g, b);
+ }
+
+ /**
+ * Parses the specified value and populates the color instance.
+ *
+ * Supported format examples:
+ * * rbg(255,0,0)
+ * * #ff0000
+ * * #fff
+ * * {r: 255, g: 0, b: 0}
+ * * {h: 360, s: 100, v: 100}
+ *
+ * @method parse
+ * @param {Object/String} value Color value to parse.
+ * @return {tinymce.util.Color} Current color instance.
+ */
+ function parse(value) {
+ var matches;
+
+ if (typeof value == 'object') {
+ if ("r" in value) {
+ r = value.r;
+ g = value.g;
+ b = value.b;
+ } else if ("v" in value) {
+ hsvToRgb(value.h, value.s, value.v);
+ }
+ } else {
+ if ((matches = /rgb\s*\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)[^\)]*\)/gi.exec(value))) {
+ r = parseInt(matches[1], 10);
+ g = parseInt(matches[2], 10);
+ b = parseInt(matches[3], 10);
+ } else if ((matches = /#([0-F]{2})([0-F]{2})([0-F]{2})/gi.exec(value))) {
+ r = parseInt(matches[1], 16);
+ g = parseInt(matches[2], 16);
+ b = parseInt(matches[3], 16);
+ } else if ((matches = /#([0-F])([0-F])([0-F])/gi.exec(value))) {
+ r = parseInt(matches[1] + matches[1], 16);
+ g = parseInt(matches[2] + matches[2], 16);
+ b = parseInt(matches[3] + matches[3], 16);
+ }
+ }
+
+ r = r < 0 ? 0 : (r > 255 ? 255 : r);
+ g = g < 0 ? 0 : (g > 255 ? 255 : g);
+ b = b < 0 ? 0 : (b > 255 ? 255 : b);
+
+ return self;
+ }
+
+ if (value) {
+ parse(value);
+ }
+
+ self.toRgb = toRgb;
+ self.toHsv = toHsv;
+ self.toHex = toHex;
+ self.parse = parse;
+ }
+
+ return Color;
+});
+
+// Included from: js/tinymce/classes/ui/ColorPicker.js
+
+/**
+ * ColorPicker.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Color picker widget lets you select colors.
+ *
+ * @-x-less ColorPicker.less
+ * @class tinymce.ui.ColorPicker
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/ColorPicker", [
+ "tinymce/ui/Widget",
+ "tinymce/ui/DragHelper",
+ "tinymce/ui/DomUtils",
+ "tinymce/util/Color"
+], function(Widget, DragHelper, DomUtils, Color) {
+ "use strict";
+
+ return Widget.extend({
+ Defaults: {
+ classes: "widget colorpicker"
+ },
+
+ /**
+ * Constructs a new colorpicker instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {String} color Initial color value.
+ */
+ init: function(settings) {
+ this._super(settings);
+ },
+
+ postRender: function() {
+ var self = this, color = self.color(), hsv, hueRootElm, huePointElm, svRootElm, svPointElm;
+
+ hueRootElm = self.getEl('h');
+ huePointElm = self.getEl('hp');
+ svRootElm = self.getEl('sv');
+ svPointElm = self.getEl('svp');
+
+ function getPos(elm, event) {
+ var pos = DomUtils.getPos(elm), x, y;
+
+ x = event.pageX - pos.x;
+ y = event.pageY - pos.y;
+
+ x = Math.max(0, Math.min(x / elm.clientWidth, 1));
+ y = Math.max(0, Math.min(y / elm.clientHeight, 1));
+
+ return {
+ x: x,
+ y: y
+ };
+ }
+
+ function updateColor(hsv, hueUpdate) {
+ var hue = (360 - hsv.h) / 360;
+
+ DomUtils.css(huePointElm, {
+ top: (hue * 100) + '%'
+ });
+
+ if (!hueUpdate) {
+ DomUtils.css(svPointElm, {
+ left: hsv.s + '%',
+ top: (100 - hsv.v) + '%'
+ });
+ }
+
+ svRootElm.style.background = new Color({s: 100, v: 100, h: hsv.h}).toHex();
+ self.color().parse({s: hsv.s, v: hsv.v, h: hsv.h});
+ }
+
+ function updateSaturationAndValue(e) {
+ var pos;
+
+ pos = getPos(svRootElm, e);
+ hsv.s = pos.x * 100;
+ hsv.v = (1 - pos.y) * 100;
+
+ updateColor(hsv);
+ self.fire('change');
+ }
+
+ function updateHue(e) {
+ var pos;
+
+ pos = getPos(hueRootElm, e);
+ hsv = color.toHsv();
+ hsv.h = (1 - pos.y) * 360;
+ updateColor(hsv, true);
+ self.fire('change');
+ }
+
+ self._repaint = function() {
+ hsv = color.toHsv();
+ updateColor(hsv);
+ };
+
+ self._super();
+
+ self._svdraghelper = new DragHelper(self._id + '-sv', {
+ start: updateSaturationAndValue,
+ drag: updateSaturationAndValue
+ });
+
+ self._hdraghelper = new DragHelper(self._id + '-h', {
+ start: updateHue,
+ drag: updateHue
+ });
+
+ self._repaint();
+ },
+
+ rgb: function() {
+ return this.color().toRgb();
+ },
+
+ value: function(value) {
+ var self = this;
+
+ if (arguments.length) {
+ self.color().parse(value);
+
+ if (self._rendered) {
+ self._repaint();
+ }
+ } else {
+ return self.color().toHex();
+ }
+ },
+
+ color: function() {
+ if (!this._color) {
+ this._color = new Color();
+ }
+
+ return this._color;
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, id = self._id, prefix = self.classPrefix, hueHtml;
+ var stops = '#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000';
+
+ function getOldIeFallbackHtml() {
+ var i, l, html = '', gradientPrefix, stopsList;
+
+ gradientPrefix = 'filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=';
+ stopsList = stops.split(',');
+ for (i = 0, l = stopsList.length - 1; i < l; i++) {
+ html += (
+ ''
+ );
+ }
+
+ return html;
+ }
+
+ var gradientCssText = (
+ 'background: -ms-linear-gradient(top,' + stops + ');' +
+ 'background: linear-gradient(to bottom,' + stops + ');'
+ );
+
+ hueHtml = (
+ '' +
+ getOldIeFallbackHtml() +
+ '
' +
+ '
' +
+ '
' +
+ hueHtml +
+ '
' +
+ self._getDataPathHtml(self.state.get('row')) +
+ '
'
+ );
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:row', function(e) {
+ self.innerHtml(self._getDataPathHtml(e.value));
+ });
+
+ return self._super();
+ },
+
+ _getDataPathHtml: function(data) {
+ var self = this, parts = data || [], i, l, html = '', prefix = self.classPrefix;
+
+ for (i = 0, l = parts.length; i < l; i++) {
+ html += (
+ (i > 0 ? ' ' + self.settings.delimiter + '
' : '') +
+ '' + parts[i].name + '
'
+ );
+ }
+
+ if (!html) {
+ html = '\u00a0
';
+ }
+
+ return html;
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/ElementPath.js
+
+/**
+ * ElementPath.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This control creates an path for the current selections parent elements in TinyMCE.
+ *
+ * @class tinymce.ui.ElementPath
+ * @extends tinymce.ui.Path
+ */
+define("tinymce/ui/ElementPath", [
+ "tinymce/ui/Path"
+], function(Path) {
+ return Path.extend({
+ /**
+ * Post render method. Called after the control has been rendered to the target.
+ *
+ * @method postRender
+ * @return {tinymce.ui.ElementPath} Current combobox instance.
+ */
+ postRender: function() {
+ var self = this, editor = self.settings.editor;
+
+ function isHidden(elm) {
+ if (elm.nodeType === 1) {
+ if (elm.nodeName == "BR" || !!elm.getAttribute('data-mce-bogus')) {
+ return true;
+ }
+
+ if (elm.getAttribute('data-mce-type') === 'bookmark') {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ if (editor.settings.elementpath !== false) {
+ self.on('select', function(e) {
+ editor.focus();
+ editor.selection.select(this.row()[e.index].element);
+ editor.nodeChanged();
+ });
+
+ editor.on('nodeChange', function(e) {
+ var outParents = [], parents = e.parents, i = parents.length;
+
+ while (i--) {
+ if (parents[i].nodeType == 1 && !isHidden(parents[i])) {
+ var args = editor.fire('ResolveName', {
+ name: parents[i].nodeName.toLowerCase(),
+ target: parents[i]
+ });
+
+ if (!args.isDefaultPrevented()) {
+ outParents.push({name: args.name, element: parents[i]});
+ }
+
+ if (args.isPropagationStopped()) {
+ break;
+ }
+ }
+ }
+
+ self.row(outParents);
+ });
+ }
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/FormItem.js
+
+/**
+ * FormItem.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class is a container created by the form element with
+ * a label and control item.
+ *
+ * @class tinymce.ui.FormItem
+ * @extends tinymce.ui.Container
+ * @setting {String} label Label to display for the form item.
+ */
+define("tinymce/ui/FormItem", [
+ "tinymce/ui/Container"
+], function(Container) {
+ "use strict";
+
+ return Container.extend({
+ Defaults: {
+ layout: 'flex',
+ align: 'center',
+ defaults: {
+ flex: 1
+ }
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, layout = self._layout, prefix = self.classPrefix;
+
+ self.classes.add('formitem');
+ layout.preRender(self);
+
+ return (
+ '' +
+ (self.settings.title ? ('
' +
+ self.settings.title + '
') : '') +
+ '
' +
+ (self.settings.html || '') + layout.renderHtml(self) +
+ '
' +
+ '
' +
+ '
' +
+ self.encode(self.state.get('text')) +
+ '' +
+ '
' +
+ '
' +
+ '' +
+ '
'
+ );
+ },
+
+ /**
+ * Gets invoked after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this;
+
+ self.on('click', function(e) {
+ if (e.control === self && isChildOf(e.target, self.getEl())) {
+ self.showMenu();
+
+ if (e.aria) {
+ self.menu.items()[0].focus();
+ }
+ }
+ });
+
+ self.on('mouseenter', function(e) {
+ var overCtrl = e.control, parent = self.parent(), hasVisibleSiblingMenu;
+
+ if (overCtrl && parent && overCtrl instanceof MenuButton && overCtrl.parent() == parent) {
+ parent.items().filter('MenuButton').each(function(ctrl) {
+ if (ctrl.hideMenu && ctrl != overCtrl) {
+ if (ctrl.menu && ctrl.menu.visible()) {
+ hasVisibleSiblingMenu = true;
+ }
+
+ ctrl.hideMenu();
+ }
+ });
+
+ if (hasVisibleSiblingMenu) {
+ overCtrl.focus(); // Fix for: #5887
+ overCtrl.showMenu();
+ }
+ }
+ });
+
+ return self._super();
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:menu', function() {
+ if (self.menu) {
+ self.menu.remove();
+ }
+
+ self.menu = null;
+ });
+
+ return self._super();
+ },
+
+ /**
+ * Removes the control and it's menus.
+ *
+ * @method remove
+ */
+ remove: function() {
+ this._super();
+
+ if (this.menu) {
+ this.menu.remove();
+ }
+ }
+ });
+
+ return MenuButton;
+});
+
+// Included from: js/tinymce/classes/ui/MenuItem.js
+
+/**
+ * MenuItem.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a new menu item.
+ *
+ * @-x-less MenuItem.less
+ * @class tinymce.ui.MenuItem
+ * @extends tinymce.ui.Control
+ */
+define("tinymce/ui/MenuItem", [
+ "tinymce/ui/Widget",
+ "tinymce/ui/Factory",
+ "tinymce/Env",
+ "tinymce/util/Delay"
+], function(Widget, Factory, Env, Delay) {
+ "use strict";
+
+ return Widget.extend({
+ Defaults: {
+ border: 0,
+ role: 'menuitem'
+ },
+
+ /**
+ * Constructs a instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {Boolean} selectable Selectable menu.
+ * @setting {Array} menu Submenu array with items.
+ * @setting {String} shortcut Shortcut to display for menu item. Example: Ctrl+X
+ */
+ init: function(settings) {
+ var self = this, text;
+
+ self._super(settings);
+
+ settings = self.settings;
+
+ self.classes.add('menu-item');
+
+ if (settings.menu) {
+ self.classes.add('menu-item-expand');
+ }
+
+ if (settings.preview) {
+ self.classes.add('menu-item-preview');
+ }
+
+ text = self.state.get('text');
+ if (text === '-' || text === '|') {
+ self.classes.add('menu-item-sep');
+ self.aria('role', 'separator');
+ self.state.set('text', '-');
+ }
+
+ if (settings.selectable) {
+ self.aria('role', 'menuitemcheckbox');
+ self.classes.add('menu-item-checkbox');
+ settings.icon = 'selected';
+ }
+
+ if (!settings.preview && !settings.selectable) {
+ self.classes.add('menu-item-normal');
+ }
+
+ self.on('mousedown', function(e) {
+ e.preventDefault();
+ });
+
+ if (settings.menu && !settings.ariaHideMenu) {
+ self.aria('haspopup', true);
+ }
+ },
+
+ /**
+ * Returns true/false if the menuitem has sub menu.
+ *
+ * @method hasMenus
+ * @return {Boolean} True/false state if it has submenu.
+ */
+ hasMenus: function() {
+ return !!this.settings.menu;
+ },
+
+ /**
+ * Shows the menu for the menu item.
+ *
+ * @method showMenu
+ */
+ showMenu: function() {
+ var self = this, settings = self.settings, menu, parent = self.parent();
+
+ parent.items().each(function(ctrl) {
+ if (ctrl !== self) {
+ ctrl.hideMenu();
+ }
+ });
+
+ if (settings.menu) {
+ menu = self.menu;
+
+ if (!menu) {
+ menu = settings.menu;
+
+ // Is menu array then auto constuct menu control
+ if (menu.length) {
+ menu = {
+ type: 'menu',
+ items: menu
+ };
+ } else {
+ menu.type = menu.type || 'menu';
+ }
+
+ if (parent.settings.itemDefaults) {
+ menu.itemDefaults = parent.settings.itemDefaults;
+ }
+
+ menu = self.menu = Factory.create(menu).parent(self).renderTo();
+ menu.reflow();
+ menu.on('cancel', function(e) {
+ e.stopPropagation();
+ self.focus();
+ menu.hide();
+ });
+ menu.on('show hide', function(e) {
+ e.control.items().each(function(ctrl) {
+ ctrl.active(ctrl.settings.selected);
+ });
+ }).fire('show');
+
+ menu.on('hide', function(e) {
+ if (e.control === menu) {
+ self.classes.remove('selected');
+ }
+ });
+
+ menu.submenu = true;
+ } else {
+ menu.show();
+ }
+
+ menu._parentMenu = parent;
+
+ menu.classes.add('menu-sub');
+
+ var rel = menu.testMoveRel(
+ self.getEl(),
+ self.isRtl() ? ['tl-tr', 'bl-br', 'tr-tl', 'br-bl'] : ['tr-tl', 'br-bl', 'tl-tr', 'bl-br']
+ );
+
+ menu.moveRel(self.getEl(), rel);
+ menu.rel = rel;
+
+ rel = 'menu-sub-' + rel;
+ menu.classes.remove(menu._lastRel).add(rel);
+ menu._lastRel = rel;
+
+ self.classes.add('selected');
+ self.aria('expanded', true);
+ }
+ },
+
+ /**
+ * Hides the menu for the menu item.
+ *
+ * @method hideMenu
+ */
+ hideMenu: function() {
+ var self = this;
+
+ if (self.menu) {
+ self.menu.items().each(function(item) {
+ if (item.hideMenu) {
+ item.hideMenu();
+ }
+ });
+
+ self.menu.hide();
+ self.aria('expanded', false);
+ }
+
+ return self;
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix, text = self.encode(self.state.get('text'));
+ var icon = self.settings.icon, image = '', shortcut = settings.shortcut;
+
+ // Converts shortcut format to Mac/PC variants
+ function convertShortcut(shortcut) {
+ var i, value, replace = {};
+
+ if (Env.mac) {
+ replace = {
+ alt: '⌥',
+ ctrl: '⌘',
+ shift: '⇧',
+ meta: '⌘'
+ };
+ } else {
+ replace = {
+ meta: 'Ctrl'
+ };
+ }
+
+ shortcut = shortcut.split('+');
+
+ for (i = 0; i < shortcut.length; i++) {
+ value = replace[shortcut[i].toLowerCase()];
+
+ if (value) {
+ shortcut[i] = value;
+ }
+ }
+
+ return shortcut.join('+');
+ }
+
+ if (icon) {
+ self.parent().classes.add('menu-has-icons');
+ }
+
+ if (settings.image) {
+ image = ' style="background-image: url(\'' + settings.image + '\')"';
+ }
+
+ if (shortcut) {
+ shortcut = convertShortcut(shortcut);
+ }
+
+ icon = prefix + 'ico ' + prefix + 'i-' + (self.settings.icon || 'none');
+
+ return (
+ '' +
+ (text !== '-' ? '
\u00a0' : '') +
+ (text !== '-' ? '
' + text + '' : '') +
+ (shortcut ? '' : '') +
+ (settings.menu ? '
' : '') +
+ '
' +
+ '' +
+ '
'
+ );
+ },
+
+ /**
+ * Called after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this;
+
+ self._super();
+
+ self.resizeDragHelper = new DragHelper(this._id, {
+ start: function() {
+ self.fire('ResizeStart');
+ },
+
+ drag: function(e) {
+ if (self.settings.direction != "both") {
+ e.deltaX = 0;
+ }
+
+ self.fire('Resize', e);
+ },
+
+ stop: function() {
+ self.fire('ResizeEnd');
+ }
+ });
+ },
+
+ remove: function() {
+ if (this.resizeDragHelper) {
+ this.resizeDragHelper.destroy();
+ }
+
+ return this._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/SelectBox.js
+
+/**
+ * SelectBox.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a new select box control.
+ *
+ * @-x-less SelectBox.less
+ * @class tinymce.ui.SelectBox
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/SelectBox", [
+ "tinymce/ui/Widget"
+], function(Widget) {
+ "use strict";
+
+ function createOptions(options) {
+ var strOptions = '';
+ if (options) {
+ for (var i = 0; i < options.length; i++) {
+ strOptions += '';
+ }
+ }
+ return strOptions;
+ }
+
+ return Widget.extend({
+ Defaults: {
+ classes: "selectbox",
+ role: "selectbox",
+ options: []
+ },
+ /**
+ * Constructs a instance with the specified settings.
+ *
+ * @constructor
+ * @param {Object} settings Name/value object with settings.
+ * @setting {Array} values Array with values to add to list box.
+ */
+ init: function(settings) {
+ var self = this;
+
+ self._super(settings);
+
+ if (self.settings.size) {
+ self.size = self.settings.size;
+ }
+
+ if (self.settings.options) {
+ self._options = self.settings.options;
+ }
+
+ self.on('keydown', function(e) {
+ var rootControl;
+
+ if (e.keyCode == 13) {
+ e.preventDefault();
+
+ // Find root control that we can do toJSON on
+ self.parents().reverse().each(function(ctrl) {
+ if (ctrl.toJSON) {
+ rootControl = ctrl;
+ return false;
+ }
+ });
+
+ // Fire event on current text box with the serialized data of the whole form
+ self.fire('submit', {data: rootControl.toJSON()});
+ }
+ });
+ },
+
+ /**
+ * Getter/setter function for the options state.
+ *
+ * @method options
+ * @param {Array} [state] State to be set.
+ * @return {Array|tinymce.ui.SelectBox} Array of string options.
+ */
+ options: function(state) {
+ if (!arguments.length) {
+ return this.state.get('options');
+ }
+
+ this.state.set('options', state);
+
+ return this;
+ },
+
+ renderHtml: function() {
+ var self = this, options, size = '';
+
+ options = createOptions(self._options);
+
+ if (self.size) {
+ size = ' size = "' + self.size + '"';
+ }
+
+ return (
+ ''
+ );
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:options', function(e) {
+ self.getEl().innerHTML = createOptions(e.value);
+ });
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/Slider.js
+
+/**
+ * Slider.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Slider control.
+ *
+ * @-x-less Slider.less
+ * @class tinymce.ui.Slider
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/Slider", [
+ "tinymce/ui/Widget",
+ "tinymce/ui/DragHelper",
+ "tinymce/ui/DomUtils"
+], function(Widget, DragHelper, DomUtils) {
+ "use strict";
+
+ function constrain(value, minVal, maxVal) {
+ if (value < minVal) {
+ value = minVal;
+ }
+
+ if (value > maxVal) {
+ value = maxVal;
+ }
+
+ return value;
+ }
+
+ function setAriaProp(el, name, value) {
+ el.setAttribute('aria-' + name, value);
+ }
+
+ function updateSliderHandle(ctrl, value) {
+ var maxHandlePos, shortSizeName, sizeName, stylePosName, styleValue, handleEl;
+
+ if (ctrl.settings.orientation == "v") {
+ stylePosName = "top";
+ sizeName = "height";
+ shortSizeName = "h";
+ } else {
+ stylePosName = "left";
+ sizeName = "width";
+ shortSizeName = "w";
+ }
+
+ handleEl = ctrl.getEl('handle');
+ maxHandlePos = (ctrl.layoutRect()[shortSizeName] || 100) - DomUtils.getSize(handleEl)[sizeName];
+
+ styleValue = (maxHandlePos * ((value - ctrl._minValue) / (ctrl._maxValue - ctrl._minValue))) + 'px';
+ handleEl.style[stylePosName] = styleValue;
+ handleEl.style.height = ctrl.layoutRect().h + 'px';
+
+ setAriaProp(handleEl, 'valuenow', value);
+ setAriaProp(handleEl, 'valuetext', '' + ctrl.settings.previewFilter(value));
+ setAriaProp(handleEl, 'valuemin', ctrl._minValue);
+ setAriaProp(handleEl, 'valuemax', ctrl._maxValue);
+ }
+
+ return Widget.extend({
+ init: function(settings) {
+ var self = this;
+
+ if (!settings.previewFilter) {
+ settings.previewFilter = function(value) {
+ return Math.round(value * 100) / 100.0;
+ };
+ }
+
+ self._super(settings);
+ self.classes.add('slider');
+
+ if (settings.orientation == "v") {
+ self.classes.add('vertical');
+ }
+
+ self._minValue = settings.minValue || 0;
+ self._maxValue = settings.maxValue || 100;
+ self._initValue = self.state.get('value');
+ },
+
+ renderHtml: function() {
+ var self = this, id = self._id, prefix = self.classPrefix;
+
+ return (
+ ''
+ );
+ },
+
+ reset: function() {
+ this.value(this._initValue).repaint();
+ },
+
+ postRender: function() {
+ var self = this, minValue, maxValue, screenCordName,
+ stylePosName, sizeName, shortSizeName;
+
+ function toFraction(min, max, val) {
+ return (val + min) / (max - min);
+ }
+
+ function fromFraction(min, max, val) {
+ return (val * (max - min)) - min;
+ }
+
+ function handleKeyboard(minValue, maxValue) {
+ function alter(delta) {
+ var value;
+
+ value = self.value();
+ value = fromFraction(minValue, maxValue, toFraction(minValue, maxValue, value) + (delta * 0.05));
+ value = constrain(value, minValue, maxValue);
+
+ self.value(value);
+
+ self.fire('dragstart', {value: value});
+ self.fire('drag', {value: value});
+ self.fire('dragend', {value: value});
+ }
+
+ self.on('keydown', function(e) {
+ switch (e.keyCode) {
+ case 37:
+ case 38:
+ alter(-1);
+ break;
+
+ case 39:
+ case 40:
+ alter(1);
+ break;
+ }
+ });
+ }
+
+ function handleDrag(minValue, maxValue, handleEl) {
+ var startPos, startHandlePos, maxHandlePos, handlePos, value;
+
+ self._dragHelper = new DragHelper(self._id, {
+ handle: self._id + "-handle",
+
+ start: function(e) {
+ startPos = e[screenCordName];
+ startHandlePos = parseInt(self.getEl('handle').style[stylePosName], 10);
+ maxHandlePos = (self.layoutRect()[shortSizeName] || 100) - DomUtils.getSize(handleEl)[sizeName];
+ self.fire('dragstart', {value: value});
+ },
+
+ drag: function(e) {
+ var delta = e[screenCordName] - startPos;
+
+ handlePos = constrain(startHandlePos + delta, 0, maxHandlePos);
+ handleEl.style[stylePosName] = handlePos + 'px';
+
+ value = minValue + (handlePos / maxHandlePos) * (maxValue - minValue);
+ self.value(value);
+
+ self.tooltip().text('' + self.settings.previewFilter(value)).show().moveRel(handleEl, 'bc tc');
+
+ self.fire('drag', {value: value});
+ },
+
+ stop: function() {
+ self.tooltip().hide();
+ self.fire('dragend', {value: value});
+ }
+ });
+ }
+
+ minValue = self._minValue;
+ maxValue = self._maxValue;
+
+ if (self.settings.orientation == "v") {
+ screenCordName = "screenY";
+ stylePosName = "top";
+ sizeName = "height";
+ shortSizeName = "h";
+ } else {
+ screenCordName = "screenX";
+ stylePosName = "left";
+ sizeName = "width";
+ shortSizeName = "w";
+ }
+
+ self._super();
+
+ handleKeyboard(minValue, maxValue, self.getEl('handle'));
+ handleDrag(minValue, maxValue, self.getEl('handle'));
+ },
+
+ repaint: function() {
+ this._super();
+ updateSliderHandle(this, this.value());
+ },
+
+ bindStates: function() {
+ var self = this;
+
+ self.state.on('change:value', function(e) {
+ updateSliderHandle(self, e.value);
+ });
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/Spacer.js
+
+/**
+ * Spacer.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a spacer. This control is used in flex layouts for example.
+ *
+ * @-x-less Spacer.less
+ * @class tinymce.ui.Spacer
+ * @extends tinymce.ui.Widget
+ */
+define("tinymce/ui/Spacer", [
+ "tinymce/ui/Widget"
+], function(Widget) {
+ "use strict";
+
+ return Widget.extend({
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this;
+
+ self.classes.add('spacer');
+ self.canFocus = false;
+
+ return '';
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/SplitButton.js
+
+/**
+ * SplitButton.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a split button.
+ *
+ * @-x-less SplitButton.less
+ * @class tinymce.ui.SplitButton
+ * @extends tinymce.ui.Button
+ */
+define("tinymce/ui/SplitButton", [
+ "tinymce/ui/MenuButton",
+ "tinymce/ui/DomUtils",
+ "tinymce/dom/DomQuery"
+], function(MenuButton, DomUtils, $) {
+ return MenuButton.extend({
+ Defaults: {
+ classes: "widget btn splitbtn",
+ role: "button"
+ },
+
+ /**
+ * Repaints the control after a layout operation.
+ *
+ * @method repaint
+ */
+ repaint: function() {
+ var self = this, elm = self.getEl(), rect = self.layoutRect(), mainButtonElm, menuButtonElm;
+
+ self._super();
+
+ mainButtonElm = elm.firstChild;
+ menuButtonElm = elm.lastChild;
+
+ $(mainButtonElm).css({
+ width: rect.w - DomUtils.getSize(menuButtonElm).width,
+ height: rect.h - 2
+ });
+
+ $(menuButtonElm).css({
+ height: rect.h - 2
+ });
+
+ return self;
+ },
+
+ /**
+ * Sets the active menu state.
+ *
+ * @private
+ */
+ activeMenu: function(state) {
+ var self = this;
+
+ $(self.getEl().lastChild).toggleClass(self.classPrefix + 'active', state);
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, id = self._id, prefix = self.classPrefix, image;
+ var icon = self.state.get('icon'), text = self.state.get('text'),
+ textHtml = '';
+
+ image = self.settings.image;
+ if (image) {
+ icon = 'none';
+
+ // Support for [high dpi, low dpi] image sources
+ if (typeof image != "string") {
+ image = window.getSelection ? image[0] : image[1];
+ }
+
+ image = ' style="background-image: url(\'' + image + '\')"';
+ } else {
+ image = '';
+ }
+
+ icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+
+ if (text) {
+ self.classes.add('btn-has-text');
+ textHtml = '' + self.encode(text) + '';
+ }
+
+ return (
+ '' +
+ '' +
+ '' +
+ '
'
+ );
+ },
+
+ /**
+ * Called after the control has been rendered.
+ *
+ * @method postRender
+ */
+ postRender: function() {
+ var self = this, onClickHandler = self.settings.onclick;
+
+ self.on('click', function(e) {
+ var node = e.target;
+
+ if (e.control == this) {
+ // Find clicks that is on the main button
+ while (node) {
+ if ((e.aria && e.aria.key != 'down') || (node.nodeName == 'BUTTON' && node.className.indexOf('open') == -1)) {
+ e.stopImmediatePropagation();
+
+ if (onClickHandler) {
+ onClickHandler.call(this, e);
+ }
+
+ return;
+ }
+
+ node = node.parentNode;
+ }
+ }
+ });
+
+ delete self.settings.onclick;
+
+ return self._super();
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/StackLayout.js
+
+/**
+ * StackLayout.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This layout uses the browsers layout when the items are blocks.
+ *
+ * @-x-less StackLayout.less
+ * @class tinymce.ui.StackLayout
+ * @extends tinymce.ui.FlowLayout
+ */
+define("tinymce/ui/StackLayout", [
+ "tinymce/ui/FlowLayout"
+], function(FlowLayout) {
+ "use strict";
+
+ return FlowLayout.extend({
+ Defaults: {
+ containerClass: 'stack-layout',
+ controlClass: 'stack-layout-item',
+ endClass: 'break'
+ },
+
+ isNative: function() {
+ return true;
+ }
+ });
+});
+
+// Included from: js/tinymce/classes/ui/TabPanel.js
+
+/**
+ * TabPanel.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Creates a tab panel control.
+ *
+ * @-x-less TabPanel.less
+ * @class tinymce.ui.TabPanel
+ * @extends tinymce.ui.Panel
+ *
+ * @setting {Number} activeTab Active tab index.
+ */
+define("tinymce/ui/TabPanel", [
+ "tinymce/ui/Panel",
+ "tinymce/dom/DomQuery",
+ "tinymce/ui/DomUtils"
+], function(Panel, $, DomUtils) {
+ "use strict";
+
+ return Panel.extend({
+ Defaults: {
+ layout: 'absolute',
+ defaults: {
+ type: 'panel'
+ }
+ },
+
+ /**
+ * Activates the specified tab by index.
+ *
+ * @method activateTab
+ * @param {Number} idx Index of the tab to activate.
+ */
+ activateTab: function(idx) {
+ var activeTabElm;
+
+ if (this.activeTabId) {
+ activeTabElm = this.getEl(this.activeTabId);
+ $(activeTabElm).removeClass(this.classPrefix + 'active');
+ activeTabElm.setAttribute('aria-selected', "false");
+ }
+
+ this.activeTabId = 't' + idx;
+
+ activeTabElm = this.getEl('t' + idx);
+ activeTabElm.setAttribute('aria-selected', "true");
+ $(activeTabElm).addClass(this.classPrefix + 'active');
+
+ this.items()[idx].show().fire('showtab');
+ this.reflow();
+
+ this.items().each(function(item, i) {
+ if (idx != i) {
+ item.hide();
+ }
+ });
+ },
+
+ /**
+ * Renders the control as a HTML string.
+ *
+ * @method renderHtml
+ * @return {String} HTML representing the control.
+ */
+ renderHtml: function() {
+ var self = this, layout = self._layout, tabsHtml = '', prefix = self.classPrefix;
+
+ self.preRender();
+ layout.preRender(self);
+
+ self.items().each(function(ctrl, i) {
+ var id = self._id + '-t' + i;
+
+ ctrl.aria('role', 'tabpanel');
+ ctrl.aria('labelledby', id);
+
+ tabsHtml += (
+ '' +
+ self.encode(ctrl.settings.title) +
+ '
'
+ );
+ });
+
+ return (
+ '' +
+ '
' +
+ tabsHtml +
+ '
' +
+ '
' +
+ layout.renderHtml(self) +
+ '
' +
+ '