1682 lines
44 KiB
JavaScript
1682 lines
44 KiB
JavaScript
(function () {
|
|
|
|
var defs = {}; // id -> {dependencies, definition, instance (possibly undefined)}
|
|
|
|
// Used when there is no 'main' module.
|
|
// The name is probably (hopefully) unique so minification removes for releases.
|
|
var register_3795 = function (id) {
|
|
var module = dem(id);
|
|
var fragments = id.split('.');
|
|
var target = Function('return this;')();
|
|
for (var i = 0; i < fragments.length - 1; ++i) {
|
|
if (target[fragments[i]] === undefined)
|
|
target[fragments[i]] = {};
|
|
target = target[fragments[i]];
|
|
}
|
|
target[fragments[fragments.length - 1]] = module;
|
|
};
|
|
|
|
var instantiate = function (id) {
|
|
var actual = defs[id];
|
|
var dependencies = actual.deps;
|
|
var definition = actual.defn;
|
|
var len = dependencies.length;
|
|
var instances = new Array(len);
|
|
for (var i = 0; i < len; ++i)
|
|
instances[i] = dem(dependencies[i]);
|
|
var defResult = definition.apply(null, instances);
|
|
if (defResult === undefined)
|
|
throw 'module [' + id + '] returned undefined';
|
|
actual.instance = defResult;
|
|
};
|
|
|
|
var def = function (id, dependencies, definition) {
|
|
if (typeof id !== 'string')
|
|
throw 'module id must be a string';
|
|
else if (dependencies === undefined)
|
|
throw 'no dependencies for ' + id;
|
|
else if (definition === undefined)
|
|
throw 'no definition function for ' + id;
|
|
defs[id] = {
|
|
deps: dependencies,
|
|
defn: definition,
|
|
instance: undefined
|
|
};
|
|
};
|
|
|
|
var dem = function (id) {
|
|
var actual = defs[id];
|
|
if (actual === undefined)
|
|
throw 'module [' + id + '] was undefined';
|
|
else if (actual.instance === undefined)
|
|
instantiate(id);
|
|
return actual.instance;
|
|
};
|
|
|
|
var req = function (ids, callback) {
|
|
var len = ids.length;
|
|
var instances = new Array(len);
|
|
for (var i = 0; i < len; ++i)
|
|
instances.push(dem(ids[i]));
|
|
callback.apply(null, callback);
|
|
};
|
|
|
|
var ephox = {};
|
|
|
|
ephox.bolt = {
|
|
module: {
|
|
api: {
|
|
define: def,
|
|
require: req,
|
|
demand: dem
|
|
}
|
|
}
|
|
};
|
|
|
|
var define = def;
|
|
var require = req;
|
|
var demand = dem;
|
|
// this helps with minificiation when using a lot of global references
|
|
var defineGlobal = function (id, ref) {
|
|
define(id, [], function () { return ref; });
|
|
};
|
|
/*jsc
|
|
["tinymce.themes.modern.Theme","global!window","tinymce.core.AddOnManager","tinymce.core.EditorManager","tinymce.core.Env","tinymce.core.ui.Api","tinymce.themes.modern.modes.Iframe","tinymce.themes.modern.modes.Inline","tinymce.themes.modern.ui.ProgressState","tinymce.themes.modern.ui.Resize","global!tinymce.util.Tools.resolve","tinymce.core.dom.DOMUtils","tinymce.core.ui.Factory","tinymce.core.util.Tools","tinymce.themes.modern.ui.A11y","tinymce.themes.modern.ui.Branding","tinymce.themes.modern.ui.ContextToolbars","tinymce.themes.modern.ui.Menubar","tinymce.themes.modern.ui.Sidebar","tinymce.themes.modern.ui.SkinLoaded","tinymce.themes.modern.ui.Toolbar","tinymce.core.ui.FloatPanel","tinymce.core.ui.Throbber","tinymce.core.util.Delay","tinymce.core.geom.Rect"]
|
|
jsc*/
|
|
defineGlobal("global!window", window);
|
|
defineGlobal("global!tinymce.util.Tools.resolve", tinymce.util.Tools.resolve);
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.AddOnManager',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.AddOnManager');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.EditorManager',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.EditorManager');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.Env',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.Env');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.ui.Api',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.ui.Api');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.dom.DOMUtils',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.dom.DOMUtils');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.ui.Factory',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.ui.Factory');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.util.Tools',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.util.Tools');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* A11y.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.A11y',
|
|
[
|
|
],
|
|
function () {
|
|
var focus = function (panel, type) {
|
|
return function () {
|
|
var item = panel.find(type)[0];
|
|
|
|
if (item) {
|
|
item.focus(true);
|
|
}
|
|
};
|
|
};
|
|
|
|
var addKeys = function (editor, panel) {
|
|
editor.shortcuts.add('Alt+F9', '', focus(panel, 'menubar'));
|
|
editor.shortcuts.add('Alt+F10,F10', '', focus(panel, 'toolbar'));
|
|
editor.shortcuts.add('Alt+F11', '', focus(panel, 'elementpath'));
|
|
panel.on('cancel', function () {
|
|
editor.focus();
|
|
});
|
|
};
|
|
|
|
return {
|
|
addKeys: addKeys
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Branding.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.Branding',
|
|
[
|
|
'tinymce.core.dom.DOMUtils'
|
|
],
|
|
function (DOMUtils) {
|
|
var DOM = DOMUtils.DOM;
|
|
|
|
var reposition = function (editor, poweredByElm, hasStatusbar) {
|
|
return function () {
|
|
var iframeWidth = editor.getContentAreaContainer().querySelector('iframe').offsetWidth;
|
|
var scrollbarWidth = Math.max(iframeWidth - editor.getDoc().documentElement.offsetWidth, 0);
|
|
|
|
DOM.setStyle(poweredByElm, 'right', scrollbarWidth + 'px');
|
|
if (hasStatusbar) {
|
|
DOM.setStyle(poweredByElm, 'top', '-16px');
|
|
} else {
|
|
DOM.setStyle(poweredByElm, 'bottom', '1px');
|
|
}
|
|
};
|
|
};
|
|
|
|
var hide = function (poweredByElm) {
|
|
return function () {
|
|
DOM.hide(poweredByElm);
|
|
};
|
|
};
|
|
|
|
var setupReposition = function (editor, poweredByElm, hasStatusbar) {
|
|
reposition(editor, poweredByElm, hasStatusbar)();
|
|
editor.on('NodeChange ResizeEditor', reposition(editor, poweredByElm, hasStatusbar));
|
|
};
|
|
|
|
var appendToStatusbar = function (editor, poweredByElm, statusbarElm) {
|
|
statusbarElm.appendChild(poweredByElm);
|
|
setupReposition(editor, poweredByElm, true);
|
|
};
|
|
|
|
var appendToContainer = function (editor, poweredByElm) {
|
|
editor.getContainer().appendChild(poweredByElm);
|
|
setupReposition(editor, poweredByElm, false);
|
|
};
|
|
|
|
var setupEventListeners = function (editor) {
|
|
editor.on('SkinLoaded', function () {
|
|
var poweredByElm = DOM.create('div', { 'class': 'mce-branding-powered-by' });
|
|
var statusbarElm = editor.getContainer().querySelector('.mce-statusbar');
|
|
|
|
if (statusbarElm) {
|
|
appendToStatusbar(editor, poweredByElm, statusbarElm);
|
|
} else {
|
|
appendToContainer(editor, poweredByElm);
|
|
}
|
|
|
|
DOM.bind(poweredByElm, 'click', hide(poweredByElm));
|
|
});
|
|
};
|
|
|
|
var setup = function (editor) {
|
|
if (editor.settings.branding !== false) {
|
|
setupEventListeners(editor);
|
|
}
|
|
};
|
|
|
|
return {
|
|
setup: setup
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.util.Delay',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.util.Delay');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.geom.Rect',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.geom.Rect');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Toolbar.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.Toolbar',
|
|
[
|
|
'tinymce.core.util.Tools',
|
|
'tinymce.core.ui.Factory'
|
|
],
|
|
function (Tools, Factory) {
|
|
var defaultToolbar = "undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | " +
|
|
"bullist numlist outdent indent | link image";
|
|
|
|
var createToolbar = function (editor, items, size) {
|
|
var toolbarItems = [], buttonGroup;
|
|
|
|
if (!items) {
|
|
return;
|
|
}
|
|
|
|
Tools.each(items.split(/[ ,]/), function (item) {
|
|
var itemName;
|
|
|
|
var bindSelectorChanged = function () {
|
|
var selection = editor.selection;
|
|
|
|
if (item.settings.stateSelector) {
|
|
selection.selectorChanged(item.settings.stateSelector, function (state) {
|
|
item.active(state);
|
|
}, true);
|
|
}
|
|
|
|
if (item.settings.disabledStateSelector) {
|
|
selection.selectorChanged(item.settings.disabledStateSelector, function (state) {
|
|
item.disabled(state);
|
|
});
|
|
}
|
|
};
|
|
|
|
if (item == "|") {
|
|
buttonGroup = null;
|
|
} else {
|
|
if (!buttonGroup) {
|
|
buttonGroup = { type: 'buttongroup', items: [] };
|
|
toolbarItems.push(buttonGroup);
|
|
}
|
|
|
|
if (editor.buttons[item]) {
|
|
// TODO: Move control creation to some UI class
|
|
itemName = item;
|
|
item = editor.buttons[itemName];
|
|
|
|
if (typeof item == "function") {
|
|
item = item();
|
|
}
|
|
|
|
item.type = item.type || 'button';
|
|
item.size = size;
|
|
|
|
item = Factory.create(item);
|
|
buttonGroup.items.push(item);
|
|
|
|
if (editor.initialized) {
|
|
bindSelectorChanged();
|
|
} else {
|
|
editor.on('init', bindSelectorChanged);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
return {
|
|
type: 'toolbar',
|
|
layout: 'flow',
|
|
items: toolbarItems
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Creates the toolbars from config and returns a toolbar array.
|
|
*
|
|
* @param {String} size Optional toolbar item size.
|
|
* @return {Array} Array with toolbars.
|
|
*/
|
|
var createToolbars = function (editor, size) {
|
|
var toolbars = [], settings = editor.settings;
|
|
|
|
var addToolbar = function (items) {
|
|
if (items) {
|
|
toolbars.push(createToolbar(editor, items, size));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Convert toolbar array to multiple options
|
|
if (Tools.isArray(settings.toolbar)) {
|
|
// Empty toolbar array is the same as a disabled toolbar
|
|
if (settings.toolbar.length === 0) {
|
|
return;
|
|
}
|
|
|
|
Tools.each(settings.toolbar, function (toolbar, i) {
|
|
settings["toolbar" + (i + 1)] = toolbar;
|
|
});
|
|
|
|
delete settings.toolbar;
|
|
}
|
|
|
|
// Generate toolbar<n>
|
|
for (var i = 1; i < 10; i++) {
|
|
if (!addToolbar(settings["toolbar" + i])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Generate toolbar or default toolbar unless it's disabled
|
|
if (!toolbars.length && settings.toolbar !== false) {
|
|
addToolbar(settings.toolbar || defaultToolbar);
|
|
}
|
|
|
|
if (toolbars.length) {
|
|
return {
|
|
type: 'panel',
|
|
layout: 'stack',
|
|
classes: "toolbar-grp",
|
|
ariaRoot: true,
|
|
ariaRemember: true,
|
|
items: toolbars
|
|
};
|
|
}
|
|
};
|
|
|
|
return {
|
|
createToolbar: createToolbar,
|
|
createToolbars: createToolbars
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ContextToolbars.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.ContextToolbars',
|
|
[
|
|
'tinymce.core.dom.DOMUtils',
|
|
'tinymce.core.util.Tools',
|
|
'tinymce.core.util.Delay',
|
|
'tinymce.core.ui.Factory',
|
|
'tinymce.core.geom.Rect',
|
|
'tinymce.themes.modern.ui.Toolbar'
|
|
],
|
|
function (DOMUtils, Tools, Delay, Factory, Rect, Toolbar) {
|
|
var DOM = DOMUtils.DOM;
|
|
|
|
var toClientRect = function (geomRect) {
|
|
return {
|
|
left: geomRect.x,
|
|
top: geomRect.y,
|
|
width: geomRect.w,
|
|
height: geomRect.h,
|
|
right: geomRect.x + geomRect.w,
|
|
bottom: geomRect.y + geomRect.h
|
|
};
|
|
};
|
|
|
|
var hideAllFloatingPanels = function (editor) {
|
|
Tools.each(editor.contextToolbars, function (toolbar) {
|
|
if (toolbar.panel) {
|
|
toolbar.panel.hide();
|
|
}
|
|
});
|
|
};
|
|
|
|
var movePanelTo = function (panel, pos) {
|
|
panel.moveTo(pos.left, pos.top);
|
|
};
|
|
|
|
var togglePositionClass = function (panel, relPos, predicate) {
|
|
relPos = relPos ? relPos.substr(0, 2) : '';
|
|
|
|
Tools.each({
|
|
t: 'down',
|
|
b: 'up'
|
|
}, function (cls, pos) {
|
|
panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(0, 1)));
|
|
});
|
|
|
|
Tools.each({
|
|
l: 'left',
|
|
r: 'right'
|
|
}, function (cls, pos) {
|
|
panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(1, 1)));
|
|
});
|
|
};
|
|
|
|
var userConstrain = function (handler, x, y, elementRect, contentAreaRect, panelRect) {
|
|
panelRect = toClientRect({ x: x, y: y, w: panelRect.w, h: panelRect.h });
|
|
|
|
if (handler) {
|
|
panelRect = handler({
|
|
elementRect: toClientRect(elementRect),
|
|
contentAreaRect: toClientRect(contentAreaRect),
|
|
panelRect: panelRect
|
|
});
|
|
}
|
|
|
|
return panelRect;
|
|
};
|
|
|
|
var addContextualToolbars = function (editor) {
|
|
var scrollContainer, settings = editor.settings;
|
|
|
|
var getContextToolbars = function () {
|
|
return editor.contextToolbars || [];
|
|
};
|
|
|
|
var getElementRect = function (elm) {
|
|
var pos, targetRect, root;
|
|
|
|
pos = DOM.getPos(editor.getContentAreaContainer());
|
|
targetRect = editor.dom.getRect(elm);
|
|
root = editor.dom.getRoot();
|
|
|
|
// Adjust targetPos for scrolling in the editor
|
|
if (root.nodeName === 'BODY') {
|
|
targetRect.x -= root.ownerDocument.documentElement.scrollLeft || root.scrollLeft;
|
|
targetRect.y -= root.ownerDocument.documentElement.scrollTop || root.scrollTop;
|
|
}
|
|
|
|
targetRect.x += pos.x;
|
|
targetRect.y += pos.y;
|
|
|
|
return targetRect;
|
|
};
|
|
|
|
var reposition = function (match, shouldShow) {
|
|
var relPos, panelRect, elementRect, contentAreaRect, panel, relRect, testPositions, smallElementWidthThreshold;
|
|
var handler = settings.inline_toolbar_position_handler;
|
|
|
|
if (editor.removed) {
|
|
return;
|
|
}
|
|
|
|
if (!match || !match.toolbar.panel) {
|
|
hideAllFloatingPanels(editor);
|
|
return;
|
|
}
|
|
|
|
testPositions = [
|
|
'bc-tc', 'tc-bc',
|
|
'tl-bl', 'bl-tl',
|
|
'tr-br', 'br-tr'
|
|
];
|
|
|
|
panel = match.toolbar.panel;
|
|
|
|
// Only show the panel on some events not for example nodeChange since that fires when context menu is opened
|
|
if (shouldShow) {
|
|
panel.show();
|
|
}
|
|
|
|
elementRect = getElementRect(match.element);
|
|
panelRect = DOM.getRect(panel.getEl());
|
|
contentAreaRect = DOM.getRect(editor.getContentAreaContainer() || editor.getBody());
|
|
smallElementWidthThreshold = 25;
|
|
|
|
if (DOM.getStyle(match.element, 'display', true) !== 'inline') {
|
|
// We need to use these instead of the rect values since the style
|
|
// size properites might not be the same as the real size for a table
|
|
elementRect.w = match.element.clientWidth;
|
|
elementRect.h = match.element.clientHeight;
|
|
}
|
|
|
|
if (!editor.inline) {
|
|
contentAreaRect.w = editor.getDoc().documentElement.offsetWidth;
|
|
}
|
|
|
|
// Inflate the elementRect so it doesn't get placed above resize handles
|
|
if (editor.selection.controlSelection.isResizable(match.element) && elementRect.w < smallElementWidthThreshold) {
|
|
elementRect = Rect.inflate(elementRect, 0, 8);
|
|
}
|
|
|
|
relPos = Rect.findBestRelativePosition(panelRect, elementRect, contentAreaRect, testPositions);
|
|
elementRect = Rect.clamp(elementRect, contentAreaRect);
|
|
|
|
if (relPos) {
|
|
relRect = Rect.relativePosition(panelRect, elementRect, relPos);
|
|
movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect));
|
|
} else {
|
|
// Allow overflow below the editor to avoid placing toolbars ontop of tables
|
|
contentAreaRect.h += panelRect.h;
|
|
|
|
elementRect = Rect.intersect(contentAreaRect, elementRect);
|
|
if (elementRect) {
|
|
relPos = Rect.findBestRelativePosition(panelRect, elementRect, contentAreaRect, [
|
|
'bc-tc', 'bl-tl', 'br-tr'
|
|
]);
|
|
|
|
if (relPos) {
|
|
relRect = Rect.relativePosition(panelRect, elementRect, relPos);
|
|
movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect));
|
|
} else {
|
|
movePanelTo(panel, userConstrain(handler, elementRect.x, elementRect.y, elementRect, contentAreaRect, panelRect));
|
|
}
|
|
} else {
|
|
panel.hide();
|
|
}
|
|
}
|
|
|
|
togglePositionClass(panel, relPos, function (pos1, pos2) {
|
|
return pos1 === pos2;
|
|
});
|
|
|
|
//drawRect(contentAreaRect, 'blue');
|
|
//drawRect(elementRect, 'red');
|
|
//drawRect(panelRect, 'green');
|
|
};
|
|
|
|
var repositionHandler = function (show) {
|
|
return function () {
|
|
var execute = function () {
|
|
if (editor.selection) {
|
|
reposition(findFrontMostMatch(editor.selection.getNode()), show);
|
|
}
|
|
};
|
|
|
|
Delay.requestAnimationFrame(execute);
|
|
};
|
|
};
|
|
|
|
var bindScrollEvent = function () {
|
|
if (!scrollContainer) {
|
|
scrollContainer = editor.selection.getScrollContainer() || editor.getWin();
|
|
DOM.bind(scrollContainer, 'scroll', repositionHandler(true));
|
|
|
|
editor.on('remove', function () {
|
|
DOM.unbind(scrollContainer, 'scroll');
|
|
});
|
|
}
|
|
};
|
|
|
|
var showContextToolbar = function (match) {
|
|
var panel;
|
|
|
|
if (match.toolbar.panel) {
|
|
match.toolbar.panel.show();
|
|
reposition(match);
|
|
return;
|
|
}
|
|
|
|
bindScrollEvent();
|
|
|
|
panel = Factory.create({
|
|
type: 'floatpanel',
|
|
role: 'dialog',
|
|
classes: 'tinymce tinymce-inline arrow',
|
|
ariaLabel: 'Inline toolbar',
|
|
layout: 'flex',
|
|
direction: 'column',
|
|
align: 'stretch',
|
|
autohide: false,
|
|
autofix: true,
|
|
fixed: true,
|
|
border: 1,
|
|
items: Toolbar.createToolbar(editor, match.toolbar.items),
|
|
oncancel: function () {
|
|
editor.focus();
|
|
}
|
|
});
|
|
|
|
match.toolbar.panel = panel;
|
|
panel.renderTo(document.body).reflow();
|
|
reposition(match);
|
|
};
|
|
|
|
var hideAllContextToolbars = function () {
|
|
Tools.each(getContextToolbars(), function (toolbar) {
|
|
if (toolbar.panel) {
|
|
toolbar.panel.hide();
|
|
}
|
|
});
|
|
};
|
|
|
|
var findFrontMostMatch = function (targetElm) {
|
|
var i, y, parentsAndSelf, toolbars = getContextToolbars();
|
|
|
|
parentsAndSelf = editor.$(targetElm).parents().add(targetElm);
|
|
for (i = parentsAndSelf.length - 1; i >= 0; i--) {
|
|
for (y = toolbars.length - 1; y >= 0; y--) {
|
|
if (toolbars[y].predicate(parentsAndSelf[i])) {
|
|
return {
|
|
toolbar: toolbars[y],
|
|
element: parentsAndSelf[i]
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
editor.on('click keyup setContent ObjectResized', function (e) {
|
|
// Only act on partial inserts
|
|
if (e.type === 'setcontent' && !e.selection) {
|
|
return;
|
|
}
|
|
|
|
// Needs to be delayed to avoid Chrome img focus out bug
|
|
Delay.setEditorTimeout(editor, function () {
|
|
var match;
|
|
|
|
match = findFrontMostMatch(editor.selection.getNode());
|
|
if (match) {
|
|
hideAllContextToolbars();
|
|
showContextToolbar(match);
|
|
} else {
|
|
hideAllContextToolbars();
|
|
}
|
|
});
|
|
});
|
|
|
|
editor.on('blur hide contextmenu', hideAllContextToolbars);
|
|
|
|
editor.on('ObjectResizeStart', function () {
|
|
var match = findFrontMostMatch(editor.selection.getNode());
|
|
|
|
if (match && match.toolbar.panel) {
|
|
match.toolbar.panel.hide();
|
|
}
|
|
});
|
|
|
|
editor.on('ResizeEditor ResizeWindow', repositionHandler(true));
|
|
editor.on('nodeChange', repositionHandler(false));
|
|
|
|
editor.on('remove', function () {
|
|
Tools.each(getContextToolbars(), function (toolbar) {
|
|
if (toolbar.panel) {
|
|
toolbar.panel.remove();
|
|
}
|
|
});
|
|
|
|
editor.contextToolbars = {};
|
|
});
|
|
|
|
editor.shortcuts.add('ctrl+shift+e > ctrl+shift+p', '', function () {
|
|
var match = findFrontMostMatch(editor.selection.getNode());
|
|
if (match && match.toolbar.panel) {
|
|
match.toolbar.panel.items()[0].focus();
|
|
}
|
|
});
|
|
};
|
|
|
|
return {
|
|
addContextualToolbars: addContextualToolbars
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Menubar.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.Menubar',
|
|
[
|
|
'tinymce.core.util.Tools'
|
|
],
|
|
function (Tools) {
|
|
var defaultMenus = {
|
|
file: { title: 'File', items: 'newdocument' },
|
|
edit: { title: 'Edit', items: 'undo redo | cut copy paste pastetext | selectall' },
|
|
insert: { title: 'Insert', items: '|' },
|
|
view: { title: 'View', items: 'visualaid |' },
|
|
format: { title: 'Format', items: 'bold italic underline strikethrough superscript subscript | formats | removeformat' },
|
|
table: { title: 'Table' },
|
|
tools: { title: 'Tools' }
|
|
};
|
|
|
|
var createMenuItem = function (menuItems, name) {
|
|
var menuItem;
|
|
|
|
if (name == '|') {
|
|
return { text: '|' };
|
|
}
|
|
|
|
menuItem = menuItems[name];
|
|
|
|
return menuItem;
|
|
};
|
|
|
|
var createMenu = function (editorMenuItems, settings, context) {
|
|
var menuButton, menu, menuItems, isUserDefined, removedMenuItems;
|
|
|
|
removedMenuItems = Tools.makeMap((settings.removed_menuitems || '').split(/[ ,]/));
|
|
|
|
// User defined menu
|
|
if (settings.menu) {
|
|
menu = settings.menu[context];
|
|
isUserDefined = true;
|
|
} else {
|
|
menu = defaultMenus[context];
|
|
}
|
|
|
|
if (menu) {
|
|
menuButton = { text: menu.title };
|
|
menuItems = [];
|
|
|
|
// Default/user defined items
|
|
Tools.each((menu.items || '').split(/[ ,]/), function (item) {
|
|
var menuItem = createMenuItem(editorMenuItems, item);
|
|
|
|
if (menuItem && !removedMenuItems[item]) {
|
|
menuItems.push(createMenuItem(editorMenuItems, item));
|
|
}
|
|
});
|
|
|
|
// Added though context
|
|
if (!isUserDefined) {
|
|
Tools.each(editorMenuItems, function (menuItem) {
|
|
if (menuItem.context == context) {
|
|
if (menuItem.separator == 'before') {
|
|
menuItems.push({ text: '|' });
|
|
}
|
|
|
|
if (menuItem.prependToContext) {
|
|
menuItems.unshift(menuItem);
|
|
} else {
|
|
menuItems.push(menuItem);
|
|
}
|
|
|
|
if (menuItem.separator == 'after') {
|
|
menuItems.push({ text: '|' });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
for (var i = 0; i < menuItems.length; i++) {
|
|
if (menuItems[i].text == '|') {
|
|
if (i === 0 || i == menuItems.length - 1) {
|
|
menuItems.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
menuButton.menu = menuItems;
|
|
|
|
if (!menuButton.menu.length) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return menuButton;
|
|
};
|
|
|
|
var createMenuButtons = function (editor) {
|
|
var name, menuButtons = [], settings = editor.settings;
|
|
|
|
var defaultMenuBar = [];
|
|
if (settings.menu) {
|
|
for (name in settings.menu) {
|
|
defaultMenuBar.push(name);
|
|
}
|
|
} else {
|
|
for (name in defaultMenus) {
|
|
defaultMenuBar.push(name);
|
|
}
|
|
}
|
|
|
|
var enabledMenuNames = typeof settings.menubar == "string" ? settings.menubar.split(/[ ,]/) : defaultMenuBar;
|
|
for (var i = 0; i < enabledMenuNames.length; i++) {
|
|
var menu = enabledMenuNames[i];
|
|
menu = createMenu(editor.menuItems, editor.settings, menu);
|
|
|
|
if (menu) {
|
|
menuButtons.push(menu);
|
|
}
|
|
}
|
|
|
|
return menuButtons;
|
|
};
|
|
|
|
return {
|
|
createMenuButtons: createMenuButtons
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Resize.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.Resize',
|
|
[
|
|
'tinymce.core.dom.DOMUtils'
|
|
],
|
|
function (DOMUtils) {
|
|
var DOM = DOMUtils.DOM;
|
|
var getSize = function (elm) {
|
|
return {
|
|
width: elm.clientWidth,
|
|
height: elm.clientHeight
|
|
};
|
|
};
|
|
|
|
var resizeTo = function (editor, width, height) {
|
|
var containerElm, iframeElm, containerSize, iframeSize, settings = editor.settings;
|
|
|
|
containerElm = editor.getContainer();
|
|
iframeElm = editor.getContentAreaContainer().firstChild;
|
|
containerSize = getSize(containerElm);
|
|
iframeSize = getSize(iframeElm);
|
|
|
|
if (width !== null) {
|
|
width = Math.max(settings.min_width || 100, width);
|
|
width = Math.min(settings.max_width || 0xFFFF, width);
|
|
|
|
DOM.setStyle(containerElm, 'width', width + (containerSize.width - iframeSize.width));
|
|
DOM.setStyle(iframeElm, 'width', width);
|
|
}
|
|
|
|
height = Math.max(settings.min_height || 100, height);
|
|
height = Math.min(settings.max_height || 0xFFFF, height);
|
|
DOM.setStyle(iframeElm, 'height', height);
|
|
|
|
editor.fire('ResizeEditor');
|
|
};
|
|
|
|
var resizeBy = function (editor, dw, dh) {
|
|
var elm = editor.getContentAreaContainer();
|
|
resizeTo(editor, elm.clientWidth + dw, elm.clientHeight + dh);
|
|
};
|
|
|
|
return {
|
|
resizeTo: resizeTo,
|
|
resizeBy: resizeBy
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Sidebar.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.Sidebar',
|
|
[
|
|
'tinymce.core.util.Tools',
|
|
'tinymce.core.ui.Factory',
|
|
'tinymce.core.Env'
|
|
],
|
|
function (Tools, Factory, Env) {
|
|
var api = function (elm) {
|
|
return {
|
|
element: function () {
|
|
return elm;
|
|
}
|
|
};
|
|
};
|
|
|
|
var trigger = function (sidebar, panel, callbackName) {
|
|
var callback = sidebar.settings[callbackName];
|
|
if (callback) {
|
|
callback(api(panel.getEl('body')));
|
|
}
|
|
};
|
|
|
|
var hidePanels = function (name, container, sidebars) {
|
|
Tools.each(sidebars, function (sidebar) {
|
|
var panel = container.items().filter('#' + sidebar.name)[0];
|
|
|
|
if (panel && panel.visible() && sidebar.name !== name) {
|
|
trigger(sidebar, panel, 'onhide');
|
|
panel.visible(false);
|
|
}
|
|
});
|
|
};
|
|
|
|
var deactivateButtons = function (toolbar) {
|
|
toolbar.items().each(function (ctrl) {
|
|
ctrl.active(false);
|
|
});
|
|
};
|
|
|
|
var findSidebar = function (sidebars, name) {
|
|
return Tools.grep(sidebars, function (sidebar) {
|
|
return sidebar.name === name;
|
|
})[0];
|
|
};
|
|
|
|
var showPanel = function (editor, name, sidebars) {
|
|
return function (e) {
|
|
var btnCtrl = e.control;
|
|
var container = btnCtrl.parents().filter('panel')[0];
|
|
var panel = container.find('#' + name)[0];
|
|
var sidebar = findSidebar(sidebars, name);
|
|
|
|
hidePanels(name, container, sidebars);
|
|
deactivateButtons(btnCtrl.parent());
|
|
|
|
if (panel && panel.visible()) {
|
|
trigger(sidebar, panel, 'onhide');
|
|
panel.hide();
|
|
btnCtrl.active(false);
|
|
} else {
|
|
if (panel) {
|
|
panel.show();
|
|
trigger(sidebar, panel, 'onshow');
|
|
} else {
|
|
panel = Factory.create({
|
|
type: 'container',
|
|
name: name,
|
|
layout: 'stack',
|
|
classes: 'sidebar-panel',
|
|
html: ''
|
|
});
|
|
|
|
container.prepend(panel);
|
|
trigger(sidebar, panel, 'onrender');
|
|
trigger(sidebar, panel, 'onshow');
|
|
}
|
|
|
|
btnCtrl.active(true);
|
|
}
|
|
|
|
editor.fire('ResizeEditor');
|
|
};
|
|
};
|
|
|
|
var isModernBrowser = function () {
|
|
return !Env.ie || Env.ie >= 11;
|
|
};
|
|
|
|
var hasSidebar = function (editor) {
|
|
return isModernBrowser() && editor.sidebars ? editor.sidebars.length > 0 : false;
|
|
};
|
|
|
|
var createSidebar = function (editor) {
|
|
var buttons = Tools.map(editor.sidebars, function (sidebar) {
|
|
var settings = sidebar.settings;
|
|
|
|
return {
|
|
type: 'button',
|
|
icon: settings.icon,
|
|
image: settings.image,
|
|
tooltip: settings.tooltip,
|
|
onclick: showPanel(editor, sidebar.name, editor.sidebars)
|
|
};
|
|
});
|
|
|
|
return {
|
|
type: 'panel',
|
|
name: 'sidebar',
|
|
layout: 'stack',
|
|
classes: 'sidebar',
|
|
items: [
|
|
{
|
|
type: 'toolbar',
|
|
layout: 'stack',
|
|
classes: 'sidebar-toolbar',
|
|
items: buttons
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
return {
|
|
hasSidebar: hasSidebar,
|
|
createSidebar: createSidebar
|
|
};
|
|
}
|
|
);
|
|
/**
|
|
* SkinLoaded.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.SkinLoaded', [
|
|
],
|
|
function () {
|
|
var fireSkinLoaded = function (editor) {
|
|
var done = function () {
|
|
editor._skinLoaded = true;
|
|
editor.fire('SkinLoaded');
|
|
};
|
|
|
|
return function () {
|
|
if (editor.initialized) {
|
|
done();
|
|
} else {
|
|
editor.on('init', done);
|
|
}
|
|
};
|
|
};
|
|
|
|
return {
|
|
fireSkinLoaded: fireSkinLoaded
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Iframe.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.modes.Iframe',
|
|
[
|
|
'tinymce.core.dom.DOMUtils',
|
|
'tinymce.core.ui.Factory',
|
|
'tinymce.core.util.Tools',
|
|
'tinymce.themes.modern.ui.A11y',
|
|
'tinymce.themes.modern.ui.Branding',
|
|
'tinymce.themes.modern.ui.ContextToolbars',
|
|
'tinymce.themes.modern.ui.Menubar',
|
|
'tinymce.themes.modern.ui.Resize',
|
|
'tinymce.themes.modern.ui.Sidebar',
|
|
'tinymce.themes.modern.ui.SkinLoaded',
|
|
'tinymce.themes.modern.ui.Toolbar'
|
|
],
|
|
function (DOMUtils, Factory, Tools, A11y, Branding, ContextToolbars, Menubar, Resize, Sidebar, SkinLoaded, Toolbar) {
|
|
var DOM = DOMUtils.DOM;
|
|
|
|
var switchMode = function (panel) {
|
|
return function (e) {
|
|
panel.find('*').disabled(e.mode === 'readonly');
|
|
};
|
|
};
|
|
|
|
var editArea = function (border) {
|
|
return {
|
|
type: 'panel',
|
|
name: 'iframe',
|
|
layout: 'stack',
|
|
classes: 'edit-area',
|
|
border: border,
|
|
html: ''
|
|
};
|
|
};
|
|
|
|
var editAreaContainer = function (editor) {
|
|
return {
|
|
type: 'panel',
|
|
layout: 'stack',
|
|
classes: 'edit-aria-container',
|
|
border: '1 0 0 0',
|
|
items: [
|
|
editArea('0'),
|
|
Sidebar.createSidebar(editor)
|
|
]
|
|
};
|
|
};
|
|
|
|
var render = function (editor, theme, args) {
|
|
var panel, resizeHandleCtrl, startSize, settings = editor.settings;
|
|
|
|
if (args.skinUiCss) {
|
|
DOM.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor));
|
|
}
|
|
|
|
panel = theme.panel = Factory.create({
|
|
type: 'panel',
|
|
role: 'application',
|
|
classes: 'tinymce',
|
|
style: 'visibility: hidden',
|
|
layout: 'stack',
|
|
border: 1,
|
|
items: [
|
|
settings.menubar === false ? null : { type: 'menubar', border: '0 0 1 0', items: Menubar.createMenuButtons(editor) },
|
|
Toolbar.createToolbars(editor, settings.toolbar_items_size),
|
|
Sidebar.hasSidebar(editor) ? editAreaContainer(editor) : editArea('1 0 0 0')
|
|
]
|
|
});
|
|
|
|
if (settings.resize !== false) {
|
|
resizeHandleCtrl = {
|
|
type: 'resizehandle',
|
|
direction: settings.resize,
|
|
|
|
onResizeStart: function () {
|
|
var elm = editor.getContentAreaContainer().firstChild;
|
|
|
|
startSize = {
|
|
width: elm.clientWidth,
|
|
height: elm.clientHeight
|
|
};
|
|
},
|
|
|
|
onResize: function (e) {
|
|
if (settings.resize === 'both') {
|
|
Resize.resizeTo(editor, startSize.width + e.deltaX, startSize.height + e.deltaY);
|
|
} else {
|
|
Resize.resizeTo(editor, null, startSize.height + e.deltaY);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// Add statusbar if needed
|
|
if (settings.statusbar !== false) {
|
|
panel.add({
|
|
type: 'panel', name: 'statusbar', classes: 'statusbar', layout: 'flow', border: '1 0 0 0', ariaRoot: true, items: [
|
|
{ type: 'elementpath', editor: editor },
|
|
resizeHandleCtrl
|
|
]
|
|
});
|
|
}
|
|
|
|
editor.fire('BeforeRenderUI');
|
|
editor.on('SwitchMode', switchMode(panel));
|
|
panel.renderBefore(args.targetNode).reflow();
|
|
|
|
if (settings.readonly) {
|
|
editor.setMode('readonly');
|
|
}
|
|
|
|
if (args.width) {
|
|
DOM.setStyle(panel.getEl(), 'width', args.width);
|
|
}
|
|
|
|
// Remove the panel when the editor is removed
|
|
editor.on('remove', function () {
|
|
panel.remove();
|
|
panel = null;
|
|
});
|
|
|
|
// Add accesibility shortcuts
|
|
A11y.addKeys(editor, panel);
|
|
ContextToolbars.addContextualToolbars(editor);
|
|
Branding.setup(editor);
|
|
|
|
return {
|
|
iframeContainer: panel.find('#iframe')[0].getEl(),
|
|
editorContainer: panel.getEl()
|
|
};
|
|
};
|
|
|
|
return {
|
|
render: render
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.ui.FloatPanel',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.ui.FloatPanel');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Inline.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.modes.Inline',
|
|
[
|
|
'tinymce.core.util.Tools',
|
|
'tinymce.core.ui.Factory',
|
|
'tinymce.core.dom.DOMUtils',
|
|
'tinymce.core.ui.FloatPanel',
|
|
'tinymce.themes.modern.ui.Toolbar',
|
|
'tinymce.themes.modern.ui.Menubar',
|
|
'tinymce.themes.modern.ui.ContextToolbars',
|
|
'tinymce.themes.modern.ui.A11y',
|
|
'tinymce.themes.modern.ui.SkinLoaded'
|
|
],
|
|
function (Tools, Factory, DOMUtils, FloatPanel, Toolbar, Menubar, ContextToolbars, A11y, SkinLoaded) {
|
|
var render = function (editor, theme, args) {
|
|
var panel, inlineToolbarContainer, settings = editor.settings;
|
|
var DOM = DOMUtils.DOM;
|
|
|
|
if (settings.fixed_toolbar_container) {
|
|
inlineToolbarContainer = DOM.select(settings.fixed_toolbar_container)[0];
|
|
}
|
|
|
|
var reposition = function () {
|
|
if (panel && panel.moveRel && panel.visible() && !panel._fixed) {
|
|
// TODO: This is kind of ugly and doesn't handle multiple scrollable elements
|
|
var scrollContainer = editor.selection.getScrollContainer(), body = editor.getBody();
|
|
var deltaX = 0, deltaY = 0;
|
|
|
|
if (scrollContainer) {
|
|
var bodyPos = DOM.getPos(body), scrollContainerPos = DOM.getPos(scrollContainer);
|
|
|
|
deltaX = Math.max(0, scrollContainerPos.x - bodyPos.x);
|
|
deltaY = Math.max(0, scrollContainerPos.y - bodyPos.y);
|
|
}
|
|
|
|
panel.fixed(false).moveRel(body, editor.rtl ? ['tr-br', 'br-tr'] : ['tl-bl', 'bl-tl', 'tr-br']).moveBy(deltaX, deltaY);
|
|
}
|
|
};
|
|
|
|
var show = function () {
|
|
if (panel) {
|
|
panel.show();
|
|
reposition();
|
|
DOM.addClass(editor.getBody(), 'mce-edit-focus');
|
|
}
|
|
};
|
|
|
|
var hide = function () {
|
|
if (panel) {
|
|
// We require two events as the inline float panel based toolbar does not have autohide=true
|
|
panel.hide();
|
|
|
|
// All other autohidden float panels will be closed below.
|
|
FloatPanel.hideAll();
|
|
|
|
DOM.removeClass(editor.getBody(), 'mce-edit-focus');
|
|
}
|
|
};
|
|
|
|
var render = function () {
|
|
if (panel) {
|
|
if (!panel.visible()) {
|
|
show();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Render a plain panel inside the inlineToolbarContainer if it's defined
|
|
panel = theme.panel = Factory.create({
|
|
type: inlineToolbarContainer ? 'panel' : 'floatpanel',
|
|
role: 'application',
|
|
classes: 'tinymce tinymce-inline',
|
|
layout: 'flex',
|
|
direction: 'column',
|
|
align: 'stretch',
|
|
autohide: false,
|
|
autofix: true,
|
|
fixed: !!inlineToolbarContainer,
|
|
border: 1,
|
|
items: [
|
|
settings.menubar === false ? null : { type: 'menubar', border: '0 0 1 0', items: Menubar.createMenuButtons(editor) },
|
|
Toolbar.createToolbars(editor, settings.toolbar_items_size)
|
|
]
|
|
});
|
|
|
|
// Add statusbar
|
|
/*if (settings.statusbar !== false) {
|
|
panel.add({type: 'panel', classes: 'statusbar', layout: 'flow', border: '1 0 0 0', items: [
|
|
{type: 'elementpath'}
|
|
]});
|
|
}*/
|
|
|
|
editor.fire('BeforeRenderUI');
|
|
panel.renderTo(inlineToolbarContainer || document.body).reflow();
|
|
|
|
A11y.addKeys(editor, panel);
|
|
show();
|
|
ContextToolbars.addContextualToolbars(editor);
|
|
|
|
editor.on('nodeChange', reposition);
|
|
editor.on('activate', show);
|
|
editor.on('deactivate', hide);
|
|
|
|
editor.nodeChanged();
|
|
};
|
|
|
|
settings.content_editable = true;
|
|
|
|
editor.on('focus', function () {
|
|
// Render only when the CSS file has been loaded
|
|
if (args.skinUiCss) {
|
|
DOM.styleSheetLoader.load(args.skinUiCss, render, render);
|
|
} else {
|
|
render();
|
|
}
|
|
});
|
|
|
|
editor.on('blur hide', hide);
|
|
|
|
// Remove the panel when the editor is removed
|
|
editor.on('remove', function () {
|
|
if (panel) {
|
|
panel.remove();
|
|
panel = null;
|
|
}
|
|
});
|
|
|
|
// Preload skin css
|
|
if (args.skinUiCss) {
|
|
DOM.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor));
|
|
}
|
|
|
|
return {};
|
|
};
|
|
|
|
return {
|
|
render: render
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ResolveGlobal.js
|
|
*
|
|
* Released under LGPL License.
|
|
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
define(
|
|
'tinymce.core.ui.Throbber',
|
|
[
|
|
'global!tinymce.util.Tools.resolve'
|
|
],
|
|
function (resolve) {
|
|
return resolve('tinymce.ui.Throbber');
|
|
}
|
|
);
|
|
|
|
/**
|
|
* ProgressState.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.ui.ProgressState',
|
|
[
|
|
'tinymce.core.ui.Throbber'
|
|
],
|
|
function (Throbber) {
|
|
var setup = function (editor, theme) {
|
|
var throbber;
|
|
|
|
editor.on('ProgressState', function (e) {
|
|
throbber = throbber || new Throbber(theme.panel.getEl('body'));
|
|
|
|
if (e.state) {
|
|
throbber.show(e.time);
|
|
} else {
|
|
throbber.hide();
|
|
}
|
|
});
|
|
};
|
|
|
|
return {
|
|
setup: setup
|
|
};
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Theme.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
|
|
*/
|
|
|
|
define(
|
|
'tinymce.themes.modern.Theme',
|
|
[
|
|
'global!window',
|
|
'tinymce.core.AddOnManager',
|
|
'tinymce.core.EditorManager',
|
|
'tinymce.core.Env',
|
|
'tinymce.core.ui.Api',
|
|
'tinymce.themes.modern.modes.Iframe',
|
|
'tinymce.themes.modern.modes.Inline',
|
|
'tinymce.themes.modern.ui.ProgressState',
|
|
'tinymce.themes.modern.ui.Resize'
|
|
],
|
|
function (window, AddOnManager, EditorManager, Env, Api, Iframe, Inline, ProgressState, Resize) {
|
|
var ThemeManager = AddOnManager.ThemeManager;
|
|
|
|
Api.appendTo(window.tinymce ? window.tinymce : {});
|
|
|
|
var renderUI = function (editor, theme, args) {
|
|
var settings = editor.settings;
|
|
var skin = settings.skin !== false ? settings.skin || 'lightgray' : false;
|
|
|
|
if (skin) {
|
|
var skinUrl = settings.skin_url;
|
|
|
|
if (skinUrl) {
|
|
skinUrl = editor.documentBaseURI.toAbsolute(skinUrl);
|
|
} else {
|
|
skinUrl = EditorManager.baseURL + '/skins/' + skin;
|
|
}
|
|
|
|
args.skinUiCss = skinUrl + '/skin.min.css';
|
|
|
|
// Load content.min.css or content.inline.min.css
|
|
editor.contentCSS.push(skinUrl + '/content' + (editor.inline ? '.inline' : '') + '.min.css');
|
|
}
|
|
|
|
ProgressState.setup(editor, theme);
|
|
|
|
if (settings.inline) {
|
|
return Inline.render(editor, theme, args);
|
|
}
|
|
|
|
return Iframe.render(editor, theme, args);
|
|
};
|
|
|
|
ThemeManager.add('modern', function (editor) {
|
|
return {
|
|
renderUI: function (args) {
|
|
return renderUI(editor, this, args);
|
|
},
|
|
resizeTo: function (w, h) {
|
|
return Resize.resizeTo(editor, w, h);
|
|
},
|
|
resizeBy: function (dw, dh) {
|
|
return Resize.resizeBy(editor, dw, dh);
|
|
}
|
|
};
|
|
});
|
|
|
|
return function () {
|
|
};
|
|
}
|
|
);
|
|
|
|
dem('tinymce.themes.modern.Theme')();
|
|
})();
|