10235 lines
310 KiB
JavaScript
10235 lines
310 KiB
JavaScript
(function () {
|
|
var inlite = (function () {
|
|
'use strict';
|
|
|
|
var global = tinymce.util.Tools.resolve('tinymce.ThemeManager');
|
|
|
|
var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
|
|
|
|
var global$2 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
|
|
|
|
var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
|
|
|
|
var flatten = function (arr) {
|
|
return arr.reduce(function (results, item) {
|
|
return Array.isArray(item) ? results.concat(flatten(item)) : results.concat(item);
|
|
}, []);
|
|
};
|
|
var $_ccn98l17xjjgwejz7 = { flatten: flatten };
|
|
|
|
var result = function (id, rect) {
|
|
return {
|
|
id: id,
|
|
rect: rect
|
|
};
|
|
};
|
|
var match = function (editor, matchers) {
|
|
for (var i = 0; i < matchers.length; i++) {
|
|
var f = matchers[i];
|
|
var result_1 = f(editor);
|
|
if (result_1) {
|
|
return result_1;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
var $_6lg87517zjjgwejza = {
|
|
match: match,
|
|
result: result
|
|
};
|
|
|
|
var fromClientRect = function (clientRect) {
|
|
return {
|
|
x: clientRect.left,
|
|
y: clientRect.top,
|
|
w: clientRect.width,
|
|
h: clientRect.height
|
|
};
|
|
};
|
|
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 $_1x174x181jjgwejzd = {
|
|
fromClientRect: fromClientRect,
|
|
toClientRect: toClientRect
|
|
};
|
|
|
|
var toAbsolute = function (rect) {
|
|
var vp = global$2.DOM.getViewPort();
|
|
return {
|
|
x: rect.x + vp.x,
|
|
y: rect.y + vp.y,
|
|
w: rect.w,
|
|
h: rect.h
|
|
};
|
|
};
|
|
var measureElement = function (elm) {
|
|
var clientRect = elm.getBoundingClientRect();
|
|
return toAbsolute({
|
|
x: clientRect.left,
|
|
y: clientRect.top,
|
|
w: Math.max(elm.clientWidth, elm.offsetWidth),
|
|
h: Math.max(elm.clientHeight, elm.offsetHeight)
|
|
});
|
|
};
|
|
var getElementRect = function (editor, elm) {
|
|
return measureElement(elm);
|
|
};
|
|
var getPageAreaRect = function (editor) {
|
|
return measureElement(editor.getElement().ownerDocument.body);
|
|
};
|
|
var getContentAreaRect = function (editor) {
|
|
return measureElement(editor.getContentAreaContainer() || editor.getBody());
|
|
};
|
|
var getSelectionRect = function (editor) {
|
|
var clientRect = editor.selection.getBoundingClientRect();
|
|
return clientRect ? toAbsolute($_1x174x181jjgwejzd.fromClientRect(clientRect)) : null;
|
|
};
|
|
var $_51qgo2180jjgwejzb = {
|
|
getElementRect: getElementRect,
|
|
getPageAreaRect: getPageAreaRect,
|
|
getContentAreaRect: getContentAreaRect,
|
|
getSelectionRect: getSelectionRect
|
|
};
|
|
|
|
var element = function (element, predicateIds) {
|
|
return function (editor) {
|
|
for (var i = 0; i < predicateIds.length; i++) {
|
|
if (predicateIds[i].predicate(element)) {
|
|
var result = $_6lg87517zjjgwejza.result(predicateIds[i].id, $_51qgo2180jjgwejzb.getElementRect(editor, element));
|
|
return result;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
};
|
|
var parent = function (elements, predicateIds) {
|
|
return function (editor) {
|
|
for (var i = 0; i < elements.length; i++) {
|
|
for (var x = 0; x < predicateIds.length; x++) {
|
|
if (predicateIds[x].predicate(elements[i])) {
|
|
return $_6lg87517zjjgwejza.result(predicateIds[x].id, $_51qgo2180jjgwejzb.getElementRect(editor, elements[i]));
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
};
|
|
var $_egsucq17yjjgwejz9 = {
|
|
element: element,
|
|
parent: parent
|
|
};
|
|
|
|
var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
|
|
|
|
var create = function (id, predicate) {
|
|
return {
|
|
id: id,
|
|
predicate: predicate
|
|
};
|
|
};
|
|
var fromContextToolbars = function (toolbars) {
|
|
return global$4.map(toolbars, function (toolbar) {
|
|
return create(toolbar.id, toolbar.predicate);
|
|
});
|
|
};
|
|
var $_9rj8kx182jjgwejze = {
|
|
create: create,
|
|
fromContextToolbars: fromContextToolbars
|
|
};
|
|
|
|
var textSelection = function (id) {
|
|
return function (editor) {
|
|
if (!editor.selection.isCollapsed()) {
|
|
var result = $_6lg87517zjjgwejza.result(id, $_51qgo2180jjgwejzb.getSelectionRect(editor));
|
|
return result;
|
|
}
|
|
return null;
|
|
};
|
|
};
|
|
var emptyTextBlock = function (elements, id) {
|
|
return function (editor) {
|
|
var i;
|
|
var textBlockElementsMap = editor.schema.getTextBlockElements();
|
|
for (i = 0; i < elements.length; i++) {
|
|
if (elements[i].nodeName === 'TABLE') {
|
|
return null;
|
|
}
|
|
}
|
|
for (i = 0; i < elements.length; i++) {
|
|
if (elements[i].nodeName in textBlockElementsMap) {
|
|
if (editor.dom.isEmpty(elements[i])) {
|
|
return $_6lg87517zjjgwejza.result(id, $_51qgo2180jjgwejzb.getSelectionRect(editor));
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
};
|
|
var $_fhwgeg184jjgwejzf = {
|
|
textSelection: textSelection,
|
|
emptyTextBlock: emptyTextBlock
|
|
};
|
|
|
|
var fireSkinLoaded = function (editor) {
|
|
editor.fire('SkinLoaded');
|
|
};
|
|
var fireBeforeRenderUI = function (editor) {
|
|
return editor.fire('BeforeRenderUI');
|
|
};
|
|
var $_77u64d186jjgwejzi = {
|
|
fireSkinLoaded: fireSkinLoaded,
|
|
fireBeforeRenderUI: fireBeforeRenderUI
|
|
};
|
|
|
|
var global$5 = tinymce.util.Tools.resolve('tinymce.EditorManager');
|
|
|
|
var isType = function (type) {
|
|
return function (value) {
|
|
return typeof value === type;
|
|
};
|
|
};
|
|
var isArray = function (value) {
|
|
return Array.isArray(value);
|
|
};
|
|
var isNull = function (value) {
|
|
return value === null;
|
|
};
|
|
var isObject = function (predicate) {
|
|
return function (value) {
|
|
return !isNull(value) && !isArray(value) && predicate(value);
|
|
};
|
|
};
|
|
var isString = function (value) {
|
|
return isType('string')(value);
|
|
};
|
|
var isNumber = function (value) {
|
|
return isType('number')(value);
|
|
};
|
|
var isFunction = function (value) {
|
|
return isType('function')(value);
|
|
};
|
|
var isBoolean = function (value) {
|
|
return isType('boolean')(value);
|
|
};
|
|
var $_e4npq318ajjgwejzo = {
|
|
isString: isString,
|
|
isNumber: isNumber,
|
|
isBoolean: isBoolean,
|
|
isFunction: isFunction,
|
|
isObject: isObject(isType('object')),
|
|
isNull: isNull,
|
|
isArray: isArray
|
|
};
|
|
|
|
var validDefaultOrDie = function (value, predicate) {
|
|
if (predicate(value)) {
|
|
return true;
|
|
}
|
|
throw new Error('Default value doesn\'t match requested type.');
|
|
};
|
|
var getByTypeOr = function (predicate) {
|
|
return function (editor, name, defaultValue) {
|
|
var settings = editor.settings;
|
|
validDefaultOrDie(defaultValue, predicate);
|
|
return name in settings && predicate(settings[name]) ? settings[name] : defaultValue;
|
|
};
|
|
};
|
|
var splitNoEmpty = function (str, delim) {
|
|
return str.split(delim).filter(function (item) {
|
|
return item.length > 0;
|
|
});
|
|
};
|
|
var itemsToArray = function (value, defaultValue) {
|
|
var stringToItemsArray = function (value) {
|
|
return typeof value === 'string' ? splitNoEmpty(value, /[ ,]/) : value;
|
|
};
|
|
var boolToItemsArray = function (value, defaultValue) {
|
|
return value === false ? [] : defaultValue;
|
|
};
|
|
if ($_e4npq318ajjgwejzo.isArray(value)) {
|
|
return value;
|
|
} else if ($_e4npq318ajjgwejzo.isString(value)) {
|
|
return stringToItemsArray(value);
|
|
} else if ($_e4npq318ajjgwejzo.isBoolean(value)) {
|
|
return boolToItemsArray(value, defaultValue);
|
|
}
|
|
return defaultValue;
|
|
};
|
|
var getToolbarItemsOr = function (predicate) {
|
|
return function (editor, name, defaultValue) {
|
|
var value = name in editor.settings ? editor.settings[name] : defaultValue;
|
|
validDefaultOrDie(defaultValue, predicate);
|
|
return itemsToArray(value, defaultValue);
|
|
};
|
|
};
|
|
var $_c8umh189jjgwejzm = {
|
|
getStringOr: getByTypeOr($_e4npq318ajjgwejzo.isString),
|
|
getBoolOr: getByTypeOr($_e4npq318ajjgwejzo.isBoolean),
|
|
getNumberOr: getByTypeOr($_e4npq318ajjgwejzo.isNumber),
|
|
getHandlerOr: getByTypeOr($_e4npq318ajjgwejzo.isFunction),
|
|
getToolbarItemsOr: getToolbarItemsOr($_e4npq318ajjgwejzo.isArray)
|
|
};
|
|
|
|
var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
|
|
|
|
var result$1 = function (rect, position) {
|
|
return {
|
|
rect: rect,
|
|
position: position
|
|
};
|
|
};
|
|
var moveTo = function (rect, toRect) {
|
|
return {
|
|
x: toRect.x,
|
|
y: toRect.y,
|
|
w: rect.w,
|
|
h: rect.h
|
|
};
|
|
};
|
|
var calcByPositions = function (testPositions1, testPositions2, targetRect, contentAreaRect, panelRect) {
|
|
var relPos, relRect, outputPanelRect;
|
|
var paddedContentRect = {
|
|
x: contentAreaRect.x,
|
|
y: contentAreaRect.y,
|
|
w: contentAreaRect.w + (contentAreaRect.w < panelRect.w + targetRect.w ? panelRect.w : 0),
|
|
h: contentAreaRect.h + (contentAreaRect.h < panelRect.h + targetRect.h ? panelRect.h : 0)
|
|
};
|
|
relPos = global$6.findBestRelativePosition(panelRect, targetRect, paddedContentRect, testPositions1);
|
|
targetRect = global$6.clamp(targetRect, paddedContentRect);
|
|
if (relPos) {
|
|
relRect = global$6.relativePosition(panelRect, targetRect, relPos);
|
|
outputPanelRect = moveTo(panelRect, relRect);
|
|
return result$1(outputPanelRect, relPos);
|
|
}
|
|
targetRect = global$6.intersect(paddedContentRect, targetRect);
|
|
if (targetRect) {
|
|
relPos = global$6.findBestRelativePosition(panelRect, targetRect, paddedContentRect, testPositions2);
|
|
if (relPos) {
|
|
relRect = global$6.relativePosition(panelRect, targetRect, relPos);
|
|
outputPanelRect = moveTo(panelRect, relRect);
|
|
return result$1(outputPanelRect, relPos);
|
|
}
|
|
outputPanelRect = moveTo(panelRect, targetRect);
|
|
return result$1(outputPanelRect, relPos);
|
|
}
|
|
return null;
|
|
};
|
|
var calcInsert = function (targetRect, contentAreaRect, panelRect) {
|
|
return calcByPositions([
|
|
'cr-cl',
|
|
'cl-cr'
|
|
], [
|
|
'bc-tc',
|
|
'bl-tl',
|
|
'br-tr'
|
|
], targetRect, contentAreaRect, panelRect);
|
|
};
|
|
var calc = function (targetRect, contentAreaRect, panelRect) {
|
|
return calcByPositions([
|
|
'tc-bc',
|
|
'bc-tc',
|
|
'tl-bl',
|
|
'bl-tl',
|
|
'tr-br',
|
|
'br-tr',
|
|
'cr-cl',
|
|
'cl-cr'
|
|
], [
|
|
'bc-tc',
|
|
'bl-tl',
|
|
'br-tr',
|
|
'cr-cl'
|
|
], targetRect, contentAreaRect, panelRect);
|
|
};
|
|
var userConstrain = function (handler, targetRect, contentAreaRect, panelRect) {
|
|
var userConstrainedPanelRect;
|
|
if (typeof handler === 'function') {
|
|
userConstrainedPanelRect = handler({
|
|
elementRect: $_1x174x181jjgwejzd.toClientRect(targetRect),
|
|
contentAreaRect: $_1x174x181jjgwejzd.toClientRect(contentAreaRect),
|
|
panelRect: $_1x174x181jjgwejzd.toClientRect(panelRect)
|
|
});
|
|
return $_1x174x181jjgwejzd.fromClientRect(userConstrainedPanelRect);
|
|
}
|
|
return panelRect;
|
|
};
|
|
var defaultHandler = function (rects) {
|
|
return rects.panelRect;
|
|
};
|
|
var $_gir42l18bjjgwejzq = {
|
|
calcInsert: calcInsert,
|
|
calc: calc,
|
|
userConstrain: userConstrain,
|
|
defaultHandler: defaultHandler
|
|
};
|
|
|
|
var toAbsoluteUrl = function (editor, url) {
|
|
return editor.documentBaseURI.toAbsolute(url);
|
|
};
|
|
var urlFromName = function (name) {
|
|
var prefix = global$5.baseURL + '/skins/';
|
|
return name ? prefix + name : prefix + 'lightgray';
|
|
};
|
|
var getTextSelectionToolbarItems = function (editor) {
|
|
return $_c8umh189jjgwejzm.getToolbarItemsOr(editor, 'selection_toolbar', [
|
|
'bold',
|
|
'italic',
|
|
'|',
|
|
'quicklink',
|
|
'h2',
|
|
'h3',
|
|
'blockquote'
|
|
]);
|
|
};
|
|
var getInsertToolbarItems = function (editor) {
|
|
return $_c8umh189jjgwejzm.getToolbarItemsOr(editor, 'insert_toolbar', [
|
|
'quickimage',
|
|
'quicktable'
|
|
]);
|
|
};
|
|
var getPositionHandler = function (editor) {
|
|
return $_c8umh189jjgwejzm.getHandlerOr(editor, 'inline_toolbar_position_handler', $_gir42l18bjjgwejzq.defaultHandler);
|
|
};
|
|
var getSkinUrl = function (editor) {
|
|
var settings = editor.settings;
|
|
return settings.skin_url ? toAbsoluteUrl(editor, settings.skin_url) : urlFromName(settings.skin);
|
|
};
|
|
var isSkinDisabled = function (editor) {
|
|
return editor.settings.skin === false;
|
|
};
|
|
var $_4j2h42187jjgwejzk = {
|
|
getTextSelectionToolbarItems: getTextSelectionToolbarItems,
|
|
getInsertToolbarItems: getInsertToolbarItems,
|
|
getPositionHandler: getPositionHandler,
|
|
getSkinUrl: getSkinUrl,
|
|
isSkinDisabled: isSkinDisabled
|
|
};
|
|
|
|
var fireSkinLoaded$1 = function (editor, callback) {
|
|
var done = function () {
|
|
editor._skinLoaded = true;
|
|
$_77u64d186jjgwejzi.fireSkinLoaded(editor);
|
|
callback();
|
|
};
|
|
if (editor.initialized) {
|
|
done();
|
|
} else {
|
|
editor.on('init', done);
|
|
}
|
|
};
|
|
var load = function (editor, callback) {
|
|
var skinUrl = $_4j2h42187jjgwejzk.getSkinUrl(editor);
|
|
var done = function () {
|
|
fireSkinLoaded$1(editor, callback);
|
|
};
|
|
if ($_4j2h42187jjgwejzk.isSkinDisabled(editor)) {
|
|
done();
|
|
} else {
|
|
global$2.DOM.styleSheetLoader.load(skinUrl + '/skin.min.css', done);
|
|
editor.contentCSS.push(skinUrl + '/content.inline.min.css');
|
|
}
|
|
};
|
|
var $_93v08q185jjgwejzh = { load: load };
|
|
|
|
var getSelectionElements = function (editor) {
|
|
var node = editor.selection.getNode();
|
|
var elms = editor.dom.getParents(node, '*');
|
|
return elms;
|
|
};
|
|
var createToolbar = function (editor, selector, id, items) {
|
|
var selectorPredicate = function (elm) {
|
|
return editor.dom.is(elm, selector);
|
|
};
|
|
return {
|
|
predicate: selectorPredicate,
|
|
id: id,
|
|
items: items
|
|
};
|
|
};
|
|
var getToolbars = function (editor) {
|
|
var contextToolbars = editor.contextToolbars;
|
|
return $_ccn98l17xjjgwejz7.flatten([
|
|
contextToolbars ? contextToolbars : [],
|
|
createToolbar(editor, 'img', 'image', 'alignleft aligncenter alignright')
|
|
]);
|
|
};
|
|
var findMatchResult = function (editor, toolbars) {
|
|
var result, elements, contextToolbarsPredicateIds;
|
|
elements = getSelectionElements(editor);
|
|
contextToolbarsPredicateIds = $_9rj8kx182jjgwejze.fromContextToolbars(toolbars);
|
|
result = $_6lg87517zjjgwejza.match(editor, [
|
|
$_egsucq17yjjgwejz9.element(elements[0], contextToolbarsPredicateIds),
|
|
$_fhwgeg184jjgwejzf.textSelection('text'),
|
|
$_fhwgeg184jjgwejzf.emptyTextBlock(elements, 'insert'),
|
|
$_egsucq17yjjgwejz9.parent(elements, contextToolbarsPredicateIds)
|
|
]);
|
|
return result && result.rect ? result : null;
|
|
};
|
|
var editorHasFocus = function (editor) {
|
|
return document.activeElement === editor.getBody();
|
|
};
|
|
var togglePanel = function (editor, panel) {
|
|
var toggle = function () {
|
|
var toolbars = getToolbars(editor);
|
|
var result = findMatchResult(editor, toolbars);
|
|
if (result) {
|
|
panel.show(editor, result.id, result.rect, toolbars);
|
|
} else {
|
|
panel.hide();
|
|
}
|
|
};
|
|
return function () {
|
|
if (!editor.removed && editorHasFocus(editor)) {
|
|
toggle();
|
|
}
|
|
};
|
|
};
|
|
var repositionPanel = function (editor, panel) {
|
|
return function () {
|
|
var toolbars = getToolbars(editor);
|
|
var result = findMatchResult(editor, toolbars);
|
|
if (result) {
|
|
panel.reposition(editor, result.id, result.rect);
|
|
}
|
|
};
|
|
};
|
|
var ignoreWhenFormIsVisible = function (editor, panel, f) {
|
|
return function () {
|
|
if (!editor.removed && !panel.inForm()) {
|
|
f();
|
|
}
|
|
};
|
|
};
|
|
var bindContextualToolbarsEvents = function (editor, panel) {
|
|
var throttledTogglePanel = global$3.throttle(togglePanel(editor, panel), 0);
|
|
var throttledTogglePanelWhenNotInForm = global$3.throttle(ignoreWhenFormIsVisible(editor, panel, togglePanel(editor, panel)), 0);
|
|
var reposition = repositionPanel(editor, panel);
|
|
editor.on('blur hide ObjectResizeStart', panel.hide);
|
|
editor.on('click', throttledTogglePanel);
|
|
editor.on('nodeChange mouseup', throttledTogglePanelWhenNotInForm);
|
|
editor.on('ResizeEditor keyup', throttledTogglePanel);
|
|
editor.on('ResizeWindow', reposition);
|
|
global$2.DOM.bind(global$1.container, 'scroll', reposition);
|
|
editor.on('remove', function () {
|
|
global$2.DOM.unbind(global$1.container, 'scroll', reposition);
|
|
panel.remove();
|
|
});
|
|
editor.shortcuts.add('Alt+F10,F10', '', panel.focus);
|
|
};
|
|
var overrideLinkShortcut = function (editor, panel) {
|
|
editor.shortcuts.remove('meta+k');
|
|
editor.shortcuts.add('meta+k', '', function () {
|
|
var toolbars = getToolbars(editor);
|
|
var result = $_6lg87517zjjgwejza.match(editor, [$_fhwgeg184jjgwejzf.textSelection('quicklink')]);
|
|
if (result) {
|
|
panel.show(editor, result.id, result.rect, toolbars);
|
|
}
|
|
});
|
|
};
|
|
var renderInlineUI = function (editor, panel) {
|
|
$_93v08q185jjgwejzh.load(editor, function () {
|
|
bindContextualToolbarsEvents(editor, panel);
|
|
overrideLinkShortcut(editor, panel);
|
|
});
|
|
return {};
|
|
};
|
|
var fail = function (message) {
|
|
throw new Error(message);
|
|
};
|
|
var renderUI = function (editor, panel) {
|
|
return editor.inline ? renderInlineUI(editor, panel) : fail('inlite theme only supports inline mode.');
|
|
};
|
|
var $_b0wxh217tjjgwejyx = { renderUI: renderUI };
|
|
|
|
var noop = function () {
|
|
var x = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
x[_i] = arguments[_i];
|
|
}
|
|
};
|
|
|
|
var compose = function (fa, fb) {
|
|
return function () {
|
|
var x = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
x[_i] = arguments[_i];
|
|
}
|
|
return fa(fb.apply(null, arguments));
|
|
};
|
|
};
|
|
var constant = function (value) {
|
|
return function () {
|
|
return value;
|
|
};
|
|
};
|
|
|
|
|
|
var curry = function (f) {
|
|
var x = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
x[_i - 1] = arguments[_i];
|
|
}
|
|
var args = new Array(arguments.length - 1);
|
|
for (var i = 1; i < arguments.length; i++)
|
|
args[i - 1] = arguments[i];
|
|
return function () {
|
|
var x = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
x[_i] = arguments[_i];
|
|
}
|
|
var newArgs = new Array(arguments.length);
|
|
for (var j = 0; j < newArgs.length; j++)
|
|
newArgs[j] = arguments[j];
|
|
var all = args.concat(newArgs);
|
|
return f.apply(null, all);
|
|
};
|
|
};
|
|
|
|
|
|
|
|
|
|
var never = constant(false);
|
|
var always = constant(true);
|
|
|
|
var never$1 = never;
|
|
var always$1 = always;
|
|
var none = function () {
|
|
return NONE;
|
|
};
|
|
var NONE = function () {
|
|
var eq = function (o) {
|
|
return o.isNone();
|
|
};
|
|
var call$$1 = function (thunk) {
|
|
return thunk();
|
|
};
|
|
var id = function (n) {
|
|
return n;
|
|
};
|
|
var noop$$1 = function () {
|
|
};
|
|
var nul = function () {
|
|
return null;
|
|
};
|
|
var undef = function () {
|
|
return undefined;
|
|
};
|
|
var me = {
|
|
fold: function (n, s) {
|
|
return n();
|
|
},
|
|
is: never$1,
|
|
isSome: never$1,
|
|
isNone: always$1,
|
|
getOr: id,
|
|
getOrThunk: call$$1,
|
|
getOrDie: function (msg) {
|
|
throw new Error(msg || 'error: getOrDie called on none.');
|
|
},
|
|
getOrNull: nul,
|
|
getOrUndefined: undef,
|
|
or: id,
|
|
orThunk: call$$1,
|
|
map: none,
|
|
ap: none,
|
|
each: noop$$1,
|
|
bind: none,
|
|
flatten: none,
|
|
exists: never$1,
|
|
forall: always$1,
|
|
filter: none,
|
|
equals: eq,
|
|
equals_: eq,
|
|
toArray: function () {
|
|
return [];
|
|
},
|
|
toString: constant('none()')
|
|
};
|
|
if (Object.freeze)
|
|
Object.freeze(me);
|
|
return me;
|
|
}();
|
|
var some = function (a) {
|
|
var constant_a = function () {
|
|
return a;
|
|
};
|
|
var self = function () {
|
|
return me;
|
|
};
|
|
var map = function (f) {
|
|
return some(f(a));
|
|
};
|
|
var bind = function (f) {
|
|
return f(a);
|
|
};
|
|
var me = {
|
|
fold: function (n, s) {
|
|
return s(a);
|
|
},
|
|
is: function (v) {
|
|
return a === v;
|
|
},
|
|
isSome: always$1,
|
|
isNone: never$1,
|
|
getOr: constant_a,
|
|
getOrThunk: constant_a,
|
|
getOrDie: constant_a,
|
|
getOrNull: constant_a,
|
|
getOrUndefined: constant_a,
|
|
or: self,
|
|
orThunk: self,
|
|
map: map,
|
|
ap: function (optfab) {
|
|
return optfab.fold(none, function (fab) {
|
|
return some(fab(a));
|
|
});
|
|
},
|
|
each: function (f) {
|
|
f(a);
|
|
},
|
|
bind: bind,
|
|
flatten: constant_a,
|
|
exists: bind,
|
|
forall: bind,
|
|
filter: function (f) {
|
|
return f(a) ? me : NONE;
|
|
},
|
|
equals: function (o) {
|
|
return o.is(a);
|
|
},
|
|
equals_: function (o, elementEq) {
|
|
return o.fold(never$1, function (b) {
|
|
return elementEq(a, b);
|
|
});
|
|
},
|
|
toArray: function () {
|
|
return [a];
|
|
},
|
|
toString: function () {
|
|
return 'some(' + a + ')';
|
|
}
|
|
};
|
|
return me;
|
|
};
|
|
var from = function (value) {
|
|
return value === null || value === undefined ? NONE : some(value);
|
|
};
|
|
var Option = {
|
|
some: some,
|
|
none: none,
|
|
from: from
|
|
};
|
|
|
|
var typeOf = function (x) {
|
|
if (x === null)
|
|
return 'null';
|
|
var t = typeof x;
|
|
if (t === 'object' && Array.prototype.isPrototypeOf(x))
|
|
return 'array';
|
|
if (t === 'object' && String.prototype.isPrototypeOf(x))
|
|
return 'string';
|
|
return t;
|
|
};
|
|
var isType$1 = function (type) {
|
|
return function (value) {
|
|
return typeOf(value) === type;
|
|
};
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var isFunction$1 = isType$1('function');
|
|
var isNumber$1 = isType$1('number');
|
|
|
|
var rawIndexOf = function () {
|
|
var pIndexOf = Array.prototype.indexOf;
|
|
var fastIndex = function (xs, x) {
|
|
return pIndexOf.call(xs, x);
|
|
};
|
|
var slowIndex = function (xs, x) {
|
|
return slowIndexOf(xs, x);
|
|
};
|
|
return pIndexOf === undefined ? slowIndex : fastIndex;
|
|
}();
|
|
var indexOf = function (xs, x) {
|
|
var r = rawIndexOf(xs, x);
|
|
return r === -1 ? Option.none() : Option.some(r);
|
|
};
|
|
|
|
var exists = function (xs, pred) {
|
|
return findIndex(xs, pred).isSome();
|
|
};
|
|
|
|
|
|
var map = function (xs, f) {
|
|
var len = xs.length;
|
|
var r = new Array(len);
|
|
for (var i = 0; i < len; i++) {
|
|
var x = xs[i];
|
|
r[i] = f(x, i, xs);
|
|
}
|
|
return r;
|
|
};
|
|
var each = function (xs, f) {
|
|
for (var i = 0, len = xs.length; i < len; i++) {
|
|
var x = xs[i];
|
|
f(x, i, xs);
|
|
}
|
|
};
|
|
|
|
|
|
var filter = function (xs, pred) {
|
|
var r = [];
|
|
for (var i = 0, len = xs.length; i < len; i++) {
|
|
var x = xs[i];
|
|
if (pred(x, i, xs)) {
|
|
r.push(x);
|
|
}
|
|
}
|
|
return r;
|
|
};
|
|
|
|
|
|
var foldl = function (xs, f, acc) {
|
|
each(xs, function (x) {
|
|
acc = f(acc, x);
|
|
});
|
|
return acc;
|
|
};
|
|
var find = function (xs, pred) {
|
|
for (var i = 0, len = xs.length; i < len; i++) {
|
|
var x = xs[i];
|
|
if (pred(x, i, xs)) {
|
|
return Option.some(x);
|
|
}
|
|
}
|
|
return Option.none();
|
|
};
|
|
var findIndex = function (xs, pred) {
|
|
for (var i = 0, len = xs.length; i < len; i++) {
|
|
var x = xs[i];
|
|
if (pred(x, i, xs)) {
|
|
return Option.some(i);
|
|
}
|
|
}
|
|
return Option.none();
|
|
};
|
|
var slowIndexOf = function (xs, x) {
|
|
for (var i = 0, len = xs.length; i < len; ++i) {
|
|
if (xs[i] === x) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
var push = Array.prototype.push;
|
|
var flatten$1 = function (xs) {
|
|
var r = [];
|
|
for (var i = 0, len = xs.length; i < len; ++i) {
|
|
if (!Array.prototype.isPrototypeOf(xs[i]))
|
|
throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
|
|
push.apply(r, xs[i]);
|
|
}
|
|
return r;
|
|
};
|
|
|
|
|
|
|
|
var slice = Array.prototype.slice;
|
|
var reverse = function (xs) {
|
|
var r = slice.call(xs, 0);
|
|
r.reverse();
|
|
return r;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var from$1 = isFunction$1(Array.from) ? Array.from : function (x) {
|
|
return slice.call(x);
|
|
};
|
|
|
|
var count = 0;
|
|
var funcs = {
|
|
id: function () {
|
|
return 'mceu_' + count++;
|
|
},
|
|
create: function (name$$1, attrs, children) {
|
|
var elm = document.createElement(name$$1);
|
|
global$2.DOM.setAttribs(elm, attrs);
|
|
if (typeof children === 'string') {
|
|
elm.innerHTML = children;
|
|
} else {
|
|
global$4.each(children, function (child) {
|
|
if (child.nodeType) {
|
|
elm.appendChild(child);
|
|
}
|
|
});
|
|
}
|
|
return elm;
|
|
},
|
|
createFragment: function (html) {
|
|
return global$2.DOM.createFragment(html);
|
|
},
|
|
getWindowSize: function () {
|
|
return global$2.DOM.getViewPort();
|
|
},
|
|
getSize: function (elm) {
|
|
var width, height;
|
|
if (elm.getBoundingClientRect) {
|
|
var rect = elm.getBoundingClientRect();
|
|
width = Math.max(rect.width || rect.right - rect.left, elm.offsetWidth);
|
|
height = Math.max(rect.height || rect.bottom - rect.bottom, elm.offsetHeight);
|
|
} else {
|
|
width = elm.offsetWidth;
|
|
height = elm.offsetHeight;
|
|
}
|
|
return {
|
|
width: width,
|
|
height: height
|
|
};
|
|
},
|
|
getPos: function (elm, root) {
|
|
return global$2.DOM.getPos(elm, root || funcs.getContainer());
|
|
},
|
|
getContainer: function () {
|
|
return global$1.container ? global$1.container : document.body;
|
|
},
|
|
getViewPort: function (win) {
|
|
return global$2.DOM.getViewPort(win);
|
|
},
|
|
get: function (id) {
|
|
return document.getElementById(id);
|
|
},
|
|
addClass: function (elm, cls) {
|
|
return global$2.DOM.addClass(elm, cls);
|
|
},
|
|
removeClass: function (elm, cls) {
|
|
return global$2.DOM.removeClass(elm, cls);
|
|
},
|
|
hasClass: function (elm, cls) {
|
|
return global$2.DOM.hasClass(elm, cls);
|
|
},
|
|
toggleClass: function (elm, cls, state) {
|
|
return global$2.DOM.toggleClass(elm, cls, state);
|
|
},
|
|
css: function (elm, name$$1, value) {
|
|
return global$2.DOM.setStyle(elm, name$$1, value);
|
|
},
|
|
getRuntimeStyle: function (elm, name$$1) {
|
|
return global$2.DOM.getStyle(elm, name$$1, true);
|
|
},
|
|
on: function (target, name$$1, callback, scope) {
|
|
return global$2.DOM.bind(target, name$$1, callback, scope);
|
|
},
|
|
off: function (target, name$$1, callback) {
|
|
return global$2.DOM.unbind(target, name$$1, callback);
|
|
},
|
|
fire: function (target, name$$1, args) {
|
|
return global$2.DOM.fire(target, name$$1, args);
|
|
},
|
|
innerHtml: function (elm, html) {
|
|
global$2.DOM.setHTML(elm, html);
|
|
}
|
|
};
|
|
|
|
var global$7 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
|
|
|
|
var global$8 = tinymce.util.Tools.resolve('tinymce.util.Class');
|
|
|
|
var global$9 = tinymce.util.Tools.resolve('tinymce.util.EventDispatcher');
|
|
|
|
var $_4kbuyt18pjjgwek1w = {
|
|
parseBox: function (value) {
|
|
var len;
|
|
var radix = 10;
|
|
if (!value) {
|
|
return;
|
|
}
|
|
if (typeof value === 'number') {
|
|
value = value || 0;
|
|
return {
|
|
top: value,
|
|
left: value,
|
|
bottom: value,
|
|
right: value
|
|
};
|
|
}
|
|
value = value.split(' ');
|
|
len = value.length;
|
|
if (len === 1) {
|
|
value[1] = value[2] = value[3] = value[0];
|
|
} else if (len === 2) {
|
|
value[2] = value[0];
|
|
value[3] = value[1];
|
|
} else if (len === 3) {
|
|
value[3] = value[1];
|
|
}
|
|
return {
|
|
top: parseInt(value[0], radix) || 0,
|
|
right: parseInt(value[1], radix) || 0,
|
|
bottom: parseInt(value[2], radix) || 0,
|
|
left: parseInt(value[3], radix) || 0
|
|
};
|
|
},
|
|
measureBox: function (elm, prefix) {
|
|
function getStyle(name) {
|
|
var defaultView = elm.ownerDocument.defaultView;
|
|
if (defaultView) {
|
|
var computedStyle = defaultView.getComputedStyle(elm, null);
|
|
if (computedStyle) {
|
|
name = name.replace(/[A-Z]/g, function (a) {
|
|
return '-' + a;
|
|
});
|
|
return computedStyle.getPropertyValue(name);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
return elm.currentStyle[name];
|
|
}
|
|
function getSide(name) {
|
|
var val = parseFloat(getStyle(name));
|
|
return isNaN(val) ? 0 : val;
|
|
}
|
|
return {
|
|
top: getSide(prefix + 'TopWidth'),
|
|
right: getSide(prefix + 'RightWidth'),
|
|
bottom: getSide(prefix + 'BottomWidth'),
|
|
left: getSide(prefix + 'LeftWidth')
|
|
};
|
|
}
|
|
};
|
|
|
|
function noop$1() {
|
|
}
|
|
function ClassList(onchange) {
|
|
this.cls = [];
|
|
this.cls._map = {};
|
|
this.onchange = onchange || noop$1;
|
|
this.prefix = '';
|
|
}
|
|
global$4.extend(ClassList.prototype, {
|
|
add: function (cls) {
|
|
if (cls && !this.contains(cls)) {
|
|
this.cls._map[cls] = true;
|
|
this.cls.push(cls);
|
|
this._change();
|
|
}
|
|
return this;
|
|
},
|
|
remove: function (cls) {
|
|
if (this.contains(cls)) {
|
|
var i = void 0;
|
|
for (i = 0; i < this.cls.length; i++) {
|
|
if (this.cls[i] === cls) {
|
|
break;
|
|
}
|
|
}
|
|
this.cls.splice(i, 1);
|
|
delete this.cls._map[cls];
|
|
this._change();
|
|
}
|
|
return this;
|
|
},
|
|
toggle: function (cls, state) {
|
|
var curState = this.contains(cls);
|
|
if (curState !== state) {
|
|
if (curState) {
|
|
this.remove(cls);
|
|
} else {
|
|
this.add(cls);
|
|
}
|
|
this._change();
|
|
}
|
|
return this;
|
|
},
|
|
contains: function (cls) {
|
|
return !!this.cls._map[cls];
|
|
},
|
|
_change: function () {
|
|
delete this.clsValue;
|
|
this.onchange.call(this);
|
|
}
|
|
});
|
|
ClassList.prototype.toString = function () {
|
|
var value;
|
|
if (this.clsValue) {
|
|
return this.clsValue;
|
|
}
|
|
value = '';
|
|
for (var i = 0; i < this.cls.length; i++) {
|
|
if (i > 0) {
|
|
value += ' ';
|
|
}
|
|
value += this.prefix + this.cls[i];
|
|
}
|
|
return value;
|
|
};
|
|
|
|
function unique(array) {
|
|
var uniqueItems = [];
|
|
var i = array.length, item;
|
|
while (i--) {
|
|
item = array[i];
|
|
if (!item.__checked) {
|
|
uniqueItems.push(item);
|
|
item.__checked = 1;
|
|
}
|
|
}
|
|
i = uniqueItems.length;
|
|
while (i--) {
|
|
delete uniqueItems[i].__checked;
|
|
}
|
|
return uniqueItems;
|
|
}
|
|
var expression = /^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i;
|
|
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g;
|
|
var whiteSpace = /^\s*|\s*$/g;
|
|
var Collection;
|
|
var Selector = global$8.extend({
|
|
init: function (selector) {
|
|
var match = this.match;
|
|
function compileNameFilter(name) {
|
|
if (name) {
|
|
name = name.toLowerCase();
|
|
return function (item) {
|
|
return name === '*' || item.type === name;
|
|
};
|
|
}
|
|
}
|
|
function compileIdFilter(id) {
|
|
if (id) {
|
|
return function (item) {
|
|
return item._name === id;
|
|
};
|
|
}
|
|
}
|
|
function compileClassesFilter(classes) {
|
|
if (classes) {
|
|
classes = classes.split('.');
|
|
return function (item) {
|
|
var i = classes.length;
|
|
while (i--) {
|
|
if (!item.classes.contains(classes[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
}
|
|
function compileAttrFilter(name, cmp, check) {
|
|
if (name) {
|
|
return function (item) {
|
|
var value = item[name] ? item[name]() : '';
|
|
return !cmp ? !!check : cmp === '=' ? value === check : cmp === '*=' ? value.indexOf(check) >= 0 : cmp === '~=' ? (' ' + value + ' ').indexOf(' ' + check + ' ') >= 0 : cmp === '!=' ? value !== check : cmp === '^=' ? value.indexOf(check) === 0 : cmp === '$=' ? value.substr(value.length - check.length) === check : false;
|
|
};
|
|
}
|
|
}
|
|
function compilePsuedoFilter(name) {
|
|
var notSelectors;
|
|
if (name) {
|
|
name = /(?:not\((.+)\))|(.+)/i.exec(name);
|
|
if (!name[1]) {
|
|
name = name[2];
|
|
return function (item, index, length) {
|
|
return name === 'first' ? index === 0 : name === 'last' ? index === length - 1 : name === 'even' ? index % 2 === 0 : name === 'odd' ? index % 2 === 1 : item[name] ? item[name]() : false;
|
|
};
|
|
}
|
|
notSelectors = parseChunks(name[1], []);
|
|
return function (item) {
|
|
return !match(item, notSelectors);
|
|
};
|
|
}
|
|
}
|
|
function compile(selector, filters, direct) {
|
|
var parts;
|
|
function add(filter) {
|
|
if (filter) {
|
|
filters.push(filter);
|
|
}
|
|
}
|
|
parts = expression.exec(selector.replace(whiteSpace, ''));
|
|
add(compileNameFilter(parts[1]));
|
|
add(compileIdFilter(parts[2]));
|
|
add(compileClassesFilter(parts[3]));
|
|
add(compileAttrFilter(parts[4], parts[5], parts[6]));
|
|
add(compilePsuedoFilter(parts[7]));
|
|
filters.pseudo = !!parts[7];
|
|
filters.direct = direct;
|
|
return filters;
|
|
}
|
|
function parseChunks(selector, selectors) {
|
|
var parts = [];
|
|
var extra, matches, i;
|
|
do {
|
|
chunker.exec('');
|
|
matches = chunker.exec(selector);
|
|
if (matches) {
|
|
selector = matches[3];
|
|
parts.push(matches[1]);
|
|
if (matches[2]) {
|
|
extra = matches[3];
|
|
break;
|
|
}
|
|
}
|
|
} while (matches);
|
|
if (extra) {
|
|
parseChunks(extra, selectors);
|
|
}
|
|
selector = [];
|
|
for (i = 0; i < parts.length; i++) {
|
|
if (parts[i] !== '>') {
|
|
selector.push(compile(parts[i], [], parts[i - 1] === '>'));
|
|
}
|
|
}
|
|
selectors.push(selector);
|
|
return selectors;
|
|
}
|
|
this._selectors = parseChunks(selector, []);
|
|
},
|
|
match: function (control, selectors) {
|
|
var i, l, si, sl, selector, fi, fl, filters, index, length, siblings, count, item;
|
|
selectors = selectors || this._selectors;
|
|
for (i = 0, l = selectors.length; i < l; i++) {
|
|
selector = selectors[i];
|
|
sl = selector.length;
|
|
item = control;
|
|
count = 0;
|
|
for (si = sl - 1; si >= 0; si--) {
|
|
filters = selector[si];
|
|
while (item) {
|
|
if (filters.pseudo) {
|
|
siblings = item.parent().items();
|
|
index = length = siblings.length;
|
|
while (index--) {
|
|
if (siblings[index] === item) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (fi = 0, fl = filters.length; fi < fl; fi++) {
|
|
if (!filters[fi](item, index, length)) {
|
|
fi = fl + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (fi === fl) {
|
|
count++;
|
|
break;
|
|
} else {
|
|
if (si === sl - 1) {
|
|
break;
|
|
}
|
|
}
|
|
item = item.parent();
|
|
}
|
|
}
|
|
if (count === sl) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
find: function (container) {
|
|
var matches = [], i, l;
|
|
var selectors = this._selectors;
|
|
function collect(items, selector, index) {
|
|
var i, l, fi, fl, item;
|
|
var filters = selector[index];
|
|
for (i = 0, l = items.length; i < l; i++) {
|
|
item = items[i];
|
|
for (fi = 0, fl = filters.length; fi < fl; fi++) {
|
|
if (!filters[fi](item, i, l)) {
|
|
fi = fl + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (fi === fl) {
|
|
if (index === selector.length - 1) {
|
|
matches.push(item);
|
|
} else {
|
|
if (item.items) {
|
|
collect(item.items(), selector, index + 1);
|
|
}
|
|
}
|
|
} else if (filters.direct) {
|
|
return;
|
|
}
|
|
if (item.items) {
|
|
collect(item.items(), selector, index);
|
|
}
|
|
}
|
|
}
|
|
if (container.items) {
|
|
for (i = 0, l = selectors.length; i < l; i++) {
|
|
collect(container.items(), selectors[i], 0);
|
|
}
|
|
if (l > 1) {
|
|
matches = unique(matches);
|
|
}
|
|
}
|
|
if (!Collection) {
|
|
Collection = Selector.Collection;
|
|
}
|
|
return new Collection(matches);
|
|
}
|
|
});
|
|
|
|
var Collection$1;
|
|
var proto;
|
|
var push$1 = Array.prototype.push;
|
|
var slice$1 = Array.prototype.slice;
|
|
proto = {
|
|
length: 0,
|
|
init: function (items) {
|
|
if (items) {
|
|
this.add(items);
|
|
}
|
|
},
|
|
add: function (items) {
|
|
var self = this;
|
|
if (!global$4.isArray(items)) {
|
|
if (items instanceof Collection$1) {
|
|
self.add(items.toArray());
|
|
} else {
|
|
push$1.call(self, items);
|
|
}
|
|
} else {
|
|
push$1.apply(self, items);
|
|
}
|
|
return self;
|
|
},
|
|
set: function (items) {
|
|
var self = this;
|
|
var len = self.length;
|
|
var i;
|
|
self.length = 0;
|
|
self.add(items);
|
|
for (i = self.length; i < len; i++) {
|
|
delete self[i];
|
|
}
|
|
return self;
|
|
},
|
|
filter: function (selector) {
|
|
var self = this;
|
|
var i, l;
|
|
var matches = [];
|
|
var item, match;
|
|
if (typeof selector === 'string') {
|
|
selector = new Selector(selector);
|
|
match = function (item) {
|
|
return selector.match(item);
|
|
};
|
|
} else {
|
|
match = selector;
|
|
}
|
|
for (i = 0, l = self.length; i < l; i++) {
|
|
item = self[i];
|
|
if (match(item)) {
|
|
matches.push(item);
|
|
}
|
|
}
|
|
return new Collection$1(matches);
|
|
},
|
|
slice: function () {
|
|
return new Collection$1(slice$1.apply(this, arguments));
|
|
},
|
|
eq: function (index) {
|
|
return index === -1 ? this.slice(index) : this.slice(index, +index + 1);
|
|
},
|
|
each: function (callback) {
|
|
global$4.each(this, callback);
|
|
return this;
|
|
},
|
|
toArray: function () {
|
|
return global$4.toArray(this);
|
|
},
|
|
indexOf: function (ctrl) {
|
|
var self = this;
|
|
var i = self.length;
|
|
while (i--) {
|
|
if (self[i] === ctrl) {
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
},
|
|
reverse: function () {
|
|
return new Collection$1(global$4.toArray(this).reverse());
|
|
},
|
|
hasClass: function (cls) {
|
|
return this[0] ? this[0].classes.contains(cls) : false;
|
|
},
|
|
prop: function (name, value) {
|
|
var self = this;
|
|
var item;
|
|
if (value !== undefined) {
|
|
self.each(function (item) {
|
|
if (item[name]) {
|
|
item[name](value);
|
|
}
|
|
});
|
|
return self;
|
|
}
|
|
item = self[0];
|
|
if (item && item[name]) {
|
|
return item[name]();
|
|
}
|
|
},
|
|
exec: function (name) {
|
|
var self = this, args = global$4.toArray(arguments).slice(1);
|
|
self.each(function (item) {
|
|
if (item[name]) {
|
|
item[name].apply(item, args);
|
|
}
|
|
});
|
|
return self;
|
|
},
|
|
remove: function () {
|
|
var i = this.length;
|
|
while (i--) {
|
|
this[i].remove();
|
|
}
|
|
return this;
|
|
},
|
|
addClass: function (cls) {
|
|
return this.each(function (item) {
|
|
item.classes.add(cls);
|
|
});
|
|
},
|
|
removeClass: function (cls) {
|
|
return this.each(function (item) {
|
|
item.classes.remove(cls);
|
|
});
|
|
}
|
|
};
|
|
global$4.each('fire on off show hide append prepend before after reflow'.split(' '), function (name) {
|
|
proto[name] = function () {
|
|
var args = global$4.toArray(arguments);
|
|
this.each(function (ctrl) {
|
|
if (name in ctrl) {
|
|
ctrl[name].apply(ctrl, args);
|
|
}
|
|
});
|
|
return this;
|
|
};
|
|
});
|
|
global$4.each('text name disabled active selected checked visible parent value data'.split(' '), function (name) {
|
|
proto[name] = function (value) {
|
|
return this.prop(name, value);
|
|
};
|
|
});
|
|
Collection$1 = global$8.extend(proto);
|
|
Selector.Collection = Collection$1;
|
|
var Collection$2 = Collection$1;
|
|
|
|
var Binding = function (settings) {
|
|
this.create = settings.create;
|
|
};
|
|
Binding.create = function (model, name) {
|
|
return new Binding({
|
|
create: function (otherModel, otherName) {
|
|
var bindings;
|
|
var fromSelfToOther = function (e) {
|
|
otherModel.set(otherName, e.value);
|
|
};
|
|
var fromOtherToSelf = function (e) {
|
|
model.set(name, e.value);
|
|
};
|
|
otherModel.on('change:' + otherName, fromOtherToSelf);
|
|
model.on('change:' + name, fromSelfToOther);
|
|
bindings = otherModel._bindings;
|
|
if (!bindings) {
|
|
bindings = otherModel._bindings = [];
|
|
otherModel.on('destroy', function () {
|
|
var i = bindings.length;
|
|
while (i--) {
|
|
bindings[i]();
|
|
}
|
|
});
|
|
}
|
|
bindings.push(function () {
|
|
model.off('change:' + name, fromSelfToOther);
|
|
});
|
|
return model.get(name);
|
|
}
|
|
});
|
|
};
|
|
|
|
var global$10 = tinymce.util.Tools.resolve('tinymce.util.Observable');
|
|
|
|
function isNode(node) {
|
|
return node.nodeType > 0;
|
|
}
|
|
function isEqual(a, b) {
|
|
var k, checked;
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (a === null || b === null) {
|
|
return a === b;
|
|
}
|
|
if (typeof a !== 'object' || typeof b !== 'object') {
|
|
return a === b;
|
|
}
|
|
if (global$4.isArray(b)) {
|
|
if (a.length !== b.length) {
|
|
return false;
|
|
}
|
|
k = a.length;
|
|
while (k--) {
|
|
if (!isEqual(a[k], b[k])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (isNode(a) || isNode(b)) {
|
|
return a === b;
|
|
}
|
|
checked = {};
|
|
for (k in b) {
|
|
if (!isEqual(a[k], b[k])) {
|
|
return false;
|
|
}
|
|
checked[k] = true;
|
|
}
|
|
for (k in a) {
|
|
if (!checked[k] && !isEqual(a[k], b[k])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
var ObservableObject = global$8.extend({
|
|
Mixins: [global$10],
|
|
init: function (data) {
|
|
var name, value;
|
|
data = data || {};
|
|
for (name in data) {
|
|
value = data[name];
|
|
if (value instanceof Binding) {
|
|
data[name] = value.create(this, name);
|
|
}
|
|
}
|
|
this.data = data;
|
|
},
|
|
set: function (name, value) {
|
|
var key, args;
|
|
var oldValue = this.data[name];
|
|
if (value instanceof Binding) {
|
|
value = value.create(this, name);
|
|
}
|
|
if (typeof name === 'object') {
|
|
for (key in name) {
|
|
this.set(key, name[key]);
|
|
}
|
|
return this;
|
|
}
|
|
if (!isEqual(oldValue, value)) {
|
|
this.data[name] = value;
|
|
args = {
|
|
target: this,
|
|
name: name,
|
|
value: value,
|
|
oldValue: oldValue
|
|
};
|
|
this.fire('change:' + name, args);
|
|
this.fire('change', args);
|
|
}
|
|
return this;
|
|
},
|
|
get: function (name) {
|
|
return this.data[name];
|
|
},
|
|
has: function (name) {
|
|
return name in this.data;
|
|
},
|
|
bind: function (name) {
|
|
return Binding.create(this, name);
|
|
},
|
|
destroy: function () {
|
|
this.fire('destroy');
|
|
}
|
|
});
|
|
|
|
var dirtyCtrls = {};
|
|
var animationFrameRequested;
|
|
var $_cqjgb518wjjgwek2f = {
|
|
add: function (ctrl) {
|
|
var parent$$1 = ctrl.parent();
|
|
if (parent$$1) {
|
|
if (!parent$$1._layout || parent$$1._layout.isNative()) {
|
|
return;
|
|
}
|
|
if (!dirtyCtrls[parent$$1._id]) {
|
|
dirtyCtrls[parent$$1._id] = parent$$1;
|
|
}
|
|
if (!animationFrameRequested) {
|
|
animationFrameRequested = true;
|
|
global$3.requestAnimationFrame(function () {
|
|
var id, ctrl;
|
|
animationFrameRequested = false;
|
|
for (id in dirtyCtrls) {
|
|
ctrl = dirtyCtrls[id];
|
|
if (ctrl.state.get('rendered')) {
|
|
ctrl.reflow();
|
|
}
|
|
}
|
|
dirtyCtrls = {};
|
|
}, document.body);
|
|
}
|
|
}
|
|
},
|
|
remove: function (ctrl) {
|
|
if (dirtyCtrls[ctrl._id]) {
|
|
delete dirtyCtrls[ctrl._id];
|
|
}
|
|
}
|
|
};
|
|
|
|
var getUiContainerDelta = function (ctrl) {
|
|
var uiContainer = getUiContainer(ctrl);
|
|
if (uiContainer && global$2.DOM.getStyle(uiContainer, 'position', true) !== 'static') {
|
|
var containerPos = global$2.DOM.getPos(uiContainer);
|
|
var dx = uiContainer.scrollLeft - containerPos.x;
|
|
var dy = uiContainer.scrollTop - containerPos.y;
|
|
return Option.some({
|
|
x: dx,
|
|
y: dy
|
|
});
|
|
} else {
|
|
return Option.none();
|
|
}
|
|
};
|
|
var setUiContainer = function (editor, ctrl) {
|
|
var uiContainer = global$2.DOM.select(editor.settings.ui_container)[0];
|
|
ctrl.getRoot().uiContainer = uiContainer;
|
|
};
|
|
var getUiContainer = function (ctrl) {
|
|
return ctrl ? ctrl.getRoot().uiContainer : null;
|
|
};
|
|
var inheritUiContainer = function (fromCtrl, toCtrl) {
|
|
return toCtrl.uiContainer = getUiContainer(fromCtrl);
|
|
};
|
|
var $_egt6ye18xjjgwek2h = {
|
|
getUiContainerDelta: getUiContainerDelta,
|
|
setUiContainer: setUiContainer,
|
|
getUiContainer: getUiContainer,
|
|
inheritUiContainer: inheritUiContainer
|
|
};
|
|
|
|
var hasMouseWheelEventSupport = 'onmousewheel' in document;
|
|
var hasWheelEventSupport = false;
|
|
var classPrefix = 'mce-';
|
|
var Control;
|
|
var idCounter = 0;
|
|
var proto$1 = {
|
|
Statics: { classPrefix: classPrefix },
|
|
isRtl: function () {
|
|
return Control.rtl;
|
|
},
|
|
classPrefix: classPrefix,
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
var classes, defaultClasses;
|
|
function applyClasses(classes) {
|
|
var i;
|
|
classes = classes.split(' ');
|
|
for (i = 0; i < classes.length; i++) {
|
|
self$$1.classes.add(classes[i]);
|
|
}
|
|
}
|
|
self$$1.settings = settings = global$4.extend({}, self$$1.Defaults, settings);
|
|
self$$1._id = settings.id || 'mceu_' + idCounter++;
|
|
self$$1._aria = { role: settings.role };
|
|
self$$1._elmCache = {};
|
|
self$$1.$ = global$7;
|
|
self$$1.state = new ObservableObject({
|
|
visible: true,
|
|
active: false,
|
|
disabled: false,
|
|
value: ''
|
|
});
|
|
self$$1.data = new ObservableObject(settings.data);
|
|
self$$1.classes = new ClassList(function () {
|
|
if (self$$1.state.get('rendered')) {
|
|
self$$1.getEl().className = this.toString();
|
|
}
|
|
});
|
|
self$$1.classes.prefix = self$$1.classPrefix;
|
|
classes = settings.classes;
|
|
if (classes) {
|
|
if (self$$1.Defaults) {
|
|
defaultClasses = self$$1.Defaults.classes;
|
|
if (defaultClasses && classes !== defaultClasses) {
|
|
applyClasses(defaultClasses);
|
|
}
|
|
}
|
|
applyClasses(classes);
|
|
}
|
|
global$4.each('title text name visible disabled active value'.split(' '), function (name$$1) {
|
|
if (name$$1 in settings) {
|
|
self$$1[name$$1](settings[name$$1]);
|
|
}
|
|
});
|
|
self$$1.on('click', function () {
|
|
if (self$$1.disabled()) {
|
|
return false;
|
|
}
|
|
});
|
|
self$$1.settings = settings;
|
|
self$$1.borderBox = $_4kbuyt18pjjgwek1w.parseBox(settings.border);
|
|
self$$1.paddingBox = $_4kbuyt18pjjgwek1w.parseBox(settings.padding);
|
|
self$$1.marginBox = $_4kbuyt18pjjgwek1w.parseBox(settings.margin);
|
|
if (settings.hidden) {
|
|
self$$1.hide();
|
|
}
|
|
},
|
|
Properties: 'parent,name',
|
|
getContainerElm: function () {
|
|
var uiContainer = $_egt6ye18xjjgwek2h.getUiContainer(this);
|
|
return uiContainer ? uiContainer : funcs.getContainer();
|
|
},
|
|
getParentCtrl: function (elm) {
|
|
var ctrl;
|
|
var lookup = this.getRoot().controlIdLookup;
|
|
while (elm && lookup) {
|
|
ctrl = lookup[elm.id];
|
|
if (ctrl) {
|
|
break;
|
|
}
|
|
elm = elm.parentNode;
|
|
}
|
|
return ctrl;
|
|
},
|
|
initLayoutRect: function () {
|
|
var self$$1 = this;
|
|
var settings = self$$1.settings;
|
|
var borderBox, layoutRect;
|
|
var elm = self$$1.getEl();
|
|
var width, height, minWidth, minHeight, autoResize;
|
|
var startMinWidth, startMinHeight, initialSize;
|
|
borderBox = self$$1.borderBox = self$$1.borderBox || $_4kbuyt18pjjgwek1w.measureBox(elm, 'border');
|
|
self$$1.paddingBox = self$$1.paddingBox || $_4kbuyt18pjjgwek1w.measureBox(elm, 'padding');
|
|
self$$1.marginBox = self$$1.marginBox || $_4kbuyt18pjjgwek1w.measureBox(elm, 'margin');
|
|
initialSize = funcs.getSize(elm);
|
|
startMinWidth = settings.minWidth;
|
|
startMinHeight = settings.minHeight;
|
|
minWidth = startMinWidth || initialSize.width;
|
|
minHeight = startMinHeight || initialSize.height;
|
|
width = settings.width;
|
|
height = settings.height;
|
|
autoResize = settings.autoResize;
|
|
autoResize = typeof autoResize !== 'undefined' ? autoResize : !width && !height;
|
|
width = width || minWidth;
|
|
height = height || minHeight;
|
|
var deltaW = borderBox.left + borderBox.right;
|
|
var deltaH = borderBox.top + borderBox.bottom;
|
|
var maxW = settings.maxWidth || 65535;
|
|
var maxH = settings.maxHeight || 65535;
|
|
self$$1._layoutRect = layoutRect = {
|
|
x: settings.x || 0,
|
|
y: settings.y || 0,
|
|
w: width,
|
|
h: height,
|
|
deltaW: deltaW,
|
|
deltaH: deltaH,
|
|
contentW: width - deltaW,
|
|
contentH: height - deltaH,
|
|
innerW: width - deltaW,
|
|
innerH: height - deltaH,
|
|
startMinWidth: startMinWidth || 0,
|
|
startMinHeight: startMinHeight || 0,
|
|
minW: Math.min(minWidth, maxW),
|
|
minH: Math.min(minHeight, maxH),
|
|
maxW: maxW,
|
|
maxH: maxH,
|
|
autoResize: autoResize,
|
|
scrollW: 0
|
|
};
|
|
self$$1._lastLayoutRect = {};
|
|
return layoutRect;
|
|
},
|
|
layoutRect: function (newRect) {
|
|
var self$$1 = this;
|
|
var curRect = self$$1._layoutRect, lastLayoutRect, size, deltaWidth, deltaHeight, repaintControls;
|
|
if (!curRect) {
|
|
curRect = self$$1.initLayoutRect();
|
|
}
|
|
if (newRect) {
|
|
deltaWidth = curRect.deltaW;
|
|
deltaHeight = curRect.deltaH;
|
|
if (newRect.x !== undefined) {
|
|
curRect.x = newRect.x;
|
|
}
|
|
if (newRect.y !== undefined) {
|
|
curRect.y = newRect.y;
|
|
}
|
|
if (newRect.minW !== undefined) {
|
|
curRect.minW = newRect.minW;
|
|
}
|
|
if (newRect.minH !== undefined) {
|
|
curRect.minH = newRect.minH;
|
|
}
|
|
size = newRect.w;
|
|
if (size !== undefined) {
|
|
size = size < curRect.minW ? curRect.minW : size;
|
|
size = size > curRect.maxW ? curRect.maxW : size;
|
|
curRect.w = size;
|
|
curRect.innerW = size - deltaWidth;
|
|
}
|
|
size = newRect.h;
|
|
if (size !== undefined) {
|
|
size = size < curRect.minH ? curRect.minH : size;
|
|
size = size > curRect.maxH ? curRect.maxH : size;
|
|
curRect.h = size;
|
|
curRect.innerH = size - deltaHeight;
|
|
}
|
|
size = newRect.innerW;
|
|
if (size !== undefined) {
|
|
size = size < curRect.minW - deltaWidth ? curRect.minW - deltaWidth : size;
|
|
size = size > curRect.maxW - deltaWidth ? curRect.maxW - deltaWidth : size;
|
|
curRect.innerW = size;
|
|
curRect.w = size + deltaWidth;
|
|
}
|
|
size = newRect.innerH;
|
|
if (size !== undefined) {
|
|
size = size < curRect.minH - deltaHeight ? curRect.minH - deltaHeight : size;
|
|
size = size > curRect.maxH - deltaHeight ? curRect.maxH - deltaHeight : size;
|
|
curRect.innerH = size;
|
|
curRect.h = size + deltaHeight;
|
|
}
|
|
if (newRect.contentW !== undefined) {
|
|
curRect.contentW = newRect.contentW;
|
|
}
|
|
if (newRect.contentH !== undefined) {
|
|
curRect.contentH = newRect.contentH;
|
|
}
|
|
lastLayoutRect = self$$1._lastLayoutRect;
|
|
if (lastLayoutRect.x !== curRect.x || lastLayoutRect.y !== curRect.y || lastLayoutRect.w !== curRect.w || lastLayoutRect.h !== curRect.h) {
|
|
repaintControls = Control.repaintControls;
|
|
if (repaintControls) {
|
|
if (repaintControls.map && !repaintControls.map[self$$1._id]) {
|
|
repaintControls.push(self$$1);
|
|
repaintControls.map[self$$1._id] = true;
|
|
}
|
|
}
|
|
lastLayoutRect.x = curRect.x;
|
|
lastLayoutRect.y = curRect.y;
|
|
lastLayoutRect.w = curRect.w;
|
|
lastLayoutRect.h = curRect.h;
|
|
}
|
|
return self$$1;
|
|
}
|
|
return curRect;
|
|
},
|
|
repaint: function () {
|
|
var self$$1 = this;
|
|
var style, bodyStyle, bodyElm, rect, borderBox;
|
|
var borderW, borderH, lastRepaintRect, round, value;
|
|
round = !document.createRange ? Math.round : function (value) {
|
|
return value;
|
|
};
|
|
style = self$$1.getEl().style;
|
|
rect = self$$1._layoutRect;
|
|
lastRepaintRect = self$$1._lastRepaintRect || {};
|
|
borderBox = self$$1.borderBox;
|
|
borderW = borderBox.left + borderBox.right;
|
|
borderH = borderBox.top + borderBox.bottom;
|
|
if (rect.x !== lastRepaintRect.x) {
|
|
style.left = round(rect.x) + 'px';
|
|
lastRepaintRect.x = rect.x;
|
|
}
|
|
if (rect.y !== lastRepaintRect.y) {
|
|
style.top = round(rect.y) + 'px';
|
|
lastRepaintRect.y = rect.y;
|
|
}
|
|
if (rect.w !== lastRepaintRect.w) {
|
|
value = round(rect.w - borderW);
|
|
style.width = (value >= 0 ? value : 0) + 'px';
|
|
lastRepaintRect.w = rect.w;
|
|
}
|
|
if (rect.h !== lastRepaintRect.h) {
|
|
value = round(rect.h - borderH);
|
|
style.height = (value >= 0 ? value : 0) + 'px';
|
|
lastRepaintRect.h = rect.h;
|
|
}
|
|
if (self$$1._hasBody && rect.innerW !== lastRepaintRect.innerW) {
|
|
value = round(rect.innerW);
|
|
bodyElm = self$$1.getEl('body');
|
|
if (bodyElm) {
|
|
bodyStyle = bodyElm.style;
|
|
bodyStyle.width = (value >= 0 ? value : 0) + 'px';
|
|
}
|
|
lastRepaintRect.innerW = rect.innerW;
|
|
}
|
|
if (self$$1._hasBody && rect.innerH !== lastRepaintRect.innerH) {
|
|
value = round(rect.innerH);
|
|
bodyElm = bodyElm || self$$1.getEl('body');
|
|
if (bodyElm) {
|
|
bodyStyle = bodyStyle || bodyElm.style;
|
|
bodyStyle.height = (value >= 0 ? value : 0) + 'px';
|
|
}
|
|
lastRepaintRect.innerH = rect.innerH;
|
|
}
|
|
self$$1._lastRepaintRect = lastRepaintRect;
|
|
self$$1.fire('repaint', {}, false);
|
|
},
|
|
updateLayoutRect: function () {
|
|
var self$$1 = this;
|
|
self$$1.parent()._lastRect = null;
|
|
funcs.css(self$$1.getEl(), {
|
|
width: '',
|
|
height: ''
|
|
});
|
|
self$$1._layoutRect = self$$1._lastRepaintRect = self$$1._lastLayoutRect = null;
|
|
self$$1.initLayoutRect();
|
|
},
|
|
on: function (name$$1, callback) {
|
|
var self$$1 = this;
|
|
function resolveCallbackName(name$$1) {
|
|
var callback, scope;
|
|
if (typeof name$$1 !== 'string') {
|
|
return name$$1;
|
|
}
|
|
return function (e) {
|
|
if (!callback) {
|
|
self$$1.parentsAndSelf().each(function (ctrl) {
|
|
var callbacks = ctrl.settings.callbacks;
|
|
if (callbacks && (callback = callbacks[name$$1])) {
|
|
scope = ctrl;
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
if (!callback) {
|
|
e.action = name$$1;
|
|
this.fire('execute', e);
|
|
return;
|
|
}
|
|
return callback.call(scope, e);
|
|
};
|
|
}
|
|
getEventDispatcher(self$$1).on(name$$1, resolveCallbackName(callback));
|
|
return self$$1;
|
|
},
|
|
off: function (name$$1, callback) {
|
|
getEventDispatcher(this).off(name$$1, callback);
|
|
return this;
|
|
},
|
|
fire: function (name$$1, args, bubble) {
|
|
var self$$1 = this;
|
|
args = args || {};
|
|
if (!args.control) {
|
|
args.control = self$$1;
|
|
}
|
|
args = getEventDispatcher(self$$1).fire(name$$1, args);
|
|
if (bubble !== false && self$$1.parent) {
|
|
var parent$$1 = self$$1.parent();
|
|
while (parent$$1 && !args.isPropagationStopped()) {
|
|
parent$$1.fire(name$$1, args, false);
|
|
parent$$1 = parent$$1.parent();
|
|
}
|
|
}
|
|
return args;
|
|
},
|
|
hasEventListeners: function (name$$1) {
|
|
return getEventDispatcher(this).has(name$$1);
|
|
},
|
|
parents: function (selector) {
|
|
var self$$1 = this;
|
|
var ctrl, parents = new Collection$2();
|
|
for (ctrl = self$$1.parent(); ctrl; ctrl = ctrl.parent()) {
|
|
parents.add(ctrl);
|
|
}
|
|
if (selector) {
|
|
parents = parents.filter(selector);
|
|
}
|
|
return parents;
|
|
},
|
|
parentsAndSelf: function (selector) {
|
|
return new Collection$2(this).add(this.parents(selector));
|
|
},
|
|
next: function () {
|
|
var parentControls = this.parent().items();
|
|
return parentControls[parentControls.indexOf(this) + 1];
|
|
},
|
|
prev: function () {
|
|
var parentControls = this.parent().items();
|
|
return parentControls[parentControls.indexOf(this) - 1];
|
|
},
|
|
innerHtml: function (html) {
|
|
this.$el.html(html);
|
|
return this;
|
|
},
|
|
getEl: function (suffix) {
|
|
var id = suffix ? this._id + '-' + suffix : this._id;
|
|
if (!this._elmCache[id]) {
|
|
this._elmCache[id] = global$7('#' + id)[0];
|
|
}
|
|
return this._elmCache[id];
|
|
},
|
|
show: function () {
|
|
return this.visible(true);
|
|
},
|
|
hide: function () {
|
|
return this.visible(false);
|
|
},
|
|
focus: function () {
|
|
try {
|
|
this.getEl().focus();
|
|
} catch (ex) {
|
|
}
|
|
return this;
|
|
},
|
|
blur: function () {
|
|
this.getEl().blur();
|
|
return this;
|
|
},
|
|
aria: function (name$$1, value) {
|
|
var self$$1 = this, elm = self$$1.getEl(self$$1.ariaTarget);
|
|
if (typeof value === 'undefined') {
|
|
return self$$1._aria[name$$1];
|
|
}
|
|
self$$1._aria[name$$1] = value;
|
|
if (self$$1.state.get('rendered')) {
|
|
elm.setAttribute(name$$1 === 'role' ? name$$1 : 'aria-' + name$$1, value);
|
|
}
|
|
return self$$1;
|
|
},
|
|
encode: function (text, translate) {
|
|
if (translate !== false) {
|
|
text = this.translate(text);
|
|
}
|
|
return (text || '').replace(/[&<>"]/g, function (match) {
|
|
return '&#' + match.charCodeAt(0) + ';';
|
|
});
|
|
},
|
|
translate: function (text) {
|
|
return Control.translate ? Control.translate(text) : text;
|
|
},
|
|
before: function (items) {
|
|
var self$$1 = this, parent$$1 = self$$1.parent();
|
|
if (parent$$1) {
|
|
parent$$1.insert(items, parent$$1.items().indexOf(self$$1), true);
|
|
}
|
|
return self$$1;
|
|
},
|
|
after: function (items) {
|
|
var self$$1 = this, parent$$1 = self$$1.parent();
|
|
if (parent$$1) {
|
|
parent$$1.insert(items, parent$$1.items().indexOf(self$$1));
|
|
}
|
|
return self$$1;
|
|
},
|
|
remove: function () {
|
|
var self$$1 = this;
|
|
var elm = self$$1.getEl();
|
|
var parent$$1 = self$$1.parent();
|
|
var newItems, i;
|
|
if (self$$1.items) {
|
|
var controls = self$$1.items().toArray();
|
|
i = controls.length;
|
|
while (i--) {
|
|
controls[i].remove();
|
|
}
|
|
}
|
|
if (parent$$1 && parent$$1.items) {
|
|
newItems = [];
|
|
parent$$1.items().each(function (item) {
|
|
if (item !== self$$1) {
|
|
newItems.push(item);
|
|
}
|
|
});
|
|
parent$$1.items().set(newItems);
|
|
parent$$1._lastRect = null;
|
|
}
|
|
if (self$$1._eventsRoot && self$$1._eventsRoot === self$$1) {
|
|
global$7(elm).off();
|
|
}
|
|
var lookup = self$$1.getRoot().controlIdLookup;
|
|
if (lookup) {
|
|
delete lookup[self$$1._id];
|
|
}
|
|
if (elm && elm.parentNode) {
|
|
elm.parentNode.removeChild(elm);
|
|
}
|
|
self$$1.state.set('rendered', false);
|
|
self$$1.state.destroy();
|
|
self$$1.fire('remove');
|
|
return self$$1;
|
|
},
|
|
renderBefore: function (elm) {
|
|
global$7(elm).before(this.renderHtml());
|
|
this.postRender();
|
|
return this;
|
|
},
|
|
renderTo: function (elm) {
|
|
global$7(elm || this.getContainerElm()).append(this.renderHtml());
|
|
this.postRender();
|
|
return this;
|
|
},
|
|
preRender: function () {
|
|
},
|
|
render: function () {
|
|
},
|
|
renderHtml: function () {
|
|
return '<div id="' + this._id + '" class="' + this.classes + '"></div>';
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this;
|
|
var settings = self$$1.settings;
|
|
var elm, box, parent$$1, name$$1, parentEventsRoot;
|
|
self$$1.$el = global$7(self$$1.getEl());
|
|
self$$1.state.set('rendered', true);
|
|
for (name$$1 in settings) {
|
|
if (name$$1.indexOf('on') === 0) {
|
|
self$$1.on(name$$1.substr(2), settings[name$$1]);
|
|
}
|
|
}
|
|
if (self$$1._eventsRoot) {
|
|
for (parent$$1 = self$$1.parent(); !parentEventsRoot && parent$$1; parent$$1 = parent$$1.parent()) {
|
|
parentEventsRoot = parent$$1._eventsRoot;
|
|
}
|
|
if (parentEventsRoot) {
|
|
for (name$$1 in parentEventsRoot._nativeEvents) {
|
|
self$$1._nativeEvents[name$$1] = true;
|
|
}
|
|
}
|
|
}
|
|
bindPendingEvents(self$$1);
|
|
if (settings.style) {
|
|
elm = self$$1.getEl();
|
|
if (elm) {
|
|
elm.setAttribute('style', settings.style);
|
|
elm.style.cssText = settings.style;
|
|
}
|
|
}
|
|
if (self$$1.settings.border) {
|
|
box = self$$1.borderBox;
|
|
self$$1.$el.css({
|
|
'border-top-width': box.top,
|
|
'border-right-width': box.right,
|
|
'border-bottom-width': box.bottom,
|
|
'border-left-width': box.left
|
|
});
|
|
}
|
|
var root = self$$1.getRoot();
|
|
if (!root.controlIdLookup) {
|
|
root.controlIdLookup = {};
|
|
}
|
|
root.controlIdLookup[self$$1._id] = self$$1;
|
|
for (var key in self$$1._aria) {
|
|
self$$1.aria(key, self$$1._aria[key]);
|
|
}
|
|
if (self$$1.state.get('visible') === false) {
|
|
self$$1.getEl().style.display = 'none';
|
|
}
|
|
self$$1.bindStates();
|
|
self$$1.state.on('change:visible', function (e) {
|
|
var state = e.value;
|
|
var parentCtrl;
|
|
if (self$$1.state.get('rendered')) {
|
|
self$$1.getEl().style.display = state === false ? 'none' : '';
|
|
self$$1.getEl().getBoundingClientRect();
|
|
}
|
|
parentCtrl = self$$1.parent();
|
|
if (parentCtrl) {
|
|
parentCtrl._lastRect = null;
|
|
}
|
|
self$$1.fire(state ? 'show' : 'hide');
|
|
$_cqjgb518wjjgwek2f.add(self$$1);
|
|
});
|
|
self$$1.fire('postrender', {}, false);
|
|
},
|
|
bindStates: function () {
|
|
},
|
|
scrollIntoView: function (align) {
|
|
function getOffset(elm, rootElm) {
|
|
var x, y, parent$$1 = elm;
|
|
x = y = 0;
|
|
while (parent$$1 && parent$$1 !== rootElm && parent$$1.nodeType) {
|
|
x += parent$$1.offsetLeft || 0;
|
|
y += parent$$1.offsetTop || 0;
|
|
parent$$1 = parent$$1.offsetParent;
|
|
}
|
|
return {
|
|
x: x,
|
|
y: y
|
|
};
|
|
}
|
|
var elm = this.getEl(), parentElm = elm.parentNode;
|
|
var x, y, width, height, parentWidth, parentHeight;
|
|
var pos = getOffset(elm, parentElm);
|
|
x = pos.x;
|
|
y = pos.y;
|
|
width = elm.offsetWidth;
|
|
height = elm.offsetHeight;
|
|
parentWidth = parentElm.clientWidth;
|
|
parentHeight = parentElm.clientHeight;
|
|
if (align === 'end') {
|
|
x -= parentWidth - width;
|
|
y -= parentHeight - height;
|
|
} else if (align === 'center') {
|
|
x -= parentWidth / 2 - width / 2;
|
|
y -= parentHeight / 2 - height / 2;
|
|
}
|
|
parentElm.scrollLeft = x;
|
|
parentElm.scrollTop = y;
|
|
return this;
|
|
},
|
|
getRoot: function () {
|
|
var ctrl = this, rootControl;
|
|
var parents = [];
|
|
while (ctrl) {
|
|
if (ctrl.rootControl) {
|
|
rootControl = ctrl.rootControl;
|
|
break;
|
|
}
|
|
parents.push(ctrl);
|
|
rootControl = ctrl;
|
|
ctrl = ctrl.parent();
|
|
}
|
|
if (!rootControl) {
|
|
rootControl = this;
|
|
}
|
|
var i = parents.length;
|
|
while (i--) {
|
|
parents[i].rootControl = rootControl;
|
|
}
|
|
return rootControl;
|
|
},
|
|
reflow: function () {
|
|
$_cqjgb518wjjgwek2f.remove(this);
|
|
var parent$$1 = this.parent();
|
|
if (parent$$1 && parent$$1._layout && !parent$$1._layout.isNative()) {
|
|
parent$$1.reflow();
|
|
}
|
|
return this;
|
|
}
|
|
};
|
|
global$4.each('text title visible disabled active value'.split(' '), function (name$$1) {
|
|
proto$1[name$$1] = function (value) {
|
|
if (arguments.length === 0) {
|
|
return this.state.get(name$$1);
|
|
}
|
|
if (typeof value !== 'undefined') {
|
|
this.state.set(name$$1, value);
|
|
}
|
|
return this;
|
|
};
|
|
});
|
|
Control = global$8.extend(proto$1);
|
|
function getEventDispatcher(obj) {
|
|
if (!obj._eventDispatcher) {
|
|
obj._eventDispatcher = new global$9({
|
|
scope: obj,
|
|
toggleEvent: function (name$$1, state) {
|
|
if (state && global$9.isNative(name$$1)) {
|
|
if (!obj._nativeEvents) {
|
|
obj._nativeEvents = {};
|
|
}
|
|
obj._nativeEvents[name$$1] = true;
|
|
if (obj.state.get('rendered')) {
|
|
bindPendingEvents(obj);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return obj._eventDispatcher;
|
|
}
|
|
function bindPendingEvents(eventCtrl) {
|
|
var i, l, parents, eventRootCtrl, nativeEvents, name$$1;
|
|
function delegate(e) {
|
|
var control = eventCtrl.getParentCtrl(e.target);
|
|
if (control) {
|
|
control.fire(e.type, e);
|
|
}
|
|
}
|
|
function mouseLeaveHandler() {
|
|
var ctrl = eventRootCtrl._lastHoverCtrl;
|
|
if (ctrl) {
|
|
ctrl.fire('mouseleave', { target: ctrl.getEl() });
|
|
ctrl.parents().each(function (ctrl) {
|
|
ctrl.fire('mouseleave', { target: ctrl.getEl() });
|
|
});
|
|
eventRootCtrl._lastHoverCtrl = null;
|
|
}
|
|
}
|
|
function mouseEnterHandler(e) {
|
|
var ctrl = eventCtrl.getParentCtrl(e.target), lastCtrl = eventRootCtrl._lastHoverCtrl, idx = 0, i, parents, lastParents;
|
|
if (ctrl !== lastCtrl) {
|
|
eventRootCtrl._lastHoverCtrl = ctrl;
|
|
parents = ctrl.parents().toArray().reverse();
|
|
parents.push(ctrl);
|
|
if (lastCtrl) {
|
|
lastParents = lastCtrl.parents().toArray().reverse();
|
|
lastParents.push(lastCtrl);
|
|
for (idx = 0; idx < lastParents.length; idx++) {
|
|
if (parents[idx] !== lastParents[idx]) {
|
|
break;
|
|
}
|
|
}
|
|
for (i = lastParents.length - 1; i >= idx; i--) {
|
|
lastCtrl = lastParents[i];
|
|
lastCtrl.fire('mouseleave', { target: lastCtrl.getEl() });
|
|
}
|
|
}
|
|
for (i = idx; i < parents.length; i++) {
|
|
ctrl = parents[i];
|
|
ctrl.fire('mouseenter', { target: ctrl.getEl() });
|
|
}
|
|
}
|
|
}
|
|
function fixWheelEvent(e) {
|
|
e.preventDefault();
|
|
if (e.type === 'mousewheel') {
|
|
e.deltaY = -1 / 40 * e.wheelDelta;
|
|
if (e.wheelDeltaX) {
|
|
e.deltaX = -1 / 40 * e.wheelDeltaX;
|
|
}
|
|
} else {
|
|
e.deltaX = 0;
|
|
e.deltaY = e.detail;
|
|
}
|
|
e = eventCtrl.fire('wheel', e);
|
|
}
|
|
nativeEvents = eventCtrl._nativeEvents;
|
|
if (nativeEvents) {
|
|
parents = eventCtrl.parents().toArray();
|
|
parents.unshift(eventCtrl);
|
|
for (i = 0, l = parents.length; !eventRootCtrl && i < l; i++) {
|
|
eventRootCtrl = parents[i]._eventsRoot;
|
|
}
|
|
if (!eventRootCtrl) {
|
|
eventRootCtrl = parents[parents.length - 1] || eventCtrl;
|
|
}
|
|
eventCtrl._eventsRoot = eventRootCtrl;
|
|
for (l = i, i = 0; i < l; i++) {
|
|
parents[i]._eventsRoot = eventRootCtrl;
|
|
}
|
|
var eventRootDelegates = eventRootCtrl._delegates;
|
|
if (!eventRootDelegates) {
|
|
eventRootDelegates = eventRootCtrl._delegates = {};
|
|
}
|
|
for (name$$1 in nativeEvents) {
|
|
if (!nativeEvents) {
|
|
return false;
|
|
}
|
|
if (name$$1 === 'wheel' && !hasWheelEventSupport) {
|
|
if (hasMouseWheelEventSupport) {
|
|
global$7(eventCtrl.getEl()).on('mousewheel', fixWheelEvent);
|
|
} else {
|
|
global$7(eventCtrl.getEl()).on('DOMMouseScroll', fixWheelEvent);
|
|
}
|
|
continue;
|
|
}
|
|
if (name$$1 === 'mouseenter' || name$$1 === 'mouseleave') {
|
|
if (!eventRootCtrl._hasMouseEnter) {
|
|
global$7(eventRootCtrl.getEl()).on('mouseleave', mouseLeaveHandler).on('mouseover', mouseEnterHandler);
|
|
eventRootCtrl._hasMouseEnter = 1;
|
|
}
|
|
} else if (!eventRootDelegates[name$$1]) {
|
|
global$7(eventRootCtrl.getEl()).on(name$$1, delegate);
|
|
eventRootDelegates[name$$1] = true;
|
|
}
|
|
nativeEvents[name$$1] = false;
|
|
}
|
|
}
|
|
}
|
|
var Control$1 = Control;
|
|
|
|
var isStatic = function (elm) {
|
|
return funcs.getRuntimeStyle(elm, 'position') === 'static';
|
|
};
|
|
var isFixed = function (ctrl) {
|
|
return ctrl.state.get('fixed');
|
|
};
|
|
function calculateRelativePosition(ctrl, targetElm, rel) {
|
|
var ctrlElm, pos, x, y, selfW, selfH, targetW, targetH, viewport, size;
|
|
viewport = getWindowViewPort();
|
|
pos = funcs.getPos(targetElm, $_egt6ye18xjjgwek2h.getUiContainer(ctrl));
|
|
x = pos.x;
|
|
y = pos.y;
|
|
if (isFixed(ctrl) && isStatic(document.body)) {
|
|
x -= viewport.x;
|
|
y -= viewport.y;
|
|
}
|
|
ctrlElm = ctrl.getEl();
|
|
size = funcs.getSize(ctrlElm);
|
|
selfW = size.width;
|
|
selfH = size.height;
|
|
size = funcs.getSize(targetElm);
|
|
targetW = size.width;
|
|
targetH = size.height;
|
|
rel = (rel || '').split('');
|
|
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);
|
|
}
|
|
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
|
|
};
|
|
}
|
|
var getUiContainerViewPort = function (customUiContainer) {
|
|
return {
|
|
x: 0,
|
|
y: 0,
|
|
w: customUiContainer.scrollWidth - 1,
|
|
h: customUiContainer.scrollHeight - 1
|
|
};
|
|
};
|
|
var getWindowViewPort = function () {
|
|
var win = window;
|
|
var x = Math.max(win.pageXOffset, document.body.scrollLeft, document.documentElement.scrollLeft);
|
|
var y = Math.max(win.pageYOffset, document.body.scrollTop, document.documentElement.scrollTop);
|
|
var w = win.innerWidth || document.documentElement.clientWidth;
|
|
var h = win.innerHeight || document.documentElement.clientHeight;
|
|
return {
|
|
x: x,
|
|
y: y,
|
|
w: x + w,
|
|
h: y + h
|
|
};
|
|
};
|
|
var getViewPortRect = function (ctrl) {
|
|
var customUiContainer = $_egt6ye18xjjgwek2h.getUiContainer(ctrl);
|
|
return customUiContainer && !isFixed(ctrl) ? getUiContainerViewPort(customUiContainer) : getWindowViewPort();
|
|
};
|
|
var $_8zu82i18yjjgwek2l = {
|
|
testMoveRel: function (elm, rels) {
|
|
var viewPortRect = getViewPortRect(this);
|
|
for (var i = 0; i < rels.length; i++) {
|
|
var pos = calculateRelativePosition(this, elm, rels[i]);
|
|
if (isFixed(this)) {
|
|
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 && pos.y > viewPortRect.y && pos.y + pos.h < viewPortRect.h) {
|
|
return rels[i];
|
|
}
|
|
}
|
|
}
|
|
return rels[0];
|
|
},
|
|
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);
|
|
},
|
|
moveBy: function (dx, dy) {
|
|
var self$$1 = this, rect = self$$1.layoutRect();
|
|
self$$1.moveTo(rect.x + dx, rect.y + dy);
|
|
return self$$1;
|
|
},
|
|
moveTo: function (x, y) {
|
|
var self$$1 = this;
|
|
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$$1.settings.constrainToViewport) {
|
|
var viewPortRect = getViewPortRect(this);
|
|
var layoutRect = self$$1.layoutRect();
|
|
x = constrain(x, viewPortRect.w, layoutRect.w);
|
|
y = constrain(y, viewPortRect.h, layoutRect.h);
|
|
}
|
|
var uiContainer = $_egt6ye18xjjgwek2h.getUiContainer(self$$1);
|
|
if (uiContainer && isStatic(uiContainer) && !isFixed(self$$1)) {
|
|
x -= uiContainer.scrollLeft;
|
|
y -= uiContainer.scrollTop;
|
|
}
|
|
if (uiContainer) {
|
|
x += 1;
|
|
y += 1;
|
|
}
|
|
if (self$$1.state.get('rendered')) {
|
|
self$$1.layoutRect({
|
|
x: x,
|
|
y: y
|
|
}).repaint();
|
|
} else {
|
|
self$$1.settings.x = x;
|
|
self$$1.settings.y = y;
|
|
}
|
|
self$$1.fire('move', {
|
|
x: x,
|
|
y: y
|
|
});
|
|
return self$$1;
|
|
}
|
|
};
|
|
|
|
var Tooltip = Control$1.extend({
|
|
Mixins: [$_8zu82i18yjjgwek2l],
|
|
Defaults: { classes: 'widget tooltip tooltip-n' },
|
|
renderHtml: function () {
|
|
var self = this, prefix = self.classPrefix;
|
|
return '<div id="' + self._id + '" class="' + self.classes + '" role="presentation">' + '<div class="' + prefix + 'tooltip-arrow"></div>' + '<div class="' + prefix + 'tooltip-inner">' + self.encode(self.state.get('text')) + '</div>' + '</div>';
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self.state.on('change:text', function (e) {
|
|
self.getEl().lastChild.innerHTML = self.encode(e.value);
|
|
});
|
|
return self._super();
|
|
},
|
|
repaint: function () {
|
|
var self = this;
|
|
var style, rect;
|
|
style = self.getEl().style;
|
|
rect = self._layoutRect;
|
|
style.left = rect.x + 'px';
|
|
style.top = rect.y + 'px';
|
|
style.zIndex = 65535 + 65535;
|
|
}
|
|
});
|
|
|
|
var Widget = Control$1.extend({
|
|
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(-65535);
|
|
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().remove();
|
|
self._tooltip = null;
|
|
});
|
|
}
|
|
self.aria('label', settings.ariaLabel || settings.tooltip);
|
|
},
|
|
tooltip: function () {
|
|
if (!this._tooltip) {
|
|
this._tooltip = new Tooltip({ type: 'tooltip' });
|
|
$_egt6ye18xjjgwek2h.inheritUiContainer(this, this._tooltip);
|
|
this._tooltip.renderTo();
|
|
}
|
|
return this._tooltip;
|
|
},
|
|
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();
|
|
},
|
|
remove: function () {
|
|
this._super();
|
|
if (this._tooltip) {
|
|
this._tooltip.remove();
|
|
this._tooltip = null;
|
|
}
|
|
}
|
|
});
|
|
|
|
var Progress = 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 '<div id="' + id + '" class="' + self.classes + '">' + '<div class="' + prefix + 'bar-container">' + '<div class="' + prefix + 'bar"></div>' + '</div>' + '<div class="' + prefix + 'text">0%</div>' + '</div>';
|
|
},
|
|
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();
|
|
}
|
|
});
|
|
|
|
var updateLiveRegion = function (ctx, text) {
|
|
ctx.getEl().lastChild.textContent = text + (ctx.progressBar ? ' ' + ctx.progressBar.value() + '%' : '');
|
|
};
|
|
var Notification = Control$1.extend({
|
|
Mixins: [$_8zu82i18yjjgwek2l],
|
|
Defaults: { classes: 'widget notification' },
|
|
init: function (settings) {
|
|
var self = this;
|
|
self._super(settings);
|
|
self.maxWidth = settings.maxWidth;
|
|
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();
|
|
}
|
|
});
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var prefix = self.classPrefix;
|
|
var icon = '', closeButton = '', progressBar = '', notificationStyle = '';
|
|
if (self.icon) {
|
|
icon = '<i class="' + prefix + 'ico' + ' ' + prefix + 'i-' + self.icon + '"></i>';
|
|
}
|
|
notificationStyle = ' style="max-width: ' + self.maxWidth + 'px;' + (self.color ? 'background-color: ' + self.color + ';"' : '"');
|
|
if (self.closeButton) {
|
|
closeButton = '<button type="button" class="' + prefix + 'close" aria-hidden="true">\xD7</button>';
|
|
}
|
|
if (self.progressBar) {
|
|
progressBar = self.progressBar.renderHtml();
|
|
}
|
|
return '<div id="' + self._id + '" class="' + self.classes + '"' + notificationStyle + ' role="presentation">' + icon + '<div class="' + prefix + 'notification-inner">' + self.state.get('text') + '</div>' + progressBar + closeButton + '<div style="clip: rect(1px, 1px, 1px, 1px);height: 1px;overflow: hidden;position: absolute;width: 1px;"' + ' aria-live="assertive" aria-relevant="additions" aria-atomic="true"></div>' + '</div>';
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
global$3.setTimeout(function () {
|
|
self.$el.addClass(self.classPrefix + 'in');
|
|
updateLiveRegion(self, self.state.get('text'));
|
|
}, 100);
|
|
return self._super();
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self.state.on('change:text', function (e) {
|
|
self.getEl().firstChild.innerHTML = e.value;
|
|
updateLiveRegion(self, e.value);
|
|
});
|
|
if (self.progressBar) {
|
|
self.progressBar.bindStates();
|
|
self.progressBar.state.on('change:value', function (e) {
|
|
updateLiveRegion(self, self.state.get('text'));
|
|
});
|
|
}
|
|
return self._super();
|
|
},
|
|
close: function () {
|
|
var self = this;
|
|
if (!self.fire('close').isDefaultPrevented()) {
|
|
self.remove();
|
|
}
|
|
return self;
|
|
},
|
|
repaint: function () {
|
|
var self = this;
|
|
var style, rect;
|
|
style = self.getEl().style;
|
|
rect = self._layoutRect;
|
|
style.left = rect.x + 'px';
|
|
style.top = rect.y + 'px';
|
|
style.zIndex = 65535 - 1;
|
|
}
|
|
});
|
|
|
|
function NotificationManagerImpl (editor) {
|
|
var getEditorContainer = function (editor) {
|
|
return editor.inline ? editor.getElement() : editor.getContentAreaContainer();
|
|
};
|
|
var getContainerWidth = function () {
|
|
var container = getEditorContainer(editor);
|
|
return funcs.getSize(container).width;
|
|
};
|
|
var prePositionNotifications = function (notifications) {
|
|
each(notifications, function (notification) {
|
|
notification.moveTo(0, 0);
|
|
});
|
|
};
|
|
var positionNotifications = function (notifications) {
|
|
if (notifications.length > 0) {
|
|
var firstItem = notifications.slice(0, 1)[0];
|
|
var container = getEditorContainer(editor);
|
|
firstItem.moveRel(container, 'tc-tc');
|
|
each(notifications, function (notification, index) {
|
|
if (index > 0) {
|
|
notification.moveRel(notifications[index - 1].getEl(), 'bc-tc');
|
|
}
|
|
});
|
|
}
|
|
};
|
|
var reposition = function (notifications) {
|
|
prePositionNotifications(notifications);
|
|
positionNotifications(notifications);
|
|
};
|
|
var open = function (args, closeCallback) {
|
|
var extendedArgs = global$4.extend(args, { maxWidth: getContainerWidth() });
|
|
var notif = new Notification(extendedArgs);
|
|
notif.args = extendedArgs;
|
|
if (extendedArgs.timeout > 0) {
|
|
notif.timer = setTimeout(function () {
|
|
notif.close();
|
|
closeCallback();
|
|
}, extendedArgs.timeout);
|
|
}
|
|
notif.on('close', function () {
|
|
closeCallback();
|
|
});
|
|
notif.renderTo();
|
|
return notif;
|
|
};
|
|
var close = function (notification) {
|
|
notification.close();
|
|
};
|
|
var getArgs = function (notification) {
|
|
return notification.args;
|
|
};
|
|
return {
|
|
open: open,
|
|
close: close,
|
|
reposition: reposition,
|
|
getArgs: getArgs
|
|
};
|
|
}
|
|
|
|
function getDocumentSize(doc) {
|
|
var documentElement, body, scrollWidth, clientWidth;
|
|
var offsetWidth, scrollHeight, clientHeight, offsetHeight;
|
|
var max = Math.max;
|
|
documentElement = doc.documentElement;
|
|
body = doc.body;
|
|
scrollWidth = max(documentElement.scrollWidth, body.scrollWidth);
|
|
clientWidth = max(documentElement.clientWidth, body.clientWidth);
|
|
offsetWidth = max(documentElement.offsetWidth, body.offsetWidth);
|
|
scrollHeight = max(documentElement.scrollHeight, body.scrollHeight);
|
|
clientHeight = max(documentElement.clientHeight, body.clientHeight);
|
|
offsetHeight = max(documentElement.offsetHeight, body.offsetHeight);
|
|
return {
|
|
width: scrollWidth < offsetWidth ? clientWidth : scrollWidth,
|
|
height: scrollHeight < offsetHeight ? clientHeight : scrollHeight
|
|
};
|
|
}
|
|
function updateWithTouchData(e) {
|
|
var keys, i;
|
|
if (e.changedTouches) {
|
|
keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
|
|
for (i = 0; i < keys.length; i++) {
|
|
e[keys[i]] = e.changedTouches[0][keys[i]];
|
|
}
|
|
}
|
|
}
|
|
function DragHelper (id, settings) {
|
|
var $eventOverlay;
|
|
var doc = settings.document || document;
|
|
var downButton;
|
|
var start, stop$$1, drag, startX, startY;
|
|
settings = settings || {};
|
|
var handleElement = doc.getElementById(settings.handle || id);
|
|
start = function (e) {
|
|
var docSize = getDocumentSize(doc);
|
|
var handleElm, cursor;
|
|
updateWithTouchData(e);
|
|
e.preventDefault();
|
|
downButton = e.button;
|
|
handleElm = handleElement;
|
|
startX = e.screenX;
|
|
startY = e.screenY;
|
|
if (window.getComputedStyle) {
|
|
cursor = window.getComputedStyle(handleElm, null).getPropertyValue('cursor');
|
|
} else {
|
|
cursor = handleElm.runtimeStyle.cursor;
|
|
}
|
|
$eventOverlay = global$7('<div></div>').css({
|
|
position: 'absolute',
|
|
top: 0,
|
|
left: 0,
|
|
width: docSize.width,
|
|
height: docSize.height,
|
|
zIndex: 2147483647,
|
|
opacity: 0.0001,
|
|
cursor: cursor
|
|
}).appendTo(doc.body);
|
|
global$7(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop$$1);
|
|
settings.start(e);
|
|
};
|
|
drag = function (e) {
|
|
updateWithTouchData(e);
|
|
if (e.button !== downButton) {
|
|
return stop$$1(e);
|
|
}
|
|
e.deltaX = e.screenX - startX;
|
|
e.deltaY = e.screenY - startY;
|
|
e.preventDefault();
|
|
settings.drag(e);
|
|
};
|
|
stop$$1 = function (e) {
|
|
updateWithTouchData(e);
|
|
global$7(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop$$1);
|
|
$eventOverlay.remove();
|
|
if (settings.stop) {
|
|
settings.stop(e);
|
|
}
|
|
};
|
|
this.destroy = function () {
|
|
global$7(handleElement).off();
|
|
};
|
|
global$7(handleElement).on('mousedown touchstart', start);
|
|
}
|
|
|
|
var global$11 = tinymce.util.Tools.resolve('tinymce.ui.Factory');
|
|
|
|
var hasTabstopData = function (elm) {
|
|
return elm.getAttribute('data-mce-tabstop') ? true : false;
|
|
};
|
|
function KeyboardNavigation (settings) {
|
|
var root = settings.root;
|
|
var focusedElement, focusedControl;
|
|
function isElement(node) {
|
|
return node && node.nodeType === 1;
|
|
}
|
|
try {
|
|
focusedElement = document.activeElement;
|
|
} catch (ex) {
|
|
focusedElement = document.body;
|
|
}
|
|
focusedControl = root.getParentCtrl(focusedElement);
|
|
function getRole(elm) {
|
|
elm = elm || focusedElement;
|
|
if (isElement(elm)) {
|
|
return elm.getAttribute('role');
|
|
}
|
|
return null;
|
|
}
|
|
function getParentRole(elm) {
|
|
var role, parent$$1 = elm || focusedElement;
|
|
while (parent$$1 = parent$$1.parentNode) {
|
|
if (role = getRole(parent$$1)) {
|
|
return role;
|
|
}
|
|
}
|
|
}
|
|
function getAriaProp(name$$1) {
|
|
var elm = focusedElement;
|
|
if (isElement(elm)) {
|
|
return elm.getAttribute('aria-' + name$$1);
|
|
}
|
|
}
|
|
function isTextInputElement(elm) {
|
|
var tagName = elm.tagName.toUpperCase();
|
|
return tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT';
|
|
}
|
|
function canFocus(elm) {
|
|
if (isTextInputElement(elm) && !elm.hidden) {
|
|
return true;
|
|
}
|
|
if (hasTabstopData(elm)) {
|
|
return true;
|
|
}
|
|
if (/^(button|menuitem|checkbox|tab|menuitemcheckbox|option|gridcell|slider)$/.test(getRole(elm))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getFocusElements(elm) {
|
|
var elements = [];
|
|
function collect(elm) {
|
|
if (elm.nodeType !== 1 || elm.style.display === 'none' || elm.disabled) {
|
|
return;
|
|
}
|
|
if (canFocus(elm)) {
|
|
elements.push(elm);
|
|
}
|
|
for (var i = 0; i < elm.childNodes.length; i++) {
|
|
collect(elm.childNodes[i]);
|
|
}
|
|
}
|
|
collect(elm || root.getEl());
|
|
return elements;
|
|
}
|
|
function getNavigationRoot(targetControl) {
|
|
var navigationRoot, controls;
|
|
targetControl = targetControl || focusedControl;
|
|
controls = targetControl.parents().toArray();
|
|
controls.unshift(targetControl);
|
|
for (var i = 0; i < controls.length; i++) {
|
|
navigationRoot = controls[i];
|
|
if (navigationRoot.settings.ariaRoot) {
|
|
break;
|
|
}
|
|
}
|
|
return navigationRoot;
|
|
}
|
|
function focusFirst(targetControl) {
|
|
var navigationRoot = getNavigationRoot(targetControl);
|
|
var focusElements = getFocusElements(navigationRoot.getEl());
|
|
if (navigationRoot.settings.ariaRemember && 'lastAriaIndex' in navigationRoot) {
|
|
moveFocusToIndex(navigationRoot.lastAriaIndex, focusElements);
|
|
} else {
|
|
moveFocusToIndex(0, focusElements);
|
|
}
|
|
}
|
|
function moveFocusToIndex(idx, elements) {
|
|
if (idx < 0) {
|
|
idx = elements.length - 1;
|
|
} else if (idx >= elements.length) {
|
|
idx = 0;
|
|
}
|
|
if (elements[idx]) {
|
|
elements[idx].focus();
|
|
}
|
|
return idx;
|
|
}
|
|
function moveFocus(dir, elements) {
|
|
var idx = -1;
|
|
var navigationRoot = getNavigationRoot();
|
|
elements = elements || getFocusElements(navigationRoot.getEl());
|
|
for (var i = 0; i < elements.length; i++) {
|
|
if (elements[i] === focusedElement) {
|
|
idx = i;
|
|
}
|
|
}
|
|
idx += dir;
|
|
navigationRoot.lastAriaIndex = moveFocusToIndex(idx, elements);
|
|
}
|
|
function left() {
|
|
var parentRole = getParentRole();
|
|
if (parentRole === 'tablist') {
|
|
moveFocus(-1, getFocusElements(focusedElement.parentNode));
|
|
} else if (focusedControl.parent().submenu) {
|
|
cancel();
|
|
} else {
|
|
moveFocus(-1);
|
|
}
|
|
}
|
|
function right() {
|
|
var role = getRole(), parentRole = getParentRole();
|
|
if (parentRole === 'tablist') {
|
|
moveFocus(1, getFocusElements(focusedElement.parentNode));
|
|
} else if (role === 'menuitem' && parentRole === 'menu' && getAriaProp('haspopup')) {
|
|
enter();
|
|
} else {
|
|
moveFocus(1);
|
|
}
|
|
}
|
|
function up() {
|
|
moveFocus(-1);
|
|
}
|
|
function down() {
|
|
var role = getRole(), parentRole = getParentRole();
|
|
if (role === 'menuitem' && parentRole === 'menubar') {
|
|
enter();
|
|
} else if (role === 'button' && getAriaProp('haspopup')) {
|
|
enter({ key: 'down' });
|
|
} else {
|
|
moveFocus(1);
|
|
}
|
|
}
|
|
function tab(e) {
|
|
var parentRole = getParentRole();
|
|
if (parentRole === 'tablist') {
|
|
var elm = getFocusElements(focusedControl.getEl('body'))[0];
|
|
if (elm) {
|
|
elm.focus();
|
|
}
|
|
} else {
|
|
moveFocus(e.shiftKey ? -1 : 1);
|
|
}
|
|
}
|
|
function cancel() {
|
|
focusedControl.fire('cancel');
|
|
}
|
|
function enter(aria) {
|
|
aria = aria || {};
|
|
focusedControl.fire('click', {
|
|
target: focusedElement,
|
|
aria: aria
|
|
});
|
|
}
|
|
root.on('keydown', function (e) {
|
|
function handleNonTabOrEscEvent(e, handler) {
|
|
if (isTextInputElement(focusedElement) || hasTabstopData(focusedElement)) {
|
|
return;
|
|
}
|
|
if (getRole(focusedElement) === 'slider') {
|
|
return;
|
|
}
|
|
if (handler(e) !== false) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
if (e.isDefaultPrevented()) {
|
|
return;
|
|
}
|
|
switch (e.keyCode) {
|
|
case 37:
|
|
handleNonTabOrEscEvent(e, left);
|
|
break;
|
|
case 39:
|
|
handleNonTabOrEscEvent(e, right);
|
|
break;
|
|
case 38:
|
|
handleNonTabOrEscEvent(e, up);
|
|
break;
|
|
case 40:
|
|
handleNonTabOrEscEvent(e, down);
|
|
break;
|
|
case 27:
|
|
cancel();
|
|
break;
|
|
case 14:
|
|
case 13:
|
|
case 32:
|
|
handleNonTabOrEscEvent(e, enter);
|
|
break;
|
|
case 9:
|
|
tab(e);
|
|
e.preventDefault();
|
|
break;
|
|
}
|
|
});
|
|
root.on('focusin', function (e) {
|
|
focusedElement = e.target;
|
|
focusedControl = e.control;
|
|
});
|
|
return { focusFirst: focusFirst };
|
|
}
|
|
|
|
var selectorCache = {};
|
|
var Container = Control$1.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
self._super(settings);
|
|
settings = self.settings;
|
|
if (settings.fixed) {
|
|
self.state.set('fixed', true);
|
|
}
|
|
self._items = new Collection$2();
|
|
if (self.isRtl()) {
|
|
self.classes.add('rtl');
|
|
}
|
|
self.bodyClasses = new ClassList(function () {
|
|
if (self.state.get('rendered')) {
|
|
self.getEl('body').className = this.toString();
|
|
}
|
|
});
|
|
self.bodyClasses.prefix = self.classPrefix;
|
|
self.classes.add('container');
|
|
self.bodyClasses.add('container-body');
|
|
if (settings.containerCls) {
|
|
self.classes.add(settings.containerCls);
|
|
}
|
|
self._layout = global$11.create((settings.layout || '') + 'layout');
|
|
if (self.settings.items) {
|
|
self.add(self.settings.items);
|
|
} else {
|
|
self.add(self.render());
|
|
}
|
|
self._hasBody = true;
|
|
},
|
|
items: function () {
|
|
return this._items;
|
|
},
|
|
find: function (selector) {
|
|
selector = selectorCache[selector] = selectorCache[selector] || new Selector(selector);
|
|
return selector.find(this);
|
|
},
|
|
add: function (items) {
|
|
var self = this;
|
|
self.items().add(self.create(items)).parent(self);
|
|
return self;
|
|
},
|
|
focus: function (keyboard) {
|
|
var self = this;
|
|
var focusCtrl, keyboardNav, items;
|
|
if (keyboard) {
|
|
keyboardNav = self.keyboardNav || self.parents().eq(-1)[0].keyboardNav;
|
|
if (keyboardNav) {
|
|
keyboardNav.focusFirst(self);
|
|
return;
|
|
}
|
|
}
|
|
items = self.find('*');
|
|
if (self.statusbar) {
|
|
items.add(self.statusbar.items());
|
|
}
|
|
items.each(function (ctrl) {
|
|
if (ctrl.settings.autofocus) {
|
|
focusCtrl = null;
|
|
return false;
|
|
}
|
|
if (ctrl.canFocus) {
|
|
focusCtrl = focusCtrl || ctrl;
|
|
}
|
|
});
|
|
if (focusCtrl) {
|
|
focusCtrl.focus();
|
|
}
|
|
return self;
|
|
},
|
|
replace: function (oldItem, newItem) {
|
|
var ctrlElm;
|
|
var items = this.items();
|
|
var i = items.length;
|
|
while (i--) {
|
|
if (items[i] === oldItem) {
|
|
items[i] = newItem;
|
|
break;
|
|
}
|
|
}
|
|
if (i >= 0) {
|
|
ctrlElm = newItem.getEl();
|
|
if (ctrlElm) {
|
|
ctrlElm.parentNode.removeChild(ctrlElm);
|
|
}
|
|
ctrlElm = oldItem.getEl();
|
|
if (ctrlElm) {
|
|
ctrlElm.parentNode.removeChild(ctrlElm);
|
|
}
|
|
}
|
|
newItem.parent(this);
|
|
},
|
|
create: function (items) {
|
|
var self = this;
|
|
var settings;
|
|
var ctrlItems = [];
|
|
if (!global$4.isArray(items)) {
|
|
items = [items];
|
|
}
|
|
global$4.each(items, function (item) {
|
|
if (item) {
|
|
if (!(item instanceof Control$1)) {
|
|
if (typeof item === 'string') {
|
|
item = { type: item };
|
|
}
|
|
settings = global$4.extend({}, self.settings.defaults, item);
|
|
item.type = settings.type = settings.type || item.type || self.settings.defaultType || (settings.defaults ? settings.defaults.type : null);
|
|
item = global$11.create(settings);
|
|
}
|
|
ctrlItems.push(item);
|
|
}
|
|
});
|
|
return ctrlItems;
|
|
},
|
|
renderNew: function () {
|
|
var self = this;
|
|
self.items().each(function (ctrl, index) {
|
|
var containerElm;
|
|
ctrl.parent(self);
|
|
if (!ctrl.state.get('rendered')) {
|
|
containerElm = self.getEl('body');
|
|
if (containerElm.hasChildNodes() && index <= containerElm.childNodes.length - 1) {
|
|
global$7(containerElm.childNodes[index]).before(ctrl.renderHtml());
|
|
} else {
|
|
global$7(containerElm).append(ctrl.renderHtml());
|
|
}
|
|
ctrl.postRender();
|
|
$_cqjgb518wjjgwek2f.add(ctrl);
|
|
}
|
|
});
|
|
self._layout.applyClasses(self.items().filter(':visible'));
|
|
self._lastRect = null;
|
|
return self;
|
|
},
|
|
append: function (items) {
|
|
return this.add(items).renderNew();
|
|
},
|
|
prepend: function (items) {
|
|
var self = this;
|
|
self.items().set(self.create(items).concat(self.items().toArray()));
|
|
return self.renderNew();
|
|
},
|
|
insert: function (items, index, before) {
|
|
var self = this;
|
|
var curItems, beforeItems, afterItems;
|
|
items = self.create(items);
|
|
curItems = self.items();
|
|
if (!before && index < curItems.length - 1) {
|
|
index += 1;
|
|
}
|
|
if (index >= 0 && index < curItems.length) {
|
|
beforeItems = curItems.slice(0, index).toArray();
|
|
afterItems = curItems.slice(index).toArray();
|
|
curItems.set(beforeItems.concat(items, afterItems));
|
|
}
|
|
return self.renderNew();
|
|
},
|
|
fromJSON: function (data) {
|
|
var self = this;
|
|
for (var name in data) {
|
|
self.find('#' + name).value(data[name]);
|
|
}
|
|
return self;
|
|
},
|
|
toJSON: function () {
|
|
var self = this, data = {};
|
|
self.find('*').each(function (ctrl) {
|
|
var name = ctrl.name(), value = ctrl.value();
|
|
if (name && typeof value !== 'undefined') {
|
|
data[name] = value;
|
|
}
|
|
});
|
|
return data;
|
|
},
|
|
renderHtml: function () {
|
|
var self = this, layout = self._layout, role = this.settings.role;
|
|
self.preRender();
|
|
layout.preRender(self);
|
|
return '<div id="' + self._id + '" class="' + self.classes + '"' + (role ? ' role="' + this.settings.role + '"' : '') + '>' + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
var box;
|
|
self.items().exec('postRender');
|
|
self._super();
|
|
self._layout.postRender(self);
|
|
self.state.set('rendered', true);
|
|
if (self.settings.style) {
|
|
self.$el.css(self.settings.style);
|
|
}
|
|
if (self.settings.border) {
|
|
box = self.borderBox;
|
|
self.$el.css({
|
|
'border-top-width': box.top,
|
|
'border-right-width': box.right,
|
|
'border-bottom-width': box.bottom,
|
|
'border-left-width': box.left
|
|
});
|
|
}
|
|
if (!self.parent()) {
|
|
self.keyboardNav = KeyboardNavigation({ root: self });
|
|
}
|
|
return self;
|
|
},
|
|
initLayoutRect: function () {
|
|
var self = this, layoutRect = self._super();
|
|
self._layout.recalc(self);
|
|
return layoutRect;
|
|
},
|
|
recalc: function () {
|
|
var self = this;
|
|
var rect = self._layoutRect;
|
|
var lastRect = self._lastRect;
|
|
if (!lastRect || lastRect.w !== rect.w || lastRect.h !== rect.h) {
|
|
self._layout.recalc(self);
|
|
rect = self.layoutRect();
|
|
self._lastRect = {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
w: rect.w,
|
|
h: rect.h
|
|
};
|
|
return true;
|
|
}
|
|
},
|
|
reflow: function () {
|
|
var i;
|
|
$_cqjgb518wjjgwek2f.remove(this);
|
|
if (this.visible()) {
|
|
Control$1.repaintControls = [];
|
|
Control$1.repaintControls.map = {};
|
|
this.recalc();
|
|
i = Control$1.repaintControls.length;
|
|
while (i--) {
|
|
Control$1.repaintControls[i].repaint();
|
|
}
|
|
if (this.settings.layout !== 'flow' && this.settings.layout !== 'stack') {
|
|
this.repaint();
|
|
}
|
|
Control$1.repaintControls = [];
|
|
}
|
|
return this;
|
|
}
|
|
});
|
|
|
|
var $_8woeth19ajjgwek4b = {
|
|
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();
|
|
global$7(self.getEl('absend')).css(posNameLower, self.layoutRect()[contentSizeName] - 1);
|
|
if (!hasScroll) {
|
|
global$7(scrollBarElm).css('display', 'none');
|
|
return;
|
|
}
|
|
global$7(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;
|
|
global$7(scrollBarElm).css(rect);
|
|
rect = {};
|
|
rect[posNameLower] = containerElm['scroll' + posName] * ratio;
|
|
rect[sizeNameLower] = containerSize * ratio;
|
|
global$7(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;
|
|
var axisId = self._id + '-scroll' + axisName, prefix = self.classPrefix;
|
|
global$7(self.getEl()).append('<div id="' + axisId + '" class="' + prefix + 'scrollbar ' + prefix + 'scrollbar-' + axisName + '">' + '<div id="' + axisId + 't" class="' + prefix + 'scrollbar-thumb"></div>' + '</div>');
|
|
self.draghelper = new DragHelper(axisId + 't', {
|
|
start: function () {
|
|
scrollStart = self.getEl('body')['scroll' + posName];
|
|
global$7('#' + axisId).addClass(prefix + 'active');
|
|
},
|
|
drag: function (e) {
|
|
var ratio, hasScrollH, hasScrollV, containerSize;
|
|
var 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 () {
|
|
global$7('#' + 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();
|
|
});
|
|
global$7(self.getEl('body')).on('scroll', repaintScroll);
|
|
}
|
|
repaintScroll();
|
|
}
|
|
}
|
|
};
|
|
|
|
var Panel = Container.extend({
|
|
Defaults: {
|
|
layout: 'fit',
|
|
containerCls: 'panel'
|
|
},
|
|
Mixins: [$_8woeth19ajjgwek4b],
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var layout = self._layout;
|
|
var innerHtml = self.settings.html;
|
|
self.preRender();
|
|
layout.preRender(self);
|
|
if (typeof innerHtml === 'undefined') {
|
|
innerHtml = '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>';
|
|
} else {
|
|
if (typeof innerHtml === 'function') {
|
|
innerHtml = innerHtml.call(self);
|
|
}
|
|
self._hasBody = false;
|
|
}
|
|
return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1" role="group">' + (self._preBodyHtml || '') + innerHtml + '</div>';
|
|
}
|
|
});
|
|
|
|
var $_20hy1119bjjgwek4f = {
|
|
resizeToContent: function () {
|
|
this._layoutRect.autoResize = true;
|
|
this._lastRect = null;
|
|
this.reflow();
|
|
},
|
|
resizeTo: function (w, h) {
|
|
if (w <= 1 || h <= 1) {
|
|
var rect = funcs.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();
|
|
},
|
|
resizeBy: function (dw, dh) {
|
|
var self = this, rect = self.layoutRect();
|
|
return self.resizeTo(rect.w + dw, rect.h + dh);
|
|
}
|
|
};
|
|
|
|
var documentClickHandler;
|
|
var documentScrollHandler;
|
|
var windowResizeHandler;
|
|
var visiblePanels = [];
|
|
var zOrder = [];
|
|
var hasModal;
|
|
function isChildOf(ctrl, parent$$1) {
|
|
while (ctrl) {
|
|
if (ctrl === parent$$1) {
|
|
return true;
|
|
}
|
|
ctrl = ctrl.parent();
|
|
}
|
|
}
|
|
function skipOrHidePanels(e) {
|
|
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) {
|
|
if (e.button === 2) {
|
|
return;
|
|
}
|
|
skipOrHidePanels(e);
|
|
};
|
|
global$7(document).on('click touchstart', documentClickHandler);
|
|
}
|
|
}
|
|
function bindDocumentScrollHandler() {
|
|
if (!documentScrollHandler) {
|
|
documentScrollHandler = function () {
|
|
var i;
|
|
i = visiblePanels.length;
|
|
while (i--) {
|
|
repositionPanel$1(visiblePanels[i]);
|
|
}
|
|
};
|
|
global$7(window).on('scroll', documentScrollHandler);
|
|
}
|
|
}
|
|
function bindWindowResizeHandler() {
|
|
if (!windowResizeHandler) {
|
|
var docElm_1 = document.documentElement;
|
|
var clientWidth_1 = docElm_1.clientWidth, clientHeight_1 = docElm_1.clientHeight;
|
|
windowResizeHandler = function () {
|
|
if (!document.all || clientWidth_1 !== docElm_1.clientWidth || clientHeight_1 !== docElm_1.clientHeight) {
|
|
clientWidth_1 = docElm_1.clientWidth;
|
|
clientHeight_1 = docElm_1.clientHeight;
|
|
FloatPanel.hideAll();
|
|
}
|
|
};
|
|
global$7(window).on('resize', windowResizeHandler);
|
|
}
|
|
}
|
|
function repositionPanel$1(panel) {
|
|
var scrollY$$1 = funcs.getViewPort().y;
|
|
function toggleFixedChildPanels(fixed, deltaY) {
|
|
var parent$$1;
|
|
for (var i = 0; i < visiblePanels.length; i++) {
|
|
if (visiblePanels[i] !== panel) {
|
|
parent$$1 = visiblePanels[i].parent();
|
|
while (parent$$1 && (parent$$1 = parent$$1.parent())) {
|
|
if (parent$$1 === 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$$1) {
|
|
panel.fixed(true).layoutRect({ y: 0 }).repaint();
|
|
toggleFixedChildPanels(true, scrollY$$1 - panel._autoFixY);
|
|
}
|
|
} else {
|
|
if (panel._autoFixY > scrollY$$1) {
|
|
panel.fixed(false).layoutRect({ y: panel._autoFixY }).repaint();
|
|
toggleFixedChildPanels(false, panel._autoFixY - scrollY$$1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function addRemove(add, ctrl) {
|
|
var i, zIndex = FloatPanel.zIndex || 65535, 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 = global$7('#' + ctrl.classPrefix + 'modal-block', ctrl.getContainerElm())[0];
|
|
if (topModal) {
|
|
global$7(modalBlockEl).css('z-index', topModal.zIndex - 1);
|
|
} else if (modalBlockEl) {
|
|
modalBlockEl.parentNode.removeChild(modalBlockEl);
|
|
hasModal = false;
|
|
}
|
|
FloatPanel.currentZIndex = zIndex;
|
|
}
|
|
var FloatPanel = Panel.extend({
|
|
Mixins: [
|
|
$_8zu82i18yjjgwek2l,
|
|
$_20hy1119bjjgwek4f
|
|
],
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
self$$1._super(settings);
|
|
self$$1._eventsRoot = self$$1;
|
|
self$$1.classes.add('floatpanel');
|
|
if (settings.autohide) {
|
|
bindDocumentClickHandler();
|
|
bindWindowResizeHandler();
|
|
visiblePanels.push(self$$1);
|
|
}
|
|
if (settings.autofix) {
|
|
bindDocumentScrollHandler();
|
|
self$$1.on('move', function () {
|
|
repositionPanel$1(this);
|
|
});
|
|
}
|
|
self$$1.on('postrender show', function (e) {
|
|
if (e.control === self$$1) {
|
|
var $modalBlockEl_1;
|
|
var prefix_1 = self$$1.classPrefix;
|
|
if (self$$1.modal && !hasModal) {
|
|
$modalBlockEl_1 = global$7('#' + prefix_1 + 'modal-block', self$$1.getContainerElm());
|
|
if (!$modalBlockEl_1[0]) {
|
|
$modalBlockEl_1 = global$7('<div id="' + prefix_1 + 'modal-block" class="' + prefix_1 + 'reset ' + prefix_1 + 'fade"></div>').appendTo(self$$1.getContainerElm());
|
|
}
|
|
global$3.setTimeout(function () {
|
|
$modalBlockEl_1.addClass(prefix_1 + 'in');
|
|
global$7(self$$1.getEl()).addClass(prefix_1 + 'in');
|
|
});
|
|
hasModal = true;
|
|
}
|
|
addRemove(true, self$$1);
|
|
}
|
|
});
|
|
self$$1.on('show', function () {
|
|
self$$1.parents().each(function (ctrl) {
|
|
if (ctrl.state.get('fixed')) {
|
|
self$$1.fixed(true);
|
|
return false;
|
|
}
|
|
});
|
|
});
|
|
if (settings.popover) {
|
|
self$$1._preBodyHtml = '<div class="' + self$$1.classPrefix + 'arrow"></div>';
|
|
self$$1.classes.add('popover').add('bottom').add(self$$1.isRtl() ? 'end' : 'start');
|
|
}
|
|
self$$1.aria('label', settings.ariaLabel);
|
|
self$$1.aria('labelledby', self$$1._id);
|
|
self$$1.aria('describedby', self$$1.describedBy || self$$1._id + '-none');
|
|
},
|
|
fixed: function (state) {
|
|
var self$$1 = this;
|
|
if (self$$1.state.get('fixed') !== state) {
|
|
if (self$$1.state.get('rendered')) {
|
|
var viewport = funcs.getViewPort();
|
|
if (state) {
|
|
self$$1.layoutRect().y -= viewport.y;
|
|
} else {
|
|
self$$1.layoutRect().y += viewport.y;
|
|
}
|
|
}
|
|
self$$1.classes.toggle('fixed', state);
|
|
self$$1.state.set('fixed', state);
|
|
}
|
|
return self$$1;
|
|
},
|
|
show: function () {
|
|
var self$$1 = this;
|
|
var i;
|
|
var state = self$$1._super();
|
|
i = visiblePanels.length;
|
|
while (i--) {
|
|
if (visiblePanels[i] === self$$1) {
|
|
break;
|
|
}
|
|
}
|
|
if (i === -1) {
|
|
visiblePanels.push(self$$1);
|
|
}
|
|
return state;
|
|
},
|
|
hide: function () {
|
|
removeVisiblePanel(this);
|
|
addRemove(false, this);
|
|
return this._super();
|
|
},
|
|
hideAll: function () {
|
|
FloatPanel.hideAll();
|
|
},
|
|
close: function () {
|
|
var self$$1 = this;
|
|
if (!self$$1.fire('close').isDefaultPrevented()) {
|
|
self$$1.remove();
|
|
addRemove(false, self$$1);
|
|
}
|
|
return self$$1;
|
|
},
|
|
remove: function () {
|
|
removeVisiblePanel(this);
|
|
this._super();
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this;
|
|
if (self$$1.settings.bodyRole) {
|
|
this.getEl('body').setAttribute('role', self$$1.settings.bodyRole);
|
|
}
|
|
return self$$1._super();
|
|
}
|
|
});
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
var windows = [];
|
|
var oldMetaValue = '';
|
|
function toggleFullScreenState(state) {
|
|
var noScaleMetaValue = 'width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0';
|
|
var viewport = global$7('meta[name=viewport]')[0], contentValue;
|
|
if (global$1.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, state) {
|
|
if (checkFullscreenWindows() && state === false) {
|
|
global$7([
|
|
document.documentElement,
|
|
document.body
|
|
]).removeClass(classPrefix + 'fullscreen');
|
|
}
|
|
}
|
|
function checkFullscreenWindows() {
|
|
for (var i = 0; i < windows.length; i++) {
|
|
if (windows[i]._fullscreen) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function handleWindowResize() {
|
|
if (!global$1.desktop) {
|
|
var lastSize_1 = {
|
|
w: window.innerWidth,
|
|
h: window.innerHeight
|
|
};
|
|
global$3.setInterval(function () {
|
|
var w = window.innerWidth, h = window.innerHeight;
|
|
if (lastSize_1.w !== w || lastSize_1.h !== h) {
|
|
lastSize_1 = {
|
|
w: w,
|
|
h: h
|
|
};
|
|
global$7(window).trigger('resize');
|
|
}
|
|
}, 100);
|
|
}
|
|
function reposition() {
|
|
var i;
|
|
var rect = funcs.getWindowSize();
|
|
var 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));
|
|
}
|
|
}
|
|
global$7(window).on('resize', reposition);
|
|
}
|
|
var Window$$1 = 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();
|
|
}
|
|
}
|
|
},
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
self$$1._super(settings);
|
|
if (self$$1.isRtl()) {
|
|
self$$1.classes.add('rtl');
|
|
}
|
|
self$$1.classes.add('window');
|
|
self$$1.bodyClasses.add('window-body');
|
|
self$$1.state.set('fixed', true);
|
|
if (settings.buttons) {
|
|
self$$1.statusbar = new Panel({
|
|
layout: 'flex',
|
|
border: '1 0 0 0',
|
|
spacing: 3,
|
|
padding: 10,
|
|
align: 'center',
|
|
pack: self$$1.isRtl() ? 'start' : 'end',
|
|
defaults: { type: 'button' },
|
|
items: settings.buttons
|
|
});
|
|
self$$1.statusbar.classes.add('foot');
|
|
self$$1.statusbar.parent(self$$1);
|
|
}
|
|
self$$1.on('click', function (e) {
|
|
var closeClass = self$$1.classPrefix + 'close';
|
|
if (funcs.hasClass(e.target, closeClass) || funcs.hasClass(e.target.parentNode, closeClass)) {
|
|
self$$1.close();
|
|
}
|
|
});
|
|
self$$1.on('cancel', function () {
|
|
self$$1.close();
|
|
});
|
|
self$$1.on('move', function (e) {
|
|
if (e.control === self$$1) {
|
|
FloatPanel.hideAll();
|
|
}
|
|
});
|
|
self$$1.aria('describedby', self$$1.describedBy || self$$1._id + '-none');
|
|
self$$1.aria('label', settings.title);
|
|
self$$1._fullscreen = false;
|
|
},
|
|
recalc: function () {
|
|
var self$$1 = this;
|
|
var statusbar$$1 = self$$1.statusbar;
|
|
var layoutRect, width, x, needsRecalc;
|
|
if (self$$1._fullscreen) {
|
|
self$$1.layoutRect(funcs.getWindowSize());
|
|
self$$1.layoutRect().contentH = self$$1.layoutRect().innerH;
|
|
}
|
|
self$$1._super();
|
|
layoutRect = self$$1.layoutRect();
|
|
if (self$$1.settings.title && !self$$1._fullscreen) {
|
|
width = layoutRect.headerW;
|
|
if (width > layoutRect.w) {
|
|
x = layoutRect.x - Math.max(0, width / 2);
|
|
self$$1.layoutRect({
|
|
w: width,
|
|
x: x
|
|
});
|
|
needsRecalc = true;
|
|
}
|
|
}
|
|
if (statusbar$$1) {
|
|
statusbar$$1.layoutRect({ w: self$$1.layoutRect().innerW }).recalc();
|
|
width = statusbar$$1.layoutRect().minW + layoutRect.deltaW;
|
|
if (width > layoutRect.w) {
|
|
x = layoutRect.x - Math.max(0, width - layoutRect.w);
|
|
self$$1.layoutRect({
|
|
w: width,
|
|
x: x
|
|
});
|
|
needsRecalc = true;
|
|
}
|
|
}
|
|
if (needsRecalc) {
|
|
self$$1.recalc();
|
|
}
|
|
},
|
|
initLayoutRect: function () {
|
|
var self$$1 = this;
|
|
var layoutRect = self$$1._super();
|
|
var deltaH = 0, headEl;
|
|
if (self$$1.settings.title && !self$$1._fullscreen) {
|
|
headEl = self$$1.getEl('head');
|
|
var size = funcs.getSize(headEl);
|
|
layoutRect.headerW = size.width;
|
|
layoutRect.headerH = size.height;
|
|
deltaH += layoutRect.headerH;
|
|
}
|
|
if (self$$1.statusbar) {
|
|
deltaH += self$$1.statusbar.layoutRect().h;
|
|
}
|
|
layoutRect.deltaH += deltaH;
|
|
layoutRect.minH += deltaH;
|
|
layoutRect.h += deltaH;
|
|
var rect = funcs.getWindowSize();
|
|
layoutRect.x = self$$1.settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2);
|
|
layoutRect.y = self$$1.settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2);
|
|
return layoutRect;
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this, layout = self$$1._layout, id = self$$1._id, prefix = self$$1.classPrefix;
|
|
var settings = self$$1.settings;
|
|
var headerHtml = '', footerHtml = '', html = settings.html;
|
|
self$$1.preRender();
|
|
layout.preRender(self$$1);
|
|
if (settings.title) {
|
|
headerHtml = '<div id="' + id + '-head" class="' + prefix + 'window-head">' + '<div id="' + id + '-title" class="' + prefix + 'title">' + self$$1.encode(settings.title) + '</div>' + '<div id="' + id + '-dragh" class="' + prefix + 'dragh"></div>' + '<button type="button" class="' + prefix + 'close" aria-hidden="true">' + '<i class="mce-ico mce-i-remove"></i>' + '</button>' + '</div>';
|
|
}
|
|
if (settings.url) {
|
|
html = '<iframe src="' + settings.url + '" tabindex="-1"></iframe>';
|
|
}
|
|
if (typeof html === 'undefined') {
|
|
html = layout.renderHtml(self$$1);
|
|
}
|
|
if (self$$1.statusbar) {
|
|
footerHtml = self$$1.statusbar.renderHtml();
|
|
}
|
|
return '<div id="' + id + '" class="' + self$$1.classes + '" hidefocus="1">' + '<div class="' + self$$1.classPrefix + 'reset" role="application">' + headerHtml + '<div id="' + id + '-body" class="' + self$$1.bodyClasses + '">' + html + '</div>' + footerHtml + '</div>' + '</div>';
|
|
},
|
|
fullscreen: function (state) {
|
|
var self$$1 = this;
|
|
var documentElement = document.documentElement;
|
|
var slowRendering;
|
|
var prefix = self$$1.classPrefix;
|
|
var layoutRect;
|
|
if (state !== self$$1._fullscreen) {
|
|
global$7(window).on('resize', function () {
|
|
var time;
|
|
if (self$$1._fullscreen) {
|
|
if (!slowRendering) {
|
|
time = new Date().getTime();
|
|
var rect = funcs.getWindowSize();
|
|
self$$1.moveTo(0, 0).resizeTo(rect.w, rect.h);
|
|
if (new Date().getTime() - time > 50) {
|
|
slowRendering = true;
|
|
}
|
|
} else {
|
|
if (!self$$1._timer) {
|
|
self$$1._timer = global$3.setTimeout(function () {
|
|
var rect = funcs.getWindowSize();
|
|
self$$1.moveTo(0, 0).resizeTo(rect.w, rect.h);
|
|
self$$1._timer = 0;
|
|
}, 50);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
layoutRect = self$$1.layoutRect();
|
|
self$$1._fullscreen = state;
|
|
if (!state) {
|
|
self$$1.borderBox = $_4kbuyt18pjjgwek1w.parseBox(self$$1.settings.border);
|
|
self$$1.getEl('head').style.display = '';
|
|
layoutRect.deltaH += layoutRect.headerH;
|
|
global$7([
|
|
documentElement,
|
|
document.body
|
|
]).removeClass(prefix + 'fullscreen');
|
|
self$$1.classes.remove('fullscreen');
|
|
self$$1.moveTo(self$$1._initial.x, self$$1._initial.y).resizeTo(self$$1._initial.w, self$$1._initial.h);
|
|
} else {
|
|
self$$1._initial = {
|
|
x: layoutRect.x,
|
|
y: layoutRect.y,
|
|
w: layoutRect.w,
|
|
h: layoutRect.h
|
|
};
|
|
self$$1.borderBox = $_4kbuyt18pjjgwek1w.parseBox('0');
|
|
self$$1.getEl('head').style.display = 'none';
|
|
layoutRect.deltaH -= layoutRect.headerH + 2;
|
|
global$7([
|
|
documentElement,
|
|
document.body
|
|
]).addClass(prefix + 'fullscreen');
|
|
self$$1.classes.add('fullscreen');
|
|
var rect = funcs.getWindowSize();
|
|
self$$1.moveTo(0, 0).resizeTo(rect.w, rect.h);
|
|
}
|
|
}
|
|
return self$$1.reflow();
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this;
|
|
var startPos;
|
|
setTimeout(function () {
|
|
self$$1.classes.add('in');
|
|
self$$1.fire('open');
|
|
}, 0);
|
|
self$$1._super();
|
|
if (self$$1.statusbar) {
|
|
self$$1.statusbar.postRender();
|
|
}
|
|
self$$1.focus();
|
|
this.dragHelper = new DragHelper(self$$1._id + '-dragh', {
|
|
start: function () {
|
|
startPos = {
|
|
x: self$$1.layoutRect().x,
|
|
y: self$$1.layoutRect().y
|
|
};
|
|
},
|
|
drag: function (e) {
|
|
self$$1.moveTo(startPos.x + e.deltaX, startPos.y + e.deltaY);
|
|
}
|
|
});
|
|
self$$1.on('submit', function (e) {
|
|
if (!e.isDefaultPrevented()) {
|
|
self$$1.close();
|
|
}
|
|
});
|
|
windows.push(self$$1);
|
|
toggleFullScreenState(true);
|
|
},
|
|
submit: function () {
|
|
return this.fire('submit', { data: this.toJSON() });
|
|
},
|
|
remove: function () {
|
|
var self$$1 = this;
|
|
var i;
|
|
self$$1.dragHelper.destroy();
|
|
self$$1._super();
|
|
if (self$$1.statusbar) {
|
|
this.statusbar.remove();
|
|
}
|
|
toggleBodyFullScreenClasses(self$$1.classPrefix, false);
|
|
i = windows.length;
|
|
while (i--) {
|
|
if (windows[i] === self$$1) {
|
|
windows.splice(i, 1);
|
|
}
|
|
}
|
|
toggleFullScreenState(windows.length > 0);
|
|
},
|
|
getContentWindow: function () {
|
|
var ifr = this.getEl().getElementsByTagName('iframe')[0];
|
|
return ifr ? ifr.contentWindow : null;
|
|
}
|
|
});
|
|
handleWindowResize();
|
|
|
|
var MessageBox = Window$$1.extend({
|
|
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: 1,
|
|
OK_CANCEL: 2,
|
|
YES_NO: 3,
|
|
YES_NO_CANCEL: 4,
|
|
msgBox: function (settings) {
|
|
var buttons;
|
|
var callback = settings.callback || function () {
|
|
};
|
|
function createButton(text, status$$1, primary) {
|
|
return {
|
|
type: 'button',
|
|
text: text,
|
|
subtype: primary ? 'primary' : '',
|
|
onClick: function (e) {
|
|
e.control.parents()[1].close();
|
|
callback(status$$1);
|
|
}
|
|
};
|
|
}
|
|
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$$1({
|
|
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();
|
|
},
|
|
alert: function (settings, callback) {
|
|
if (typeof settings === 'string') {
|
|
settings = { text: settings };
|
|
}
|
|
settings.callback = callback;
|
|
return MessageBox.msgBox(settings);
|
|
},
|
|
confirm: function (settings, callback) {
|
|
if (typeof settings === 'string') {
|
|
settings = { text: settings };
|
|
}
|
|
settings.callback = callback;
|
|
settings.buttons = MessageBox.OK_CANCEL;
|
|
return MessageBox.msgBox(settings);
|
|
}
|
|
}
|
|
});
|
|
|
|
function WindowManagerImpl (editor) {
|
|
var open$$1 = function (args, params, closeCallback) {
|
|
var win;
|
|
args.title = args.title || ' ';
|
|
args.url = args.url || args.file;
|
|
if (args.url) {
|
|
args.width = parseInt(args.width || 320, 10);
|
|
args.height = parseInt(args.height || 240, 10);
|
|
}
|
|
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$$1(args);
|
|
win.on('close', function () {
|
|
closeCallback(win);
|
|
});
|
|
if (args.data) {
|
|
win.on('postRender', function () {
|
|
this.find('*').each(function (ctrl) {
|
|
var name$$1 = ctrl.name();
|
|
if (name$$1 in args.data) {
|
|
ctrl.value(args.data[name$$1]);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
win.features = args || {};
|
|
win.params = params || {};
|
|
win = win.renderTo(document.body).reflow();
|
|
return win;
|
|
};
|
|
var alert$$1 = function (message, choiceCallback, closeCallback) {
|
|
var win;
|
|
win = MessageBox.alert(message, function () {
|
|
choiceCallback();
|
|
});
|
|
win.on('close', function () {
|
|
closeCallback(win);
|
|
});
|
|
return win;
|
|
};
|
|
var confirm$$1 = function (message, choiceCallback, closeCallback) {
|
|
var win;
|
|
win = MessageBox.confirm(message, function (state) {
|
|
choiceCallback(state);
|
|
});
|
|
win.on('close', function () {
|
|
closeCallback(win);
|
|
});
|
|
return win;
|
|
};
|
|
var close$$1 = function (window$$1) {
|
|
window$$1.close();
|
|
};
|
|
var getParams = function (window$$1) {
|
|
return window$$1.params;
|
|
};
|
|
var setParams = function (window$$1, params) {
|
|
window$$1.params = params;
|
|
};
|
|
return {
|
|
open: open$$1,
|
|
alert: alert$$1,
|
|
confirm: confirm$$1,
|
|
close: close$$1,
|
|
getParams: getParams,
|
|
setParams: setParams
|
|
};
|
|
}
|
|
|
|
var get = function (editor, panel) {
|
|
var renderUI = function () {
|
|
return $_b0wxh217tjjgwejyx.renderUI(editor, panel);
|
|
};
|
|
return {
|
|
renderUI: renderUI,
|
|
getNotificationManagerImpl: function () {
|
|
return NotificationManagerImpl(editor);
|
|
},
|
|
getWindowManagerImpl: function () {
|
|
return WindowManagerImpl(editor);
|
|
}
|
|
};
|
|
};
|
|
var $_7y4x3k17sjjgwejyw = { get: get };
|
|
|
|
var Global = typeof window !== 'undefined' ? window : Function('return this;')();
|
|
|
|
var path = function (parts, scope) {
|
|
var o = scope !== undefined && scope !== null ? scope : Global;
|
|
for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i)
|
|
o = o[parts[i]];
|
|
return o;
|
|
};
|
|
var resolve = function (p, scope) {
|
|
var parts = p.split('.');
|
|
return path(parts, scope);
|
|
};
|
|
|
|
var unsafe = function (name, scope) {
|
|
return resolve(name, scope);
|
|
};
|
|
var getOrDie = function (name, scope) {
|
|
var actual = unsafe(name, scope);
|
|
if (actual === undefined || actual === null)
|
|
throw name + ' not available on this browser';
|
|
return actual;
|
|
};
|
|
var $_8wnjhx19gjjgwek54 = { getOrDie: getOrDie };
|
|
|
|
function FileReader () {
|
|
var f = $_8wnjhx19gjjgwek54.getOrDie('FileReader');
|
|
return new f();
|
|
}
|
|
|
|
var global$12 = tinymce.util.Tools.resolve('tinymce.util.Promise');
|
|
|
|
var blobToBase64 = function (blob) {
|
|
return new global$12(function (resolve) {
|
|
var reader = new FileReader();
|
|
reader.onloadend = function () {
|
|
resolve(reader.result.split(',')[1]);
|
|
};
|
|
reader.readAsDataURL(blob);
|
|
});
|
|
};
|
|
var $_c292419ejjgwek4z = { blobToBase64: blobToBase64 };
|
|
|
|
var pickFile = function () {
|
|
return new global$12(function (resolve) {
|
|
var fileInput;
|
|
fileInput = document.createElement('input');
|
|
fileInput.type = 'file';
|
|
fileInput.style.position = 'fixed';
|
|
fileInput.style.left = 0;
|
|
fileInput.style.top = 0;
|
|
fileInput.style.opacity = 0.001;
|
|
document.body.appendChild(fileInput);
|
|
fileInput.onchange = function (e) {
|
|
resolve(Array.prototype.slice.call(e.target.files));
|
|
};
|
|
fileInput.click();
|
|
fileInput.parentNode.removeChild(fileInput);
|
|
});
|
|
};
|
|
var $_edjfwb19kjjgwek5a = { pickFile: pickFile };
|
|
|
|
var count$1 = 0;
|
|
var seed = function () {
|
|
var rnd = function () {
|
|
return Math.round(Math.random() * 4294967295).toString(36);
|
|
};
|
|
return 's' + Date.now().toString(36) + rnd() + rnd() + rnd();
|
|
};
|
|
var uuid = function (prefix) {
|
|
return prefix + count$1++ + seed();
|
|
};
|
|
var $_49gxzf19mjjgwek5f = { uuid: uuid };
|
|
|
|
var create$1 = function (dom, rng) {
|
|
var bookmark = {};
|
|
function setupEndPoint(start) {
|
|
var offsetNode, container, offset;
|
|
container = rng[start ? 'startContainer' : 'endContainer'];
|
|
offset = rng[start ? 'startOffset' : 'endOffset'];
|
|
if (container.nodeType === 1) {
|
|
offsetNode = dom.create('span', { 'data-mce-type': 'bookmark' });
|
|
if (container.hasChildNodes()) {
|
|
offset = Math.min(offset, container.childNodes.length - 1);
|
|
if (start) {
|
|
container.insertBefore(offsetNode, container.childNodes[offset]);
|
|
} else {
|
|
dom.insertAfter(offsetNode, container.childNodes[offset]);
|
|
}
|
|
} else {
|
|
container.appendChild(offsetNode);
|
|
}
|
|
container = offsetNode;
|
|
offset = 0;
|
|
}
|
|
bookmark[start ? 'startContainer' : 'endContainer'] = container;
|
|
bookmark[start ? 'startOffset' : 'endOffset'] = offset;
|
|
}
|
|
setupEndPoint(true);
|
|
if (!rng.collapsed) {
|
|
setupEndPoint();
|
|
}
|
|
return bookmark;
|
|
};
|
|
var resolve$1 = function (dom, bookmark) {
|
|
function restoreEndPoint(start) {
|
|
var container, offset, node;
|
|
function nodeIndex(container) {
|
|
var node = container.parentNode.firstChild, idx = 0;
|
|
while (node) {
|
|
if (node === container) {
|
|
return idx;
|
|
}
|
|
if (node.nodeType !== 1 || node.getAttribute('data-mce-type') !== 'bookmark') {
|
|
idx++;
|
|
}
|
|
node = node.nextSibling;
|
|
}
|
|
return -1;
|
|
}
|
|
container = node = bookmark[start ? 'startContainer' : 'endContainer'];
|
|
offset = bookmark[start ? 'startOffset' : 'endOffset'];
|
|
if (!container) {
|
|
return;
|
|
}
|
|
if (container.nodeType === 1) {
|
|
offset = nodeIndex(container);
|
|
container = container.parentNode;
|
|
dom.remove(node);
|
|
}
|
|
bookmark[start ? 'startContainer' : 'endContainer'] = container;
|
|
bookmark[start ? 'startOffset' : 'endOffset'] = offset;
|
|
}
|
|
restoreEndPoint(true);
|
|
restoreEndPoint();
|
|
var rng = dom.createRng();
|
|
rng.setStart(bookmark.startContainer, bookmark.startOffset);
|
|
if (bookmark.endContainer) {
|
|
rng.setEnd(bookmark.endContainer, bookmark.endOffset);
|
|
}
|
|
return rng;
|
|
};
|
|
var $_3b24e19ojjgwek5i = {
|
|
create: create$1,
|
|
resolve: resolve$1
|
|
};
|
|
|
|
var global$13 = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');
|
|
|
|
var global$14 = tinymce.util.Tools.resolve('tinymce.dom.RangeUtils');
|
|
|
|
var getSelectedElements = function (rootElm, startNode, endNode) {
|
|
var walker, node;
|
|
var elms = [];
|
|
walker = new global$13(startNode, rootElm);
|
|
for (node = startNode; node; node = walker.next()) {
|
|
if (node.nodeType === 1) {
|
|
elms.push(node);
|
|
}
|
|
if (node === endNode) {
|
|
break;
|
|
}
|
|
}
|
|
return elms;
|
|
};
|
|
var unwrapElements = function (editor, elms) {
|
|
var bookmark, dom, selection;
|
|
dom = editor.dom;
|
|
selection = editor.selection;
|
|
bookmark = $_3b24e19ojjgwek5i.create(dom, selection.getRng());
|
|
global$4.each(elms, function (elm) {
|
|
editor.dom.remove(elm, true);
|
|
});
|
|
selection.setRng($_3b24e19ojjgwek5i.resolve(dom, bookmark));
|
|
};
|
|
var isLink = function (elm) {
|
|
return elm.nodeName === 'A' && elm.hasAttribute('href');
|
|
};
|
|
var getParentAnchorOrSelf = function (dom, elm) {
|
|
var anchorElm = dom.getParent(elm, isLink);
|
|
return anchorElm ? anchorElm : elm;
|
|
};
|
|
var getSelectedAnchors = function (editor) {
|
|
var startElm, endElm, rootElm, anchorElms, selection, dom, rng;
|
|
selection = editor.selection;
|
|
dom = editor.dom;
|
|
rng = selection.getRng();
|
|
startElm = getParentAnchorOrSelf(dom, global$14.getNode(rng.startContainer, rng.startOffset));
|
|
endElm = global$14.getNode(rng.endContainer, rng.endOffset);
|
|
rootElm = editor.getBody();
|
|
anchorElms = global$4.grep(getSelectedElements(rootElm, startElm, endElm), isLink);
|
|
return anchorElms;
|
|
};
|
|
var unlinkSelection = function (editor) {
|
|
unwrapElements(editor, getSelectedAnchors(editor));
|
|
};
|
|
var $_aunbnv19njjgwek5g = { unlinkSelection: unlinkSelection };
|
|
|
|
var createTableHtml = function (cols, rows) {
|
|
var x, y, html;
|
|
html = '<table data-mce-id="mce" style="width: 100%">';
|
|
html += '<tbody>';
|
|
for (y = 0; y < rows; y++) {
|
|
html += '<tr>';
|
|
for (x = 0; x < cols; x++) {
|
|
html += '<td><br></td>';
|
|
}
|
|
html += '</tr>';
|
|
}
|
|
html += '</tbody>';
|
|
html += '</table>';
|
|
return html;
|
|
};
|
|
var getInsertedElement = function (editor) {
|
|
var elms = editor.dom.select('*[data-mce-id]');
|
|
return elms[0];
|
|
};
|
|
var insertTableHtml = function (editor, cols, rows) {
|
|
editor.undoManager.transact(function () {
|
|
var tableElm, cellElm;
|
|
editor.insertContent(createTableHtml(cols, rows));
|
|
tableElm = getInsertedElement(editor);
|
|
tableElm.removeAttribute('data-mce-id');
|
|
cellElm = editor.dom.select('td,th', tableElm);
|
|
editor.selection.setCursorLocation(cellElm[0], 0);
|
|
});
|
|
};
|
|
var insertTable = function (editor, cols, rows) {
|
|
editor.plugins.table ? editor.plugins.table.insertTable(cols, rows) : insertTableHtml(editor, cols, rows);
|
|
};
|
|
var formatBlock = function (editor, formatName) {
|
|
editor.execCommand('FormatBlock', false, formatName);
|
|
};
|
|
var insertBlob = function (editor, base64, blob) {
|
|
var blobCache, blobInfo;
|
|
blobCache = editor.editorUpload.blobCache;
|
|
blobInfo = blobCache.create($_49gxzf19mjjgwek5f.uuid('mceu'), blob, base64);
|
|
blobCache.add(blobInfo);
|
|
editor.insertContent(editor.dom.createHTML('img', { src: blobInfo.blobUri() }));
|
|
};
|
|
var collapseSelectionToEnd = function (editor) {
|
|
editor.selection.collapse(false);
|
|
};
|
|
var unlink = function (editor) {
|
|
editor.focus();
|
|
$_aunbnv19njjgwek5g.unlinkSelection(editor);
|
|
collapseSelectionToEnd(editor);
|
|
};
|
|
var changeHref = function (editor, elm, url) {
|
|
editor.focus();
|
|
editor.dom.setAttrib(elm, 'href', url);
|
|
collapseSelectionToEnd(editor);
|
|
};
|
|
var insertLink = function (editor, url) {
|
|
editor.execCommand('mceInsertLink', false, { href: url });
|
|
collapseSelectionToEnd(editor);
|
|
};
|
|
var updateOrInsertLink = function (editor, url) {
|
|
var elm = editor.dom.getParent(editor.selection.getStart(), 'a[href]');
|
|
elm ? changeHref(editor, elm, url) : insertLink(editor, url);
|
|
};
|
|
var createLink = function (editor, url) {
|
|
url.trim().length === 0 ? unlink(editor) : updateOrInsertLink(editor, url);
|
|
};
|
|
var $_elxm3u19ljjgwek5d = {
|
|
insertTable: insertTable,
|
|
formatBlock: formatBlock,
|
|
insertBlob: insertBlob,
|
|
createLink: createLink,
|
|
unlink: unlink
|
|
};
|
|
|
|
var addHeaderButtons = function (editor) {
|
|
var formatBlock = function (name) {
|
|
return function () {
|
|
$_elxm3u19ljjgwek5d.formatBlock(editor, name);
|
|
};
|
|
};
|
|
for (var i = 1; i < 6; i++) {
|
|
var name = 'h' + i;
|
|
editor.addButton(name, {
|
|
text: name.toUpperCase(),
|
|
tooltip: 'Heading ' + i,
|
|
stateSelector: name,
|
|
onclick: formatBlock(name),
|
|
onPostRender: function () {
|
|
var span = this.getEl().firstChild.firstChild;
|
|
span.style.fontWeight = 'bold';
|
|
}
|
|
});
|
|
}
|
|
};
|
|
var addToEditor = function (editor, panel) {
|
|
editor.addButton('quicklink', {
|
|
icon: 'link',
|
|
tooltip: 'Insert/Edit link',
|
|
stateSelector: 'a[href]',
|
|
onclick: function () {
|
|
panel.showForm(editor, 'quicklink');
|
|
}
|
|
});
|
|
editor.addButton('quickimage', {
|
|
icon: 'image',
|
|
tooltip: 'Insert image',
|
|
onclick: function () {
|
|
$_edjfwb19kjjgwek5a.pickFile().then(function (files) {
|
|
var blob = files[0];
|
|
$_c292419ejjgwek4z.blobToBase64(blob).then(function (base64) {
|
|
$_elxm3u19ljjgwek5d.insertBlob(editor, base64, blob);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
editor.addButton('quicktable', {
|
|
icon: 'table',
|
|
tooltip: 'Insert table',
|
|
onclick: function () {
|
|
panel.hide();
|
|
$_elxm3u19ljjgwek5d.insertTable(editor, 2, 2);
|
|
}
|
|
});
|
|
addHeaderButtons(editor);
|
|
};
|
|
var $_epdxt419djjgwek4l = { addToEditor: addToEditor };
|
|
|
|
var getUiContainerDelta$1 = function () {
|
|
var uiContainer = global$1.container;
|
|
if (uiContainer && global$2.DOM.getStyle(uiContainer, 'position', true) !== 'static') {
|
|
var containerPos = global$2.DOM.getPos(uiContainer);
|
|
var dx = containerPos.x - uiContainer.scrollLeft;
|
|
var dy = containerPos.y - uiContainer.scrollTop;
|
|
return Option.some({
|
|
x: dx,
|
|
y: dy
|
|
});
|
|
} else {
|
|
return Option.none();
|
|
}
|
|
};
|
|
var $_9hbv4x19sjjgwek5q = { getUiContainerDelta: getUiContainerDelta$1 };
|
|
|
|
var isDomainLike = function (href) {
|
|
return /^www\.|\.(com|org|edu|gov|uk|net|ca|de|jp|fr|au|us|ru|ch|it|nl|se|no|es|mil)$/i.test(href.trim());
|
|
};
|
|
var isAbsolute = function (href) {
|
|
return /^https?:\/\//.test(href.trim());
|
|
};
|
|
var $_5y05uk19ujjgwek5w = {
|
|
isDomainLike: isDomainLike,
|
|
isAbsolute: isAbsolute
|
|
};
|
|
|
|
var focusFirstTextBox = function (form) {
|
|
form.find('textbox').eq(0).each(function (ctrl) {
|
|
ctrl.focus();
|
|
});
|
|
};
|
|
var createForm = function (name, spec) {
|
|
var form = global$11.create(global$4.extend({
|
|
type: 'form',
|
|
layout: 'flex',
|
|
direction: 'row',
|
|
padding: 5,
|
|
name: name,
|
|
spacing: 3
|
|
}, spec));
|
|
form.on('show', function () {
|
|
focusFirstTextBox(form);
|
|
});
|
|
return form;
|
|
};
|
|
var toggleVisibility = function (ctrl, state) {
|
|
return state ? ctrl.show() : ctrl.hide();
|
|
};
|
|
var askAboutPrefix = function (editor, href) {
|
|
return new global$12(function (resolve) {
|
|
editor.windowManager.confirm('The URL you entered seems to be an external link. Do you want to add the required http:// prefix?', function (result) {
|
|
var output = result === true ? 'http://' + href : href;
|
|
resolve(output);
|
|
});
|
|
});
|
|
};
|
|
var convertLinkToAbsolute = function (editor, href) {
|
|
return !$_5y05uk19ujjgwek5w.isAbsolute(href) && $_5y05uk19ujjgwek5w.isDomainLike(href) ? askAboutPrefix(editor, href) : global$12.resolve(href);
|
|
};
|
|
var createQuickLinkForm = function (editor, hide) {
|
|
var attachState = {};
|
|
var unlink = function () {
|
|
editor.focus();
|
|
$_elxm3u19ljjgwek5d.unlink(editor);
|
|
hide();
|
|
};
|
|
var onChangeHandler = function (e) {
|
|
var meta = e.meta;
|
|
if (meta && meta.attach) {
|
|
attachState = {
|
|
href: this.value(),
|
|
attach: meta.attach
|
|
};
|
|
}
|
|
};
|
|
var onShowHandler = function (e) {
|
|
if (e.control === this) {
|
|
var elm = void 0, linkurl = '';
|
|
elm = editor.dom.getParent(editor.selection.getStart(), 'a[href]');
|
|
if (elm) {
|
|
linkurl = editor.dom.getAttrib(elm, 'href');
|
|
}
|
|
this.fromJSON({ linkurl: linkurl });
|
|
toggleVisibility(this.find('#unlink'), elm);
|
|
this.find('#linkurl')[0].focus();
|
|
}
|
|
};
|
|
return createForm('quicklink', {
|
|
items: [
|
|
{
|
|
type: 'button',
|
|
name: 'unlink',
|
|
icon: 'unlink',
|
|
onclick: unlink,
|
|
tooltip: 'Remove link'
|
|
},
|
|
{
|
|
type: 'filepicker',
|
|
name: 'linkurl',
|
|
placeholder: 'Paste or type a link',
|
|
filetype: 'file',
|
|
onchange: onChangeHandler
|
|
},
|
|
{
|
|
type: 'button',
|
|
icon: 'checkmark',
|
|
subtype: 'primary',
|
|
tooltip: 'Ok',
|
|
onclick: 'submit'
|
|
}
|
|
],
|
|
onshow: onShowHandler,
|
|
onsubmit: function (e) {
|
|
convertLinkToAbsolute(editor, e.data.linkurl).then(function (url) {
|
|
editor.undoManager.transact(function () {
|
|
if (url === attachState.href) {
|
|
attachState.attach();
|
|
attachState = {};
|
|
}
|
|
$_elxm3u19ljjgwek5d.createLink(editor, url);
|
|
});
|
|
hide();
|
|
});
|
|
}
|
|
});
|
|
};
|
|
var $_amewps19tjjgwek5t = { createQuickLinkForm: createQuickLinkForm };
|
|
|
|
var getSelectorStateResult = function (itemName, item) {
|
|
var result = function (selector, handler) {
|
|
return {
|
|
selector: selector,
|
|
handler: handler
|
|
};
|
|
};
|
|
var activeHandler = function (state) {
|
|
item.active(state);
|
|
};
|
|
var disabledHandler = function (state) {
|
|
item.disabled(state);
|
|
};
|
|
if (item.settings.stateSelector) {
|
|
return result(item.settings.stateSelector, activeHandler);
|
|
}
|
|
if (item.settings.disabledStateSelector) {
|
|
return result(item.settings.disabledStateSelector, disabledHandler);
|
|
}
|
|
return null;
|
|
};
|
|
var bindSelectorChanged = function (editor, itemName, item) {
|
|
return function () {
|
|
var result = getSelectorStateResult(itemName, item);
|
|
if (result !== null) {
|
|
editor.selection.selectorChanged(result.selector, result.handler);
|
|
}
|
|
};
|
|
};
|
|
var itemsToArray$1 = function (items) {
|
|
if ($_e4npq318ajjgwejzo.isArray(items)) {
|
|
return items;
|
|
} else if ($_e4npq318ajjgwejzo.isString(items)) {
|
|
return items.split(/[ ,]/);
|
|
}
|
|
return [];
|
|
};
|
|
var create$2 = function (editor, name, items) {
|
|
var toolbarItems = [];
|
|
var buttonGroup;
|
|
if (!items) {
|
|
return;
|
|
}
|
|
global$4.each(itemsToArray$1(items), function (item) {
|
|
if (item === '|') {
|
|
buttonGroup = null;
|
|
} else {
|
|
if (editor.buttons[item]) {
|
|
if (!buttonGroup) {
|
|
buttonGroup = {
|
|
type: 'buttongroup',
|
|
items: []
|
|
};
|
|
toolbarItems.push(buttonGroup);
|
|
}
|
|
var button = editor.buttons[item];
|
|
if ($_e4npq318ajjgwejzo.isFunction(button)) {
|
|
button = button();
|
|
}
|
|
button.type = button.type || 'button';
|
|
button = global$11.create(button);
|
|
button.on('postRender', bindSelectorChanged(editor, item, button));
|
|
buttonGroup.items.push(button);
|
|
}
|
|
}
|
|
});
|
|
return global$11.create({
|
|
type: 'toolbar',
|
|
layout: 'flow',
|
|
name: name,
|
|
items: toolbarItems
|
|
});
|
|
};
|
|
var $_797pa819vjjgwek5x = { create: create$2 };
|
|
|
|
var create$3 = function () {
|
|
var panel, currentRect;
|
|
var createToolbars = function (editor, toolbars) {
|
|
return global$4.map(toolbars, function (toolbar) {
|
|
return $_797pa819vjjgwek5x.create(editor, toolbar.id, toolbar.items);
|
|
});
|
|
};
|
|
var hasToolbarItems = function (toolbar) {
|
|
return toolbar.items().length > 0;
|
|
};
|
|
var create = function (editor, toolbars) {
|
|
var items = createToolbars(editor, toolbars).concat([
|
|
$_797pa819vjjgwek5x.create(editor, 'text', $_4j2h42187jjgwejzk.getTextSelectionToolbarItems(editor)),
|
|
$_797pa819vjjgwek5x.create(editor, 'insert', $_4j2h42187jjgwejzk.getInsertToolbarItems(editor)),
|
|
$_amewps19tjjgwek5t.createQuickLinkForm(editor, hide)
|
|
]);
|
|
return global$11.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: global$4.grep(items, hasToolbarItems),
|
|
oncancel: function () {
|
|
editor.focus();
|
|
}
|
|
});
|
|
};
|
|
var showPanel = function (panel) {
|
|
if (panel) {
|
|
panel.show();
|
|
}
|
|
};
|
|
var movePanelTo = function (panel, pos) {
|
|
panel.moveTo(pos.x, pos.y);
|
|
};
|
|
var togglePositionClass = function (panel, relPos) {
|
|
relPos = relPos ? relPos.substr(0, 2) : '';
|
|
global$4.each({
|
|
t: 'down',
|
|
b: 'up',
|
|
c: 'center'
|
|
}, function (cls, pos) {
|
|
panel.classes.toggle('arrow-' + cls, pos === relPos.substr(0, 1));
|
|
});
|
|
if (relPos === 'cr') {
|
|
panel.classes.toggle('arrow-left', true);
|
|
panel.classes.toggle('arrow-right', false);
|
|
} else if (relPos === 'cl') {
|
|
panel.classes.toggle('arrow-left', true);
|
|
panel.classes.toggle('arrow-right', true);
|
|
} else {
|
|
global$4.each({
|
|
l: 'left',
|
|
r: 'right'
|
|
}, function (cls, pos) {
|
|
panel.classes.toggle('arrow-' + cls, pos === relPos.substr(1, 1));
|
|
});
|
|
}
|
|
};
|
|
var showToolbar = function (panel, id) {
|
|
var toolbars = panel.items().filter('#' + id);
|
|
if (toolbars.length > 0) {
|
|
toolbars[0].show();
|
|
panel.reflow();
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
var repositionPanelAt = function (panel, id, editor, targetRect) {
|
|
var contentAreaRect, panelRect, result, userConstainHandler;
|
|
userConstainHandler = $_4j2h42187jjgwejzk.getPositionHandler(editor);
|
|
contentAreaRect = $_51qgo2180jjgwejzb.getContentAreaRect(editor);
|
|
panelRect = global$2.DOM.getRect(panel.getEl());
|
|
if (id === 'insert') {
|
|
result = $_gir42l18bjjgwejzq.calcInsert(targetRect, contentAreaRect, panelRect);
|
|
} else {
|
|
result = $_gir42l18bjjgwejzq.calc(targetRect, contentAreaRect, panelRect);
|
|
}
|
|
if (result) {
|
|
var delta = $_9hbv4x19sjjgwek5q.getUiContainerDelta().getOr({
|
|
x: 0,
|
|
y: 0
|
|
});
|
|
var transposedPanelRect = {
|
|
x: result.rect.x - delta.x,
|
|
y: result.rect.y - delta.y,
|
|
w: result.rect.w,
|
|
h: result.rect.h
|
|
};
|
|
currentRect = targetRect;
|
|
movePanelTo(panel, $_gir42l18bjjgwejzq.userConstrain(userConstainHandler, targetRect, contentAreaRect, transposedPanelRect));
|
|
togglePositionClass(panel, result.position);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
var showPanelAt = function (panel, id, editor, targetRect) {
|
|
showPanel(panel);
|
|
panel.items().hide();
|
|
if (!showToolbar(panel, id)) {
|
|
hide();
|
|
return;
|
|
}
|
|
if (repositionPanelAt(panel, id, editor, targetRect) === false) {
|
|
hide();
|
|
}
|
|
};
|
|
var hasFormVisible = function () {
|
|
return panel.items().filter('form:visible').length > 0;
|
|
};
|
|
var showForm = function (editor, id) {
|
|
if (panel) {
|
|
panel.items().hide();
|
|
if (!showToolbar(panel, id)) {
|
|
hide();
|
|
return;
|
|
}
|
|
var contentAreaRect = void 0, panelRect = void 0, result = void 0, userConstainHandler = void 0;
|
|
showPanel(panel);
|
|
panel.items().hide();
|
|
showToolbar(panel, id);
|
|
userConstainHandler = $_4j2h42187jjgwejzk.getPositionHandler(editor);
|
|
contentAreaRect = $_51qgo2180jjgwejzb.getContentAreaRect(editor);
|
|
panelRect = global$2.DOM.getRect(panel.getEl());
|
|
result = $_gir42l18bjjgwejzq.calc(currentRect, contentAreaRect, panelRect);
|
|
if (result) {
|
|
panelRect = result.rect;
|
|
movePanelTo(panel, $_gir42l18bjjgwejzq.userConstrain(userConstainHandler, currentRect, contentAreaRect, panelRect));
|
|
togglePositionClass(panel, result.position);
|
|
}
|
|
}
|
|
};
|
|
var show = function (editor, id, targetRect, toolbars) {
|
|
if (!panel) {
|
|
$_77u64d186jjgwejzi.fireBeforeRenderUI(editor);
|
|
panel = create(editor, toolbars);
|
|
panel.renderTo().reflow().moveTo(targetRect.x, targetRect.y);
|
|
editor.nodeChanged();
|
|
}
|
|
showPanelAt(panel, id, editor, targetRect);
|
|
};
|
|
var reposition = function (editor, id, targetRect) {
|
|
if (panel) {
|
|
repositionPanelAt(panel, id, editor, targetRect);
|
|
}
|
|
};
|
|
var hide = function () {
|
|
if (panel) {
|
|
panel.hide();
|
|
}
|
|
};
|
|
var focus = function () {
|
|
if (panel) {
|
|
panel.find('toolbar:visible').eq(0).each(function (item) {
|
|
item.focus(true);
|
|
});
|
|
}
|
|
};
|
|
var remove = function () {
|
|
if (panel) {
|
|
panel.remove();
|
|
panel = null;
|
|
}
|
|
};
|
|
var inForm = function () {
|
|
return panel && panel.visible() && hasFormVisible();
|
|
};
|
|
return {
|
|
show: show,
|
|
showForm: showForm,
|
|
reposition: reposition,
|
|
inForm: inForm,
|
|
hide: hide,
|
|
focus: focus,
|
|
remove: remove
|
|
};
|
|
};
|
|
|
|
var Layout$1 = global$8.extend({
|
|
Defaults: {
|
|
firstControlClass: 'first',
|
|
lastControlClass: 'last'
|
|
},
|
|
init: function (settings) {
|
|
this.settings = global$4.extend({}, this.Defaults, settings);
|
|
},
|
|
preRender: function (container) {
|
|
container.bodyClasses.add(this.settings.containerClass);
|
|
},
|
|
applyClasses: function (items) {
|
|
var self = this;
|
|
var settings = self.settings;
|
|
var 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);
|
|
}
|
|
},
|
|
renderHtml: function (container) {
|
|
var self = this;
|
|
var html = '';
|
|
self.applyClasses(container.items());
|
|
container.items().each(function (item) {
|
|
html += item.renderHtml();
|
|
});
|
|
return html;
|
|
},
|
|
recalc: function () {
|
|
},
|
|
postRender: function () {
|
|
},
|
|
isNative: function () {
|
|
return false;
|
|
}
|
|
});
|
|
|
|
var AbsoluteLayout = Layout$1.extend({
|
|
Defaults: {
|
|
containerClass: 'abs-layout',
|
|
controlClass: 'abs-layout-item'
|
|
},
|
|
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();
|
|
}
|
|
});
|
|
},
|
|
renderHtml: function (container) {
|
|
return '<div id="' + container._id + '-absend" class="' + container.classPrefix + 'abs-end"></div>' + this._super(container);
|
|
}
|
|
});
|
|
|
|
var Button = Widget.extend({
|
|
Defaults: {
|
|
classes: 'widget btn',
|
|
role: 'button'
|
|
},
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
var size;
|
|
self$$1._super(settings);
|
|
settings = self$$1.settings;
|
|
size = self$$1.settings.size;
|
|
self$$1.on('click mousedown', function (e) {
|
|
e.preventDefault();
|
|
});
|
|
self$$1.on('touchstart', function (e) {
|
|
self$$1.fire('click', e);
|
|
e.preventDefault();
|
|
});
|
|
if (settings.subtype) {
|
|
self$$1.classes.add(settings.subtype);
|
|
}
|
|
if (size) {
|
|
self$$1.classes.add('btn-' + size);
|
|
}
|
|
if (settings.icon) {
|
|
self$$1.icon(settings.icon);
|
|
}
|
|
},
|
|
icon: function (icon) {
|
|
if (!arguments.length) {
|
|
return this.state.get('icon');
|
|
}
|
|
this.state.set('icon', icon);
|
|
return this;
|
|
},
|
|
repaint: function () {
|
|
var btnElm = this.getEl().firstChild;
|
|
var btnStyle;
|
|
if (btnElm) {
|
|
btnStyle = btnElm.style;
|
|
btnStyle.width = btnStyle.height = '100%';
|
|
}
|
|
this._super();
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this, id = self$$1._id, prefix = self$$1.classPrefix;
|
|
var icon = self$$1.state.get('icon'), image;
|
|
var text = self$$1.state.get('text');
|
|
var textHtml = '';
|
|
var ariaPressed;
|
|
var settings = self$$1.settings;
|
|
image = settings.image;
|
|
if (image) {
|
|
icon = 'none';
|
|
if (typeof image !== 'string') {
|
|
image = window.getSelection ? image[0] : image[1];
|
|
}
|
|
image = ' style="background-image: url(\'' + image + '\')"';
|
|
} else {
|
|
image = '';
|
|
}
|
|
if (text) {
|
|
self$$1.classes.add('btn-has-text');
|
|
textHtml = '<span class="' + prefix + 'txt">' + self$$1.encode(text) + '</span>';
|
|
}
|
|
icon = icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
|
|
ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
|
|
return '<div id="' + id + '" class="' + self$$1.classes + '" tabindex="-1"' + ariaPressed + '>' + '<button id="' + id + '-button" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '</div>';
|
|
},
|
|
bindStates: function () {
|
|
var self$$1 = this, $ = self$$1.$, textCls = self$$1.classPrefix + 'txt';
|
|
function setButtonText(text) {
|
|
var $span = $('span.' + textCls, self$$1.getEl());
|
|
if (text) {
|
|
if (!$span[0]) {
|
|
$('button:first', self$$1.getEl()).append('<span class="' + textCls + '"></span>');
|
|
$span = $('span.' + textCls, self$$1.getEl());
|
|
}
|
|
$span.html(self$$1.encode(text));
|
|
} else {
|
|
$span.remove();
|
|
}
|
|
self$$1.classes.toggle('btn-has-text', !!text);
|
|
}
|
|
self$$1.state.on('change:text', function (e) {
|
|
setButtonText(e.value);
|
|
});
|
|
self$$1.state.on('change:icon', function (e) {
|
|
var icon = e.value;
|
|
var prefix = self$$1.classPrefix;
|
|
self$$1.settings.icon = icon;
|
|
icon = icon ? prefix + 'ico ' + prefix + 'i-' + self$$1.settings.icon : '';
|
|
var btnElm = self$$1.getEl().firstChild;
|
|
var 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$$1.state.get('text'));
|
|
});
|
|
return self$$1._super();
|
|
}
|
|
});
|
|
|
|
var BrowseButton = Button.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
settings = global$4.extend({
|
|
text: 'Browse...',
|
|
multiple: false,
|
|
accept: null
|
|
}, settings);
|
|
self._super(settings);
|
|
self.classes.add('browsebutton');
|
|
if (settings.multiple) {
|
|
self.classes.add('multiple');
|
|
}
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
var input = funcs.create('input', {
|
|
type: 'file',
|
|
id: self._id + '-browse',
|
|
accept: self.settings.accept
|
|
});
|
|
self._super();
|
|
global$7(input).on('change', function (e) {
|
|
var files = e.target.files;
|
|
self.value = function () {
|
|
if (!files.length) {
|
|
return null;
|
|
} else if (self.settings.multiple) {
|
|
return files;
|
|
} else {
|
|
return files[0];
|
|
}
|
|
};
|
|
e.preventDefault();
|
|
if (files.length) {
|
|
self.fire('change', e);
|
|
}
|
|
});
|
|
global$7(input).on('click', function (e) {
|
|
e.stopPropagation();
|
|
});
|
|
global$7(self.getEl('button')).on('click', function (e) {
|
|
e.stopPropagation();
|
|
input.click();
|
|
});
|
|
self.getEl().appendChild(input);
|
|
},
|
|
remove: function () {
|
|
global$7(this.getEl('button')).off();
|
|
global$7(this.getEl('input')).off();
|
|
this._super();
|
|
}
|
|
});
|
|
|
|
var ButtonGroup = Container.extend({
|
|
Defaults: {
|
|
defaultType: 'button',
|
|
role: 'group'
|
|
},
|
|
renderHtml: function () {
|
|
var self = this, layout = self._layout;
|
|
self.classes.add('btn-group');
|
|
self.preRender();
|
|
layout.preRender(self);
|
|
return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
|
|
}
|
|
});
|
|
|
|
var Checkbox = Widget.extend({
|
|
Defaults: {
|
|
classes: 'checkbox',
|
|
role: 'checkbox',
|
|
checked: false
|
|
},
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
self$$1._super(settings);
|
|
self$$1.on('click mousedown', function (e) {
|
|
e.preventDefault();
|
|
});
|
|
self$$1.on('click', function (e) {
|
|
e.preventDefault();
|
|
if (!self$$1.disabled()) {
|
|
self$$1.checked(!self$$1.checked());
|
|
}
|
|
});
|
|
self$$1.checked(self$$1.settings.checked);
|
|
},
|
|
checked: function (state) {
|
|
if (!arguments.length) {
|
|
return this.state.get('checked');
|
|
}
|
|
this.state.set('checked', state);
|
|
return this;
|
|
},
|
|
value: function (state) {
|
|
if (!arguments.length) {
|
|
return this.checked();
|
|
}
|
|
return this.checked(state);
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this, id = self$$1._id, prefix = self$$1.classPrefix;
|
|
return '<div id="' + id + '" class="' + self$$1.classes + '" unselectable="on" aria-labelledby="' + id + '-al" tabindex="-1">' + '<i class="' + prefix + 'ico ' + prefix + 'i-checkbox"></i>' + '<span id="' + id + '-al" class="' + prefix + 'label">' + self$$1.encode(self$$1.state.get('text')) + '</span>' + '</div>';
|
|
},
|
|
bindStates: function () {
|
|
var self$$1 = this;
|
|
function checked(state) {
|
|
self$$1.classes.toggle('checked', state);
|
|
self$$1.aria('checked', state);
|
|
}
|
|
self$$1.state.on('change:text', function (e) {
|
|
self$$1.getEl('al').firstChild.data = self$$1.translate(e.value);
|
|
});
|
|
self$$1.state.on('change:checked change:value', function (e) {
|
|
self$$1.fire('change');
|
|
checked(e.value);
|
|
});
|
|
self$$1.state.on('change:icon', function (e) {
|
|
var icon = e.value;
|
|
var prefix = self$$1.classPrefix;
|
|
if (typeof icon === 'undefined') {
|
|
return self$$1.settings.icon;
|
|
}
|
|
self$$1.settings.icon = icon;
|
|
icon = icon ? prefix + 'ico ' + prefix + 'i-' + self$$1.settings.icon : '';
|
|
var btnElm = self$$1.getEl().firstChild;
|
|
var 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$$1.state.get('checked')) {
|
|
checked(true);
|
|
}
|
|
return self$$1._super();
|
|
}
|
|
});
|
|
|
|
var global$15 = tinymce.util.Tools.resolve('tinymce.util.VK');
|
|
|
|
var ComboBox = Widget.extend({
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
self$$1._super(settings);
|
|
settings = self$$1.settings;
|
|
self$$1.classes.add('combobox');
|
|
self$$1.subinput = true;
|
|
self$$1.ariaTarget = 'inp';
|
|
settings.menu = settings.menu || settings.values;
|
|
if (settings.menu) {
|
|
settings.icon = 'caret';
|
|
}
|
|
self$$1.on('click', function (e) {
|
|
var elm = e.target;
|
|
var root = self$$1.getEl();
|
|
if (!global$7.contains(root, elm) && elm !== root) {
|
|
return;
|
|
}
|
|
while (elm && elm !== root) {
|
|
if (elm.id && elm.id.indexOf('-open') !== -1) {
|
|
self$$1.fire('action');
|
|
if (settings.menu) {
|
|
self$$1.showMenu();
|
|
if (e.aria) {
|
|
self$$1.menu.items()[0].focus();
|
|
}
|
|
}
|
|
}
|
|
elm = elm.parentNode;
|
|
}
|
|
});
|
|
self$$1.on('keydown', function (e) {
|
|
var rootControl;
|
|
if (e.keyCode === 13 && e.target.nodeName === 'INPUT') {
|
|
e.preventDefault();
|
|
self$$1.parents().reverse().each(function (ctrl) {
|
|
if (ctrl.toJSON) {
|
|
rootControl = ctrl;
|
|
return false;
|
|
}
|
|
});
|
|
self$$1.fire('submit', { data: rootControl.toJSON() });
|
|
}
|
|
});
|
|
self$$1.on('keyup', function (e) {
|
|
if (e.target.nodeName === 'INPUT') {
|
|
var oldValue = self$$1.state.get('value');
|
|
var newValue = e.target.value;
|
|
if (newValue !== oldValue) {
|
|
self$$1.state.set('value', newValue);
|
|
self$$1.fire('autocomplete', e);
|
|
}
|
|
}
|
|
});
|
|
self$$1.on('mouseover', function (e) {
|
|
var tooltip = self$$1.tooltip().moveTo(-65535);
|
|
if (self$$1.statusLevel() && e.target.className.indexOf(self$$1.classPrefix + 'status') !== -1) {
|
|
var statusMessage = self$$1.statusMessage() || 'Ok';
|
|
var rel = tooltip.text(statusMessage).show().testMoveRel(e.target, [
|
|
'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(e.target, rel);
|
|
}
|
|
});
|
|
},
|
|
statusLevel: function (value) {
|
|
if (arguments.length > 0) {
|
|
this.state.set('statusLevel', value);
|
|
}
|
|
return this.state.get('statusLevel');
|
|
},
|
|
statusMessage: function (value) {
|
|
if (arguments.length > 0) {
|
|
this.state.set('statusMessage', value);
|
|
}
|
|
return this.state.get('statusMessage');
|
|
},
|
|
showMenu: function () {
|
|
var self$$1 = this;
|
|
var settings = self$$1.settings;
|
|
var menu;
|
|
if (!self$$1.menu) {
|
|
menu = settings.menu || [];
|
|
if (menu.length) {
|
|
menu = {
|
|
type: 'menu',
|
|
items: menu
|
|
};
|
|
} else {
|
|
menu.type = menu.type || 'menu';
|
|
}
|
|
self$$1.menu = global$11.create(menu).parent(self$$1).renderTo(self$$1.getContainerElm());
|
|
self$$1.fire('createmenu');
|
|
self$$1.menu.reflow();
|
|
self$$1.menu.on('cancel', function (e) {
|
|
if (e.control === self$$1.menu) {
|
|
self$$1.focus();
|
|
}
|
|
});
|
|
self$$1.menu.on('show hide', function (e) {
|
|
e.control.items().each(function (ctrl) {
|
|
ctrl.active(ctrl.value() === self$$1.value());
|
|
});
|
|
}).fire('show');
|
|
self$$1.menu.on('select', function (e) {
|
|
self$$1.value(e.control.value());
|
|
});
|
|
self$$1.on('focusin', function (e) {
|
|
if (e.target.tagName.toUpperCase() === 'INPUT') {
|
|
self$$1.menu.hide();
|
|
}
|
|
});
|
|
self$$1.aria('expanded', true);
|
|
}
|
|
self$$1.menu.show();
|
|
self$$1.menu.layoutRect({ w: self$$1.layoutRect().w });
|
|
self$$1.menu.moveRel(self$$1.getEl(), self$$1.isRtl() ? [
|
|
'br-tr',
|
|
'tr-br'
|
|
] : [
|
|
'bl-tl',
|
|
'tl-bl'
|
|
]);
|
|
},
|
|
focus: function () {
|
|
this.getEl('inp').focus();
|
|
},
|
|
repaint: function () {
|
|
var self$$1 = this, elm = self$$1.getEl(), openElm = self$$1.getEl('open'), rect = self$$1.layoutRect();
|
|
var width, lineHeight, innerPadding = 0;
|
|
var inputElm = elm.firstChild;
|
|
if (self$$1.statusLevel() && self$$1.statusLevel() !== 'none') {
|
|
innerPadding = parseInt(funcs.getRuntimeStyle(inputElm, 'padding-right'), 10) - parseInt(funcs.getRuntimeStyle(inputElm, 'padding-left'), 10);
|
|
}
|
|
if (openElm) {
|
|
width = rect.w - funcs.getSize(openElm).width - 10;
|
|
} else {
|
|
width = rect.w - 10;
|
|
}
|
|
var doc = document;
|
|
if (doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
|
|
lineHeight = self$$1.layoutRect().h - 2 + 'px';
|
|
}
|
|
global$7(inputElm).css({
|
|
width: width - innerPadding,
|
|
lineHeight: lineHeight
|
|
});
|
|
self$$1._super();
|
|
return self$$1;
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this;
|
|
global$7(this.getEl('inp')).on('change', function (e) {
|
|
self$$1.state.set('value', e.target.value);
|
|
self$$1.fire('change', e);
|
|
});
|
|
return self$$1._super();
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this, id = self$$1._id, settings = self$$1.settings, prefix = self$$1.classPrefix;
|
|
var value = self$$1.state.get('value') || '';
|
|
var icon, text, openBtnHtml = '', extraAttrs = '', statusHtml = '';
|
|
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 + '"';
|
|
}
|
|
statusHtml = '<i id="' + id + '-status" class="mce-status mce-ico" style="display: none"></i>';
|
|
if (self$$1.disabled()) {
|
|
extraAttrs += ' disabled="disabled"';
|
|
}
|
|
icon = settings.icon;
|
|
if (icon && icon !== 'caret') {
|
|
icon = prefix + 'ico ' + prefix + 'i-' + settings.icon;
|
|
}
|
|
text = self$$1.state.get('text');
|
|
if (icon || text) {
|
|
openBtnHtml = '<div id="' + id + '-open" class="' + prefix + 'btn ' + prefix + 'open" tabIndex="-1" role="button">' + '<button id="' + id + '-action" type="button" hidefocus="1" tabindex="-1">' + (icon !== 'caret' ? '<i class="' + icon + '"></i>' : '<i class="' + prefix + 'caret"></i>') + (text ? (icon ? ' ' : '') + text : '') + '</button>' + '</div>';
|
|
self$$1.classes.add('has-open');
|
|
}
|
|
return '<div id="' + id + '" class="' + self$$1.classes + '">' + '<input id="' + id + '-inp" class="' + prefix + 'textbox" value="' + self$$1.encode(value, false) + '" hidefocus="1"' + extraAttrs + ' placeholder="' + self$$1.encode(settings.placeholder) + '" />' + statusHtml + openBtnHtml + '</div>';
|
|
},
|
|
value: function (value) {
|
|
if (arguments.length) {
|
|
this.state.set('value', value);
|
|
return this;
|
|
}
|
|
if (this.state.get('rendered')) {
|
|
this.state.set('value', this.getEl('inp').value);
|
|
}
|
|
return this.state.get('value');
|
|
},
|
|
showAutoComplete: function (items, term) {
|
|
var self$$1 = this;
|
|
if (items.length === 0) {
|
|
self$$1.hideMenu();
|
|
return;
|
|
}
|
|
var insert = function (value, title) {
|
|
return function () {
|
|
self$$1.fire('selectitem', {
|
|
title: title,
|
|
value: value
|
|
});
|
|
};
|
|
};
|
|
if (self$$1.menu) {
|
|
self$$1.menu.items().remove();
|
|
} else {
|
|
self$$1.menu = global$11.create({
|
|
type: 'menu',
|
|
classes: 'combobox-menu',
|
|
layout: 'flow'
|
|
}).parent(self$$1).renderTo();
|
|
}
|
|
global$4.each(items, function (item) {
|
|
self$$1.menu.add({
|
|
text: item.title,
|
|
url: item.previewUrl,
|
|
match: term,
|
|
classes: 'menu-item-ellipsis',
|
|
onclick: insert(item.value, item.title)
|
|
});
|
|
});
|
|
self$$1.menu.renderNew();
|
|
self$$1.hideMenu();
|
|
self$$1.menu.on('cancel', function (e) {
|
|
if (e.control.parent() === self$$1.menu) {
|
|
e.stopPropagation();
|
|
self$$1.focus();
|
|
self$$1.hideMenu();
|
|
}
|
|
});
|
|
self$$1.menu.on('select', function () {
|
|
self$$1.focus();
|
|
});
|
|
var maxW = self$$1.layoutRect().w;
|
|
self$$1.menu.layoutRect({
|
|
w: maxW,
|
|
minW: 0,
|
|
maxW: maxW
|
|
});
|
|
self$$1.menu.repaint();
|
|
self$$1.menu.reflow();
|
|
self$$1.menu.show();
|
|
self$$1.menu.moveRel(self$$1.getEl(), self$$1.isRtl() ? [
|
|
'br-tr',
|
|
'tr-br'
|
|
] : [
|
|
'bl-tl',
|
|
'tl-bl'
|
|
]);
|
|
},
|
|
hideMenu: function () {
|
|
if (this.menu) {
|
|
this.menu.hide();
|
|
}
|
|
},
|
|
bindStates: function () {
|
|
var self$$1 = this;
|
|
self$$1.state.on('change:value', function (e) {
|
|
if (self$$1.getEl('inp').value !== e.value) {
|
|
self$$1.getEl('inp').value = e.value;
|
|
}
|
|
});
|
|
self$$1.state.on('change:disabled', function (e) {
|
|
self$$1.getEl('inp').disabled = e.value;
|
|
});
|
|
self$$1.state.on('change:statusLevel', function (e) {
|
|
var statusIconElm = self$$1.getEl('status');
|
|
var prefix = self$$1.classPrefix, value = e.value;
|
|
funcs.css(statusIconElm, 'display', value === 'none' ? 'none' : '');
|
|
funcs.toggleClass(statusIconElm, prefix + 'i-checkmark', value === 'ok');
|
|
funcs.toggleClass(statusIconElm, prefix + 'i-warning', value === 'warn');
|
|
funcs.toggleClass(statusIconElm, prefix + 'i-error', value === 'error');
|
|
self$$1.classes.toggle('has-status', value !== 'none');
|
|
self$$1.repaint();
|
|
});
|
|
funcs.on(self$$1.getEl('status'), 'mouseleave', function () {
|
|
self$$1.tooltip().hide();
|
|
});
|
|
self$$1.on('cancel', function (e) {
|
|
if (self$$1.menu && self$$1.menu.visible()) {
|
|
e.stopPropagation();
|
|
self$$1.hideMenu();
|
|
}
|
|
});
|
|
var focusIdx = function (idx, menu) {
|
|
if (menu && menu.items().length > 0) {
|
|
menu.items().eq(idx)[0].focus();
|
|
}
|
|
};
|
|
self$$1.on('keydown', function (e) {
|
|
var keyCode = e.keyCode;
|
|
if (e.target.nodeName === 'INPUT') {
|
|
if (keyCode === global$15.DOWN) {
|
|
e.preventDefault();
|
|
self$$1.fire('autocomplete');
|
|
focusIdx(0, self$$1.menu);
|
|
} else if (keyCode === global$15.UP) {
|
|
e.preventDefault();
|
|
focusIdx(-1, self$$1.menu);
|
|
}
|
|
}
|
|
});
|
|
return self$$1._super();
|
|
},
|
|
remove: function () {
|
|
global$7(this.getEl('inp')).off();
|
|
if (this.menu) {
|
|
this.menu.remove();
|
|
}
|
|
this._super();
|
|
}
|
|
});
|
|
|
|
var ColorBox = ComboBox.extend({
|
|
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 openElm = this.getEl('open');
|
|
var elm = openElm ? openElm.getElementsByTagName('i')[0] : null;
|
|
if (elm) {
|
|
try {
|
|
elm.style.background = value;
|
|
} catch (ex) {
|
|
}
|
|
}
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self.state.on('change:value', function (e) {
|
|
if (self.state.get('rendered')) {
|
|
self.repaintColor(e.value);
|
|
}
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
var PanelButton = Button.extend({
|
|
showPanel: function () {
|
|
var self = this, settings = self.settings;
|
|
self.classes.add('opened');
|
|
if (!self.panel) {
|
|
var panelSettings = settings.panel;
|
|
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.classes.remove('opened');
|
|
}).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();
|
|
}
|
|
var rtlRels = [
|
|
'bc-tc',
|
|
'bc-tl',
|
|
'bc-tr'
|
|
];
|
|
var ltrRels = [
|
|
'bc-tc',
|
|
'bc-tr',
|
|
'bc-tl',
|
|
'tc-bc',
|
|
'tc-br',
|
|
'tc-bl'
|
|
];
|
|
var rel = self.panel.testMoveRel(self.getEl(), settings.popoverAlign || (self.isRtl() ? rtlRels : ltrRels));
|
|
self.panel.classes.toggle('start', rel.substr(-1) === 'l');
|
|
self.panel.classes.toggle('end', rel.substr(-1) === 'r');
|
|
var isTop = rel.substr(0, 1) === 't';
|
|
self.panel.classes.toggle('bottom', !isTop);
|
|
self.panel.classes.toggle('top', isTop);
|
|
self.panel.moveRel(self.getEl(), rel);
|
|
},
|
|
hidePanel: function () {
|
|
var self = this;
|
|
if (self.panel) {
|
|
self.panel.hide();
|
|
}
|
|
},
|
|
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();
|
|
}
|
|
});
|
|
|
|
var DOM = global$2.DOM;
|
|
var ColorButton = PanelButton.extend({
|
|
init: function (settings) {
|
|
this._super(settings);
|
|
this.classes.add('splitbtn');
|
|
this.classes.add('colorbutton');
|
|
},
|
|
color: function (color) {
|
|
if (color) {
|
|
this._color = color;
|
|
this.getEl('preview').style.backgroundColor = color;
|
|
return this;
|
|
}
|
|
return this._color;
|
|
},
|
|
resetColor: function () {
|
|
this._color = null;
|
|
this.getEl('preview').style.backgroundColor = null;
|
|
return this;
|
|
},
|
|
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 + '\')"' : '';
|
|
var textHtml = '';
|
|
if (text) {
|
|
self.classes.add('btn-has-text');
|
|
textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
|
|
}
|
|
return '<div id="' + id + '" class="' + self.classes + '" role="button" tabindex="-1" aria-haspopup="true">' + '<button role="presentation" hidefocus="1" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + '<span id="' + id + '-preview" class="' + prefix + 'preview"></span>' + textHtml + '</button>' + '<button type="button" class="' + prefix + 'open" hidefocus="1" tabindex="-1">' + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
|
|
},
|
|
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();
|
|
}
|
|
});
|
|
|
|
var global$16 = tinymce.util.Tools.resolve('tinymce.util.Color');
|
|
|
|
var ColorPicker = Widget.extend({
|
|
Defaults: { classes: 'widget colorpicker' },
|
|
init: function (settings) {
|
|
this._super(settings);
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
var color = self.color();
|
|
var 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 = funcs.getPos(elm);
|
|
var 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;
|
|
funcs.css(huePointElm, { top: hue * 100 + '%' });
|
|
if (!hueUpdate) {
|
|
funcs.css(svPointElm, {
|
|
left: hsv.s + '%',
|
|
top: 100 - hsv.v + '%'
|
|
});
|
|
}
|
|
svRootElm.style.background = global$16({
|
|
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 = global$16();
|
|
}
|
|
return this._color;
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var id = self._id;
|
|
var prefix = self.classPrefix;
|
|
var 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 += '<div class="' + prefix + 'colorpicker-h-chunk" style="' + 'height:' + 100 / l + '%;' + gradientPrefix + stopsList[i] + ',endColorstr=' + stopsList[i + 1] + ');' + '-ms-' + gradientPrefix + stopsList[i] + ',endColorstr=' + stopsList[i + 1] + ')' + '"></div>';
|
|
}
|
|
return html;
|
|
}
|
|
var gradientCssText = 'background: -ms-linear-gradient(top,' + stops + ');' + 'background: linear-gradient(to bottom,' + stops + ');';
|
|
hueHtml = '<div id="' + id + '-h" class="' + prefix + 'colorpicker-h" style="' + gradientCssText + '">' + getOldIeFallbackHtml() + '<div id="' + id + '-hp" class="' + prefix + 'colorpicker-h-marker"></div>' + '</div>';
|
|
return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-sv" class="' + prefix + 'colorpicker-sv">' + '<div class="' + prefix + 'colorpicker-overlay1">' + '<div class="' + prefix + 'colorpicker-overlay2">' + '<div id="' + id + '-svp" class="' + prefix + 'colorpicker-selector1">' + '<div class="' + prefix + 'colorpicker-selector2"></div>' + '</div>' + '</div>' + '</div>' + '</div>' + hueHtml + '</div>';
|
|
}
|
|
});
|
|
|
|
var DropZone = Widget.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
settings = global$4.extend({
|
|
height: 100,
|
|
text: 'Drop an image here',
|
|
multiple: false,
|
|
accept: null
|
|
}, settings);
|
|
self._super(settings);
|
|
self.classes.add('dropzone');
|
|
if (settings.multiple) {
|
|
self.classes.add('multiple');
|
|
}
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var attrs, elm;
|
|
var cfg = self.settings;
|
|
attrs = {
|
|
id: self._id,
|
|
hidefocus: '1'
|
|
};
|
|
elm = funcs.create('div', attrs, '<span>' + this.translate(cfg.text) + '</span>');
|
|
if (cfg.height) {
|
|
funcs.css(elm, 'height', cfg.height + 'px');
|
|
}
|
|
if (cfg.width) {
|
|
funcs.css(elm, 'width', cfg.width + 'px');
|
|
}
|
|
elm.className = self.classes;
|
|
return elm.outerHTML;
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
var toggleDragClass = function (e) {
|
|
e.preventDefault();
|
|
self.classes.toggle('dragenter');
|
|
self.getEl().className = self.classes;
|
|
};
|
|
var filter = function (files) {
|
|
var accept = self.settings.accept;
|
|
if (typeof accept !== 'string') {
|
|
return files;
|
|
}
|
|
var re = new RegExp('(' + accept.split(/\s*,\s*/).join('|') + ')$', 'i');
|
|
return global$4.grep(files, function (file) {
|
|
return re.test(file.name);
|
|
});
|
|
};
|
|
self._super();
|
|
self.$el.on('dragover', function (e) {
|
|
e.preventDefault();
|
|
});
|
|
self.$el.on('dragenter', toggleDragClass);
|
|
self.$el.on('dragleave', toggleDragClass);
|
|
self.$el.on('drop', function (e) {
|
|
e.preventDefault();
|
|
if (self.state.get('disabled')) {
|
|
return;
|
|
}
|
|
var files = filter(e.dataTransfer.files);
|
|
self.value = function () {
|
|
if (!files.length) {
|
|
return null;
|
|
} else if (self.settings.multiple) {
|
|
return files;
|
|
} else {
|
|
return files[0];
|
|
}
|
|
};
|
|
if (files.length) {
|
|
self.fire('change', e);
|
|
}
|
|
});
|
|
},
|
|
remove: function () {
|
|
this.$el.off();
|
|
this._super();
|
|
}
|
|
});
|
|
|
|
var Path = Widget.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
if (!settings.delimiter) {
|
|
settings.delimiter = '\xBB';
|
|
}
|
|
self._super(settings);
|
|
self.classes.add('path');
|
|
self.canFocus = true;
|
|
self.on('click', function (e) {
|
|
var index;
|
|
var target = e.target;
|
|
if (index = target.getAttribute('data-index')) {
|
|
self.fire('select', {
|
|
value: self.row()[index],
|
|
index: index
|
|
});
|
|
}
|
|
});
|
|
self.row(self.settings.row);
|
|
},
|
|
focus: function () {
|
|
var self = this;
|
|
self.getEl().firstChild.focus();
|
|
return self;
|
|
},
|
|
row: function (row) {
|
|
if (!arguments.length) {
|
|
return this.state.get('row');
|
|
}
|
|
this.state.set('row', row);
|
|
return this;
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
return '<div id="' + self._id + '" class="' + self.classes + '">' + self._getDataPathHtml(self.state.get('row')) + '</div>';
|
|
},
|
|
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;
|
|
var parts = data || [];
|
|
var i, l, html = '';
|
|
var prefix = self.classPrefix;
|
|
for (i = 0, l = parts.length; i < l; i++) {
|
|
html += (i > 0 ? '<div class="' + prefix + 'divider" aria-hidden="true"> ' + self.settings.delimiter + ' </div>' : '') + '<div role="button" class="' + prefix + 'path-item' + (i === l - 1 ? ' ' + prefix + 'last' : '') + '" data-index="' + i + '" tabindex="-1" id="' + self._id + '-' + i + '" aria-level="' + (i + 1) + '">' + parts[i].name + '</div>';
|
|
}
|
|
if (!html) {
|
|
html = '<div class="' + prefix + 'path-item">\xA0</div>';
|
|
}
|
|
return html;
|
|
}
|
|
});
|
|
|
|
var ElementPath = Path.extend({
|
|
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 = [];
|
|
var parents = e.parents;
|
|
var 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();
|
|
}
|
|
});
|
|
|
|
var FormItem = Container.extend({
|
|
Defaults: {
|
|
layout: 'flex',
|
|
align: 'center',
|
|
defaults: { flex: 1 }
|
|
},
|
|
renderHtml: function () {
|
|
var self = this, layout = self._layout, prefix = self.classPrefix;
|
|
self.classes.add('formitem');
|
|
layout.preRender(self);
|
|
return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + (self.settings.title ? '<div id="' + self._id + '-title" class="' + prefix + 'title">' + self.settings.title + '</div>' : '') + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
|
|
}
|
|
});
|
|
|
|
var Form = Container.extend({
|
|
Defaults: {
|
|
containerCls: 'form',
|
|
layout: 'flex',
|
|
direction: 'column',
|
|
align: 'stretch',
|
|
flex: 1,
|
|
padding: 15,
|
|
labelGap: 30,
|
|
spacing: 10,
|
|
callbacks: {
|
|
submit: function () {
|
|
this.submit();
|
|
}
|
|
}
|
|
},
|
|
preRender: function () {
|
|
var self = this, items = self.items();
|
|
if (!self.settings.formItemDefaults) {
|
|
self.settings.formItemDefaults = {
|
|
layout: 'flex',
|
|
autoResize: 'overflow',
|
|
defaults: { flex: 1 }
|
|
};
|
|
}
|
|
items.each(function (ctrl) {
|
|
var formItem;
|
|
var label = ctrl.settings.label;
|
|
if (label) {
|
|
formItem = new FormItem(global$4.extend({
|
|
items: {
|
|
type: 'label',
|
|
id: ctrl._id + '-l',
|
|
text: label,
|
|
flex: 0,
|
|
forId: ctrl._id,
|
|
disabled: ctrl.disabled()
|
|
}
|
|
}, self.settings.formItemDefaults));
|
|
formItem.type = 'formitem';
|
|
ctrl.aria('labelledby', ctrl._id + '-l');
|
|
if (typeof ctrl.settings.flex === 'undefined') {
|
|
ctrl.settings.flex = 1;
|
|
}
|
|
self.replace(ctrl, formItem);
|
|
formItem.add(ctrl);
|
|
}
|
|
});
|
|
},
|
|
submit: function () {
|
|
return this.fire('submit', { data: this.toJSON() });
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
self._super();
|
|
self.fromJSON(self.settings.data);
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self._super();
|
|
function recalcLabels() {
|
|
var maxLabelWidth = 0;
|
|
var labels = [];
|
|
var i, labelGap, items;
|
|
if (self.settings.labelGapCalc === false) {
|
|
return;
|
|
}
|
|
if (self.settings.labelGapCalc === 'children') {
|
|
items = self.find('formitem');
|
|
} else {
|
|
items = self.items();
|
|
}
|
|
items.filter('formitem').each(function (item) {
|
|
var labelCtrl = item.items()[0], labelWidth = labelCtrl.getEl().clientWidth;
|
|
maxLabelWidth = labelWidth > maxLabelWidth ? labelWidth : maxLabelWidth;
|
|
labels.push(labelCtrl);
|
|
});
|
|
labelGap = self.settings.labelGap || 0;
|
|
i = labels.length;
|
|
while (i--) {
|
|
labels[i].settings.minWidth = maxLabelWidth + labelGap;
|
|
}
|
|
}
|
|
self.on('show', recalcLabels);
|
|
recalcLabels();
|
|
}
|
|
});
|
|
|
|
var FieldSet = Form.extend({
|
|
Defaults: {
|
|
containerCls: 'fieldset',
|
|
layout: 'flex',
|
|
direction: 'column',
|
|
align: 'stretch',
|
|
flex: 1,
|
|
padding: '25 15 5 15',
|
|
labelGap: 30,
|
|
spacing: 10,
|
|
border: 1
|
|
},
|
|
renderHtml: function () {
|
|
var self = this, layout = self._layout, prefix = self.classPrefix;
|
|
self.preRender();
|
|
layout.preRender(self);
|
|
return '<fieldset id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + (self.settings.title ? '<legend id="' + self._id + '-title" class="' + prefix + 'fieldset-title">' + self.settings.title + '</legend>' : '') + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</fieldset>';
|
|
}
|
|
});
|
|
|
|
var unique$1 = 0;
|
|
var generate = function (prefix) {
|
|
var date = new Date();
|
|
var time = date.getTime();
|
|
var random = Math.floor(Math.random() * 1000000000);
|
|
unique$1++;
|
|
return prefix + '_' + random + unique$1 + String(time);
|
|
};
|
|
|
|
var fromHtml = function (html, scope) {
|
|
var doc = scope || document;
|
|
var div = doc.createElement('div');
|
|
div.innerHTML = html;
|
|
if (!div.hasChildNodes() || div.childNodes.length > 1) {
|
|
console.error('HTML does not have a single root node', html);
|
|
throw 'HTML must have a single root node';
|
|
}
|
|
return fromDom(div.childNodes[0]);
|
|
};
|
|
var fromTag = function (tag, scope) {
|
|
var doc = scope || document;
|
|
var node = doc.createElement(tag);
|
|
return fromDom(node);
|
|
};
|
|
var fromText = function (text, scope) {
|
|
var doc = scope || document;
|
|
var node = doc.createTextNode(text);
|
|
return fromDom(node);
|
|
};
|
|
var fromDom = function (node) {
|
|
if (node === null || node === undefined)
|
|
throw new Error('Node cannot be null or undefined');
|
|
return { dom: constant(node) };
|
|
};
|
|
var fromPoint = function (docElm, x, y) {
|
|
var doc = docElm.dom();
|
|
return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
|
|
};
|
|
var Element$$1 = {
|
|
fromHtml: fromHtml,
|
|
fromTag: fromTag,
|
|
fromText: fromText,
|
|
fromDom: fromDom,
|
|
fromPoint: fromPoint
|
|
};
|
|
|
|
var cached = function (f) {
|
|
var called = false;
|
|
var r;
|
|
return function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
if (!called) {
|
|
called = true;
|
|
r = f.apply(null, args);
|
|
}
|
|
return r;
|
|
};
|
|
};
|
|
|
|
var $_2jrgnk1apjjgwek8y = {
|
|
ATTRIBUTE: Node.ATTRIBUTE_NODE,
|
|
CDATA_SECTION: Node.CDATA_SECTION_NODE,
|
|
COMMENT: Node.COMMENT_NODE,
|
|
DOCUMENT: Node.DOCUMENT_NODE,
|
|
DOCUMENT_TYPE: Node.DOCUMENT_TYPE_NODE,
|
|
DOCUMENT_FRAGMENT: Node.DOCUMENT_FRAGMENT_NODE,
|
|
ELEMENT: Node.ELEMENT_NODE,
|
|
TEXT: Node.TEXT_NODE,
|
|
PROCESSING_INSTRUCTION: Node.PROCESSING_INSTRUCTION_NODE,
|
|
ENTITY_REFERENCE: Node.ENTITY_REFERENCE_NODE,
|
|
ENTITY: Node.ENTITY_NODE,
|
|
NOTATION: Node.NOTATION_NODE
|
|
};
|
|
|
|
var name = function (element) {
|
|
var r = element.dom().nodeName;
|
|
return r.toLowerCase();
|
|
};
|
|
var type = function (element) {
|
|
return element.dom().nodeType;
|
|
};
|
|
var value = function (element) {
|
|
return element.dom().nodeValue;
|
|
};
|
|
var isType$2 = function (t) {
|
|
return function (element) {
|
|
return type(element) === t;
|
|
};
|
|
};
|
|
var isComment = function (element) {
|
|
return type(element) === $_2jrgnk1apjjgwek8y.COMMENT || name(element) === '#comment';
|
|
};
|
|
var isElement = isType$2($_2jrgnk1apjjgwek8y.ELEMENT);
|
|
var isText = isType$2($_2jrgnk1apjjgwek8y.TEXT);
|
|
var isDocument = isType$2($_2jrgnk1apjjgwek8y.DOCUMENT);
|
|
var $_fv3as1aojjgwek8x = {
|
|
name: name,
|
|
type: type,
|
|
value: value,
|
|
isElement: isElement,
|
|
isText: isText,
|
|
isDocument: isDocument,
|
|
isComment: isComment
|
|
};
|
|
|
|
var inBody = function (element) {
|
|
var dom = $_fv3as1aojjgwek8x.isText(element) ? element.dom().parentNode : element.dom();
|
|
return dom !== undefined && dom !== null && dom.ownerDocument.body.contains(dom);
|
|
};
|
|
var body = cached(function () {
|
|
return getBody(Element$$1.fromDom(document));
|
|
});
|
|
var getBody = function (doc) {
|
|
var body = doc.dom().body;
|
|
if (body === null || body === undefined)
|
|
throw 'Body is not available yet';
|
|
return Element$$1.fromDom(body);
|
|
};
|
|
var $_d2glpe1amjjgwek8t = {
|
|
body: body,
|
|
getBody: getBody,
|
|
inBody: inBody
|
|
};
|
|
|
|
var Immutable = function () {
|
|
var fields = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
fields[_i] = arguments[_i];
|
|
}
|
|
return function () {
|
|
var values = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
values[_i] = arguments[_i];
|
|
}
|
|
if (fields.length !== values.length) {
|
|
throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
|
|
}
|
|
var struct = {};
|
|
each(fields, function (name, i) {
|
|
struct[name] = constant(values[i]);
|
|
});
|
|
return struct;
|
|
};
|
|
};
|
|
|
|
var toArray = function (target, f) {
|
|
var r = [];
|
|
var recurse = function (e) {
|
|
r.push(e);
|
|
return f(e);
|
|
};
|
|
var cur = f(target);
|
|
do {
|
|
cur = cur.bind(recurse);
|
|
} while (cur.isSome());
|
|
return r;
|
|
};
|
|
var $_607sf01awjjgweka0 = { toArray: toArray };
|
|
|
|
var node = function () {
|
|
var f = $_8wnjhx19gjjgwek54.getOrDie('Node');
|
|
return f;
|
|
};
|
|
var compareDocumentPosition = function (a, b, match) {
|
|
return (a.compareDocumentPosition(b) & match) !== 0;
|
|
};
|
|
var documentPositionPreceding = function (a, b) {
|
|
return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
|
|
};
|
|
var documentPositionContainedBy = function (a, b) {
|
|
return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
|
|
};
|
|
var $_d0o64o1ayjjgwekaa = {
|
|
documentPositionPreceding: documentPositionPreceding,
|
|
documentPositionContainedBy: documentPositionContainedBy
|
|
};
|
|
|
|
var firstMatch = function (regexes, s) {
|
|
for (var i = 0; i < regexes.length; i++) {
|
|
var x = regexes[i];
|
|
if (x.test(s))
|
|
return x;
|
|
}
|
|
return undefined;
|
|
};
|
|
var find$2 = function (regexes, agent) {
|
|
var r = firstMatch(regexes, agent);
|
|
if (!r)
|
|
return {
|
|
major: 0,
|
|
minor: 0
|
|
};
|
|
var group = function (i) {
|
|
return Number(agent.replace(r, '$' + i));
|
|
};
|
|
return nu(group(1), group(2));
|
|
};
|
|
var detect = function (versionRegexes, agent) {
|
|
var cleanedAgent = String(agent).toLowerCase();
|
|
if (versionRegexes.length === 0)
|
|
return unknown();
|
|
return find$2(versionRegexes, cleanedAgent);
|
|
};
|
|
var unknown = function () {
|
|
return nu(0, 0);
|
|
};
|
|
var nu = function (major, minor) {
|
|
return {
|
|
major: major,
|
|
minor: minor
|
|
};
|
|
};
|
|
var $_bhlk9t1b2jjgwekaq = {
|
|
nu: nu,
|
|
detect: detect,
|
|
unknown: unknown
|
|
};
|
|
|
|
var edge = 'Edge';
|
|
var chrome = 'Chrome';
|
|
var ie = 'IE';
|
|
var opera = 'Opera';
|
|
var firefox = 'Firefox';
|
|
var safari = 'Safari';
|
|
var isBrowser = function (name, current) {
|
|
return function () {
|
|
return current === name;
|
|
};
|
|
};
|
|
var unknown$1 = function () {
|
|
return nu$1({
|
|
current: undefined,
|
|
version: $_bhlk9t1b2jjgwekaq.unknown()
|
|
});
|
|
};
|
|
var nu$1 = function (info) {
|
|
var current = info.current;
|
|
var version = info.version;
|
|
return {
|
|
current: current,
|
|
version: version,
|
|
isEdge: isBrowser(edge, current),
|
|
isChrome: isBrowser(chrome, current),
|
|
isIE: isBrowser(ie, current),
|
|
isOpera: isBrowser(opera, current),
|
|
isFirefox: isBrowser(firefox, current),
|
|
isSafari: isBrowser(safari, current)
|
|
};
|
|
};
|
|
var $_3j4jht1b1jjgwekal = {
|
|
unknown: unknown$1,
|
|
nu: nu$1,
|
|
edge: constant(edge),
|
|
chrome: constant(chrome),
|
|
ie: constant(ie),
|
|
opera: constant(opera),
|
|
firefox: constant(firefox),
|
|
safari: constant(safari)
|
|
};
|
|
|
|
var windows$1 = 'Windows';
|
|
var ios = 'iOS';
|
|
var android = 'Android';
|
|
var linux = 'Linux';
|
|
var osx = 'OSX';
|
|
var solaris = 'Solaris';
|
|
var freebsd = 'FreeBSD';
|
|
var isOS = function (name, current) {
|
|
return function () {
|
|
return current === name;
|
|
};
|
|
};
|
|
var unknown$2 = function () {
|
|
return nu$2({
|
|
current: undefined,
|
|
version: $_bhlk9t1b2jjgwekaq.unknown()
|
|
});
|
|
};
|
|
var nu$2 = function (info) {
|
|
var current = info.current;
|
|
var version = info.version;
|
|
return {
|
|
current: current,
|
|
version: version,
|
|
isWindows: isOS(windows$1, current),
|
|
isiOS: isOS(ios, current),
|
|
isAndroid: isOS(android, current),
|
|
isOSX: isOS(osx, current),
|
|
isLinux: isOS(linux, current),
|
|
isSolaris: isOS(solaris, current),
|
|
isFreeBSD: isOS(freebsd, current)
|
|
};
|
|
};
|
|
var $_7je60a1b3jjgwekar = {
|
|
unknown: unknown$2,
|
|
nu: nu$2,
|
|
windows: constant(windows$1),
|
|
ios: constant(ios),
|
|
android: constant(android),
|
|
linux: constant(linux),
|
|
osx: constant(osx),
|
|
solaris: constant(solaris),
|
|
freebsd: constant(freebsd)
|
|
};
|
|
|
|
function DeviceType (os, browser, userAgent) {
|
|
var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
|
|
var isiPhone = os.isiOS() && !isiPad;
|
|
var isAndroid3 = os.isAndroid() && os.version.major === 3;
|
|
var isAndroid4 = os.isAndroid() && os.version.major === 4;
|
|
var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
|
|
var isTouch = os.isiOS() || os.isAndroid();
|
|
var isPhone = isTouch && !isTablet;
|
|
var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
|
|
return {
|
|
isiPad: constant(isiPad),
|
|
isiPhone: constant(isiPhone),
|
|
isTablet: constant(isTablet),
|
|
isPhone: constant(isPhone),
|
|
isTouch: constant(isTouch),
|
|
isAndroid: os.isAndroid,
|
|
isiOS: os.isiOS,
|
|
isWebView: constant(iOSwebview)
|
|
};
|
|
}
|
|
|
|
var detect$1 = function (candidates, userAgent) {
|
|
var agent = String(userAgent).toLowerCase();
|
|
return find(candidates, function (candidate) {
|
|
return candidate.search(agent);
|
|
});
|
|
};
|
|
var detectBrowser = function (browsers, userAgent) {
|
|
return detect$1(browsers, userAgent).map(function (browser) {
|
|
var version = $_bhlk9t1b2jjgwekaq.detect(browser.versionRegexes, userAgent);
|
|
return {
|
|
current: browser.name,
|
|
version: version
|
|
};
|
|
});
|
|
};
|
|
var detectOs = function (oses, userAgent) {
|
|
return detect$1(oses, userAgent).map(function (os) {
|
|
var version = $_bhlk9t1b2jjgwekaq.detect(os.versionRegexes, userAgent);
|
|
return {
|
|
current: os.name,
|
|
version: version
|
|
};
|
|
});
|
|
};
|
|
var $_1uo66k1b5jjgwekb9 = {
|
|
detectBrowser: detectBrowser,
|
|
detectOs: detectOs
|
|
};
|
|
|
|
var contains$1 = function (str, substr) {
|
|
return str.indexOf(substr) !== -1;
|
|
};
|
|
|
|
var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
|
|
var checkContains = function (target) {
|
|
return function (uastring) {
|
|
return contains$1(uastring, target);
|
|
};
|
|
};
|
|
var browsers = [
|
|
{
|
|
name: 'Edge',
|
|
versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
|
|
search: function (uastring) {
|
|
var monstrosity = contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
|
|
return monstrosity;
|
|
}
|
|
},
|
|
{
|
|
name: 'Chrome',
|
|
versionRegexes: [
|
|
/.*?chrome\/([0-9]+)\.([0-9]+).*/,
|
|
normalVersionRegex
|
|
],
|
|
search: function (uastring) {
|
|
return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
|
|
}
|
|
},
|
|
{
|
|
name: 'IE',
|
|
versionRegexes: [
|
|
/.*?msie\ ?([0-9]+)\.([0-9]+).*/,
|
|
/.*?rv:([0-9]+)\.([0-9]+).*/
|
|
],
|
|
search: function (uastring) {
|
|
return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
|
|
}
|
|
},
|
|
{
|
|
name: 'Opera',
|
|
versionRegexes: [
|
|
normalVersionRegex,
|
|
/.*?opera\/([0-9]+)\.([0-9]+).*/
|
|
],
|
|
search: checkContains('opera')
|
|
},
|
|
{
|
|
name: 'Firefox',
|
|
versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
|
|
search: checkContains('firefox')
|
|
},
|
|
{
|
|
name: 'Safari',
|
|
versionRegexes: [
|
|
normalVersionRegex,
|
|
/.*?cpu os ([0-9]+)_([0-9]+).*/
|
|
],
|
|
search: function (uastring) {
|
|
return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
|
|
}
|
|
}
|
|
];
|
|
var oses = [
|
|
{
|
|
name: 'Windows',
|
|
search: checkContains('win'),
|
|
versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
|
|
},
|
|
{
|
|
name: 'iOS',
|
|
search: function (uastring) {
|
|
return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
|
|
},
|
|
versionRegexes: [
|
|
/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
|
|
/.*cpu os ([0-9]+)_([0-9]+).*/,
|
|
/.*cpu iphone os ([0-9]+)_([0-9]+).*/
|
|
]
|
|
},
|
|
{
|
|
name: 'Android',
|
|
search: checkContains('android'),
|
|
versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
|
|
},
|
|
{
|
|
name: 'OSX',
|
|
search: checkContains('os x'),
|
|
versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
|
|
},
|
|
{
|
|
name: 'Linux',
|
|
search: checkContains('linux'),
|
|
versionRegexes: []
|
|
},
|
|
{
|
|
name: 'Solaris',
|
|
search: checkContains('sunos'),
|
|
versionRegexes: []
|
|
},
|
|
{
|
|
name: 'FreeBSD',
|
|
search: checkContains('freebsd'),
|
|
versionRegexes: []
|
|
}
|
|
];
|
|
var $_4f7v971b6jjgwekbd = {
|
|
browsers: constant(browsers),
|
|
oses: constant(oses)
|
|
};
|
|
|
|
var detect$2 = function (userAgent) {
|
|
var browsers = $_4f7v971b6jjgwekbd.browsers();
|
|
var oses = $_4f7v971b6jjgwekbd.oses();
|
|
var browser = $_1uo66k1b5jjgwekb9.detectBrowser(browsers, userAgent).fold($_3j4jht1b1jjgwekal.unknown, $_3j4jht1b1jjgwekal.nu);
|
|
var os = $_1uo66k1b5jjgwekb9.detectOs(oses, userAgent).fold($_7je60a1b3jjgwekar.unknown, $_7je60a1b3jjgwekar.nu);
|
|
var deviceType = DeviceType(os, browser, userAgent);
|
|
return {
|
|
browser: browser,
|
|
os: os,
|
|
deviceType: deviceType
|
|
};
|
|
};
|
|
var $_d71emz1b0jjgwekak = { detect: detect$2 };
|
|
|
|
var detect$3 = cached(function () {
|
|
var userAgent = navigator.userAgent;
|
|
return $_d71emz1b0jjgwekak.detect(userAgent);
|
|
});
|
|
var $_9xrxmy1azjjgwekac = { detect: detect$3 };
|
|
|
|
var ELEMENT = $_2jrgnk1apjjgwek8y.ELEMENT;
|
|
var DOCUMENT = $_2jrgnk1apjjgwek8y.DOCUMENT;
|
|
var is = function (element, selector) {
|
|
var elem = element.dom();
|
|
if (elem.nodeType !== ELEMENT)
|
|
return false;
|
|
else if (elem.matches !== undefined)
|
|
return elem.matches(selector);
|
|
else if (elem.msMatchesSelector !== undefined)
|
|
return elem.msMatchesSelector(selector);
|
|
else if (elem.webkitMatchesSelector !== undefined)
|
|
return elem.webkitMatchesSelector(selector);
|
|
else if (elem.mozMatchesSelector !== undefined)
|
|
return elem.mozMatchesSelector(selector);
|
|
else
|
|
throw new Error('Browser lacks native selectors');
|
|
};
|
|
var bypassSelector = function (dom) {
|
|
return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT || dom.childElementCount === 0;
|
|
};
|
|
var all = function (selector, scope) {
|
|
var base = scope === undefined ? document : scope.dom();
|
|
return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), Element$$1.fromDom);
|
|
};
|
|
var one = function (selector, scope) {
|
|
var base = scope === undefined ? document : scope.dom();
|
|
return bypassSelector(base) ? Option.none() : Option.from(base.querySelector(selector)).map(Element$$1.fromDom);
|
|
};
|
|
var $_e63uk51bajjgwekbq = {
|
|
all: all,
|
|
is: is,
|
|
one: one
|
|
};
|
|
|
|
var eq = function (e1, e2) {
|
|
return e1.dom() === e2.dom();
|
|
};
|
|
var isEqualNode = function (e1, e2) {
|
|
return e1.dom().isEqualNode(e2.dom());
|
|
};
|
|
var member = function (element, elements) {
|
|
return exists(elements, curry(eq, element));
|
|
};
|
|
var regularContains = function (e1, e2) {
|
|
var d1 = e1.dom(), d2 = e2.dom();
|
|
return d1 === d2 ? false : d1.contains(d2);
|
|
};
|
|
var ieContains = function (e1, e2) {
|
|
return $_d0o64o1ayjjgwekaa.documentPositionContainedBy(e1.dom(), e2.dom());
|
|
};
|
|
var browser = $_9xrxmy1azjjgwekac.detect().browser;
|
|
var contains$2 = browser.isIE() ? ieContains : regularContains;
|
|
var $_36s5ie1axjjgweka1 = {
|
|
eq: eq,
|
|
isEqualNode: isEqualNode,
|
|
member: member,
|
|
contains: contains$2,
|
|
is: $_e63uk51bajjgwekbq.is
|
|
};
|
|
|
|
var owner = function (element) {
|
|
return Element$$1.fromDom(element.dom().ownerDocument);
|
|
};
|
|
var documentElement = function (element) {
|
|
return Element$$1.fromDom(element.dom().ownerDocument.documentElement);
|
|
};
|
|
var defaultView = function (element) {
|
|
var el = element.dom();
|
|
var defaultView = el.ownerDocument.defaultView;
|
|
return Element$$1.fromDom(defaultView);
|
|
};
|
|
var parent$1 = function (element) {
|
|
var dom = element.dom();
|
|
return Option.from(dom.parentNode).map(Element$$1.fromDom);
|
|
};
|
|
var findIndex$1 = function (element) {
|
|
return parent$1(element).bind(function (p) {
|
|
var kin = children(p);
|
|
return findIndex(kin, function (elem) {
|
|
return $_36s5ie1axjjgweka1.eq(element, elem);
|
|
});
|
|
});
|
|
};
|
|
var parents = function (element, isRoot) {
|
|
var stop = isFunction$1(isRoot) ? isRoot : constant(false);
|
|
var dom = element.dom();
|
|
var ret = [];
|
|
while (dom.parentNode !== null && dom.parentNode !== undefined) {
|
|
var rawParent = dom.parentNode;
|
|
var parent = Element$$1.fromDom(rawParent);
|
|
ret.push(parent);
|
|
if (stop(parent) === true)
|
|
break;
|
|
else
|
|
dom = rawParent;
|
|
}
|
|
return ret;
|
|
};
|
|
var siblings = function (element) {
|
|
var filterSelf = function (elements) {
|
|
return filter(elements, function (x) {
|
|
return !$_36s5ie1axjjgweka1.eq(element, x);
|
|
});
|
|
};
|
|
return parent$1(element).map(children).map(filterSelf).getOr([]);
|
|
};
|
|
var offsetParent = function (element) {
|
|
var dom = element.dom();
|
|
return Option.from(dom.offsetParent).map(Element$$1.fromDom);
|
|
};
|
|
var prevSibling = function (element) {
|
|
var dom = element.dom();
|
|
return Option.from(dom.previousSibling).map(Element$$1.fromDom);
|
|
};
|
|
var nextSibling = function (element) {
|
|
var dom = element.dom();
|
|
return Option.from(dom.nextSibling).map(Element$$1.fromDom);
|
|
};
|
|
var prevSiblings = function (element) {
|
|
return reverse($_607sf01awjjgweka0.toArray(element, prevSibling));
|
|
};
|
|
var nextSiblings = function (element) {
|
|
return $_607sf01awjjgweka0.toArray(element, nextSibling);
|
|
};
|
|
var children = function (element) {
|
|
var dom = element.dom();
|
|
return map(dom.childNodes, Element$$1.fromDom);
|
|
};
|
|
var child = function (element, index) {
|
|
var children = element.dom().childNodes;
|
|
return Option.from(children[index]).map(Element$$1.fromDom);
|
|
};
|
|
var firstChild = function (element) {
|
|
return child(element, 0);
|
|
};
|
|
var lastChild = function (element) {
|
|
return child(element, element.dom().childNodes.length - 1);
|
|
};
|
|
var childNodesCount = function (element) {
|
|
return element.dom().childNodes.length;
|
|
};
|
|
var hasChildNodes = function (element) {
|
|
return element.dom().hasChildNodes();
|
|
};
|
|
var spot = Immutable('element', 'offset');
|
|
var leaf = function (element, offset) {
|
|
var cs = children(element);
|
|
return cs.length > 0 && offset < cs.length ? spot(cs[offset], 0) : spot(element, offset);
|
|
};
|
|
var $_fk3hdw1aqjjgwek91 = {
|
|
owner: owner,
|
|
defaultView: defaultView,
|
|
documentElement: documentElement,
|
|
parent: parent$1,
|
|
findIndex: findIndex$1,
|
|
parents: parents,
|
|
siblings: siblings,
|
|
prevSibling: prevSibling,
|
|
offsetParent: offsetParent,
|
|
prevSiblings: prevSiblings,
|
|
nextSibling: nextSibling,
|
|
nextSiblings: nextSiblings,
|
|
children: children,
|
|
child: child,
|
|
firstChild: firstChild,
|
|
lastChild: lastChild,
|
|
childNodesCount: childNodesCount,
|
|
hasChildNodes: hasChildNodes,
|
|
leaf: leaf
|
|
};
|
|
|
|
var all$1 = function (predicate) {
|
|
return descendants($_d2glpe1amjjgwek8t.body(), predicate);
|
|
};
|
|
var ancestors = function (scope, predicate, isRoot) {
|
|
return filter($_fk3hdw1aqjjgwek91.parents(scope, isRoot), predicate);
|
|
};
|
|
var siblings$1 = function (scope, predicate) {
|
|
return filter($_fk3hdw1aqjjgwek91.siblings(scope), predicate);
|
|
};
|
|
var children$1 = function (scope, predicate) {
|
|
return filter($_fk3hdw1aqjjgwek91.children(scope), predicate);
|
|
};
|
|
var descendants = function (scope, predicate) {
|
|
var result = [];
|
|
each($_fk3hdw1aqjjgwek91.children(scope), function (x) {
|
|
if (predicate(x)) {
|
|
result = result.concat([x]);
|
|
}
|
|
result = result.concat(descendants(x, predicate));
|
|
});
|
|
return result;
|
|
};
|
|
var $_4re57m1aljjgwek8p = {
|
|
all: all$1,
|
|
ancestors: ancestors,
|
|
siblings: siblings$1,
|
|
children: children$1,
|
|
descendants: descendants
|
|
};
|
|
|
|
var all$2 = function (selector) {
|
|
return $_e63uk51bajjgwekbq.all(selector);
|
|
};
|
|
var ancestors$1 = function (scope, selector, isRoot) {
|
|
return $_4re57m1aljjgwek8p.ancestors(scope, function (e) {
|
|
return $_e63uk51bajjgwekbq.is(e, selector);
|
|
}, isRoot);
|
|
};
|
|
var siblings$2 = function (scope, selector) {
|
|
return $_4re57m1aljjgwek8p.siblings(scope, function (e) {
|
|
return $_e63uk51bajjgwekbq.is(e, selector);
|
|
});
|
|
};
|
|
var children$2 = function (scope, selector) {
|
|
return $_4re57m1aljjgwek8p.children(scope, function (e) {
|
|
return $_e63uk51bajjgwekbq.is(e, selector);
|
|
});
|
|
};
|
|
var descendants$1 = function (scope, selector) {
|
|
return $_e63uk51bajjgwekbq.all(selector, scope);
|
|
};
|
|
var $_1jc9su1akjjgwek8o = {
|
|
all: all$2,
|
|
ancestors: ancestors$1,
|
|
siblings: siblings$2,
|
|
children: children$2,
|
|
descendants: descendants$1
|
|
};
|
|
|
|
var trim$1 = global$4.trim;
|
|
var hasContentEditableState = function (value) {
|
|
return function (node) {
|
|
if (node && node.nodeType === 1) {
|
|
if (node.contentEditable === value) {
|
|
return true;
|
|
}
|
|
if (node.getAttribute('data-mce-contenteditable') === value) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
};
|
|
var isContentEditableTrue = hasContentEditableState('true');
|
|
var isContentEditableFalse = hasContentEditableState('false');
|
|
var create$4 = function (type, title, url, level, attach) {
|
|
return {
|
|
type: type,
|
|
title: title,
|
|
url: url,
|
|
level: level,
|
|
attach: attach
|
|
};
|
|
};
|
|
var isChildOfContentEditableTrue = function (node) {
|
|
while (node = node.parentNode) {
|
|
var value = node.contentEditable;
|
|
if (value && value !== 'inherit') {
|
|
return isContentEditableTrue(node);
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
var select = function (selector, root) {
|
|
return map($_1jc9su1akjjgwek8o.descendants(Element$$1.fromDom(root), selector), function (element) {
|
|
return element.dom();
|
|
});
|
|
};
|
|
var getElementText = function (elm) {
|
|
return elm.innerText || elm.textContent;
|
|
};
|
|
var getOrGenerateId = function (elm) {
|
|
return elm.id ? elm.id : generate('h');
|
|
};
|
|
var isAnchor = function (elm) {
|
|
return elm && elm.nodeName === 'A' && (elm.id || elm.name);
|
|
};
|
|
var isValidAnchor = function (elm) {
|
|
return isAnchor(elm) && isEditable(elm);
|
|
};
|
|
var isHeader = function (elm) {
|
|
return elm && /^(H[1-6])$/.test(elm.nodeName);
|
|
};
|
|
var isEditable = function (elm) {
|
|
return isChildOfContentEditableTrue(elm) && !isContentEditableFalse(elm);
|
|
};
|
|
var isValidHeader = function (elm) {
|
|
return isHeader(elm) && isEditable(elm);
|
|
};
|
|
var getLevel = function (elm) {
|
|
return isHeader(elm) ? parseInt(elm.nodeName.substr(1), 10) : 0;
|
|
};
|
|
var headerTarget = function (elm) {
|
|
var headerId = getOrGenerateId(elm);
|
|
var attach = function () {
|
|
elm.id = headerId;
|
|
};
|
|
return create$4('header', getElementText(elm), '#' + headerId, getLevel(elm), attach);
|
|
};
|
|
var anchorTarget = function (elm) {
|
|
var anchorId = elm.id || elm.name;
|
|
var anchorText = getElementText(elm);
|
|
return create$4('anchor', anchorText ? anchorText : '#' + anchorId, '#' + anchorId, 0, noop);
|
|
};
|
|
var getHeaderTargets = function (elms) {
|
|
return map(filter(elms, isValidHeader), headerTarget);
|
|
};
|
|
var getAnchorTargets = function (elms) {
|
|
return map(filter(elms, isValidAnchor), anchorTarget);
|
|
};
|
|
var getTargetElements = function (elm) {
|
|
var elms = select('h1,h2,h3,h4,h5,h6,a:not([href])', elm);
|
|
return elms;
|
|
};
|
|
var hasTitle = function (target) {
|
|
return trim$1(target.title).length > 0;
|
|
};
|
|
var find$3 = function (elm) {
|
|
var elms = getTargetElements(elm);
|
|
return filter(getHeaderTargets(elms).concat(getAnchorTargets(elms)), hasTitle);
|
|
};
|
|
var $_5ia43q1ahjjgwek7u = { find: find$3 };
|
|
|
|
var getActiveEditor = function () {
|
|
return window.tinymce ? window.tinymce.activeEditor : global$5.activeEditor;
|
|
};
|
|
var history = {};
|
|
var HISTORY_LENGTH = 5;
|
|
var clearHistory = function () {
|
|
history = {};
|
|
};
|
|
var toMenuItem = function (target) {
|
|
return {
|
|
title: target.title,
|
|
value: {
|
|
title: { raw: target.title },
|
|
url: target.url,
|
|
attach: target.attach
|
|
}
|
|
};
|
|
};
|
|
var toMenuItems = function (targets) {
|
|
return global$4.map(targets, toMenuItem);
|
|
};
|
|
var staticMenuItem = function (title, url) {
|
|
return {
|
|
title: title,
|
|
value: {
|
|
title: title,
|
|
url: url,
|
|
attach: noop
|
|
}
|
|
};
|
|
};
|
|
var isUniqueUrl = function (url, targets) {
|
|
var foundTarget = exists(targets, function (target) {
|
|
return target.url === url;
|
|
});
|
|
return !foundTarget;
|
|
};
|
|
var getSetting = function (editorSettings, name, defaultValue) {
|
|
var value = name in editorSettings ? editorSettings[name] : defaultValue;
|
|
return value === false ? null : value;
|
|
};
|
|
var createMenuItems = function (term, targets, fileType, editorSettings) {
|
|
var separator = { title: '-' };
|
|
var fromHistoryMenuItems = function (history) {
|
|
var historyItems = history.hasOwnProperty(fileType) ? history[fileType] : [];
|
|
var uniqueHistory = filter(historyItems, function (url) {
|
|
return isUniqueUrl(url, targets);
|
|
});
|
|
return global$4.map(uniqueHistory, function (url) {
|
|
return {
|
|
title: url,
|
|
value: {
|
|
title: url,
|
|
url: url,
|
|
attach: noop
|
|
}
|
|
};
|
|
});
|
|
};
|
|
var fromMenuItems = function (type) {
|
|
var filteredTargets = filter(targets, function (target) {
|
|
return target.type === type;
|
|
});
|
|
return toMenuItems(filteredTargets);
|
|
};
|
|
var anchorMenuItems = function () {
|
|
var anchorMenuItems = fromMenuItems('anchor');
|
|
var topAnchor = getSetting(editorSettings, 'anchor_top', '#top');
|
|
var bottomAchor = getSetting(editorSettings, 'anchor_bottom', '#bottom');
|
|
if (topAnchor !== null) {
|
|
anchorMenuItems.unshift(staticMenuItem('<top>', topAnchor));
|
|
}
|
|
if (bottomAchor !== null) {
|
|
anchorMenuItems.push(staticMenuItem('<bottom>', bottomAchor));
|
|
}
|
|
return anchorMenuItems;
|
|
};
|
|
var join = function (items) {
|
|
return foldl(items, function (a, b) {
|
|
var bothEmpty = a.length === 0 || b.length === 0;
|
|
return bothEmpty ? a.concat(b) : a.concat(separator, b);
|
|
}, []);
|
|
};
|
|
if (editorSettings.typeahead_urls === false) {
|
|
return [];
|
|
}
|
|
return fileType === 'file' ? join([
|
|
filterByQuery(term, fromHistoryMenuItems(history)),
|
|
filterByQuery(term, fromMenuItems('header')),
|
|
filterByQuery(term, anchorMenuItems())
|
|
]) : filterByQuery(term, fromHistoryMenuItems(history));
|
|
};
|
|
var addToHistory = function (url, fileType) {
|
|
var items = history[fileType];
|
|
if (!/^https?/.test(url)) {
|
|
return;
|
|
}
|
|
if (items) {
|
|
if (indexOf(items, url).isNone()) {
|
|
history[fileType] = items.slice(0, HISTORY_LENGTH).concat(url);
|
|
}
|
|
} else {
|
|
history[fileType] = [url];
|
|
}
|
|
};
|
|
var filterByQuery = function (term, menuItems) {
|
|
var lowerCaseTerm = term.toLowerCase();
|
|
var result = global$4.grep(menuItems, function (item) {
|
|
return item.title.toLowerCase().indexOf(lowerCaseTerm) !== -1;
|
|
});
|
|
return result.length === 1 && result[0].title === term ? [] : result;
|
|
};
|
|
var getTitle = function (linkDetails) {
|
|
var title = linkDetails.title;
|
|
return title.raw ? title.raw : title;
|
|
};
|
|
var setupAutoCompleteHandler = function (ctrl, editorSettings, bodyElm, fileType) {
|
|
var autocomplete = function (term) {
|
|
var linkTargets = $_5ia43q1ahjjgwek7u.find(bodyElm);
|
|
var menuItems = createMenuItems(term, linkTargets, fileType, editorSettings);
|
|
ctrl.showAutoComplete(menuItems, term);
|
|
};
|
|
ctrl.on('autocomplete', function () {
|
|
autocomplete(ctrl.value());
|
|
});
|
|
ctrl.on('selectitem', function (e) {
|
|
var linkDetails = e.value;
|
|
ctrl.value(linkDetails.url);
|
|
var title = getTitle(linkDetails);
|
|
if (fileType === 'image') {
|
|
ctrl.fire('change', {
|
|
meta: {
|
|
alt: title,
|
|
attach: linkDetails.attach
|
|
}
|
|
});
|
|
} else {
|
|
ctrl.fire('change', {
|
|
meta: {
|
|
text: title,
|
|
attach: linkDetails.attach
|
|
}
|
|
});
|
|
}
|
|
ctrl.focus();
|
|
});
|
|
ctrl.on('click', function (e) {
|
|
if (ctrl.value().length === 0 && e.target.nodeName === 'INPUT') {
|
|
autocomplete('');
|
|
}
|
|
});
|
|
ctrl.on('PostRender', function () {
|
|
ctrl.getRoot().on('submit', function (e) {
|
|
if (!e.isDefaultPrevented()) {
|
|
addToHistory(ctrl.value(), fileType);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
var statusToUiState = function (result) {
|
|
var status = result.status, message = result.message;
|
|
if (status === 'valid') {
|
|
return {
|
|
status: 'ok',
|
|
message: message
|
|
};
|
|
} else if (status === 'unknown') {
|
|
return {
|
|
status: 'warn',
|
|
message: message
|
|
};
|
|
} else if (status === 'invalid') {
|
|
return {
|
|
status: 'warn',
|
|
message: message
|
|
};
|
|
} else {
|
|
return {
|
|
status: 'none',
|
|
message: ''
|
|
};
|
|
}
|
|
};
|
|
var setupLinkValidatorHandler = function (ctrl, editorSettings, fileType) {
|
|
var validatorHandler = editorSettings.filepicker_validator_handler;
|
|
if (validatorHandler) {
|
|
var validateUrl_1 = function (url) {
|
|
if (url.length === 0) {
|
|
ctrl.statusLevel('none');
|
|
return;
|
|
}
|
|
validatorHandler({
|
|
url: url,
|
|
type: fileType
|
|
}, function (result) {
|
|
var uiState = statusToUiState(result);
|
|
ctrl.statusMessage(uiState.message);
|
|
ctrl.statusLevel(uiState.status);
|
|
});
|
|
};
|
|
ctrl.state.on('change:value', function (e) {
|
|
validateUrl_1(e.value);
|
|
});
|
|
}
|
|
};
|
|
var FilePicker = ComboBox.extend({
|
|
Statics: { clearHistory: clearHistory },
|
|
init: function (settings) {
|
|
var self = this, editor = getActiveEditor(), editorSettings = editor.settings;
|
|
var actionCallback, fileBrowserCallback, fileBrowserCallbackTypes;
|
|
var fileType = settings.filetype;
|
|
settings.spellcheck = false;
|
|
fileBrowserCallbackTypes = editorSettings.file_picker_types || editorSettings.file_browser_callback_types;
|
|
if (fileBrowserCallbackTypes) {
|
|
fileBrowserCallbackTypes = global$4.makeMap(fileBrowserCallbackTypes, /[, ]/);
|
|
}
|
|
if (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType]) {
|
|
fileBrowserCallback = editorSettings.file_picker_callback;
|
|
if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
|
|
actionCallback = function () {
|
|
var meta = self.fire('beforecall').meta;
|
|
meta = global$4.extend({ filetype: fileType }, meta);
|
|
fileBrowserCallback.call(editor, function (value, meta) {
|
|
self.value(value).fire('change', { meta: meta });
|
|
}, self.value(), meta);
|
|
};
|
|
} else {
|
|
fileBrowserCallback = editorSettings.file_browser_callback;
|
|
if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
|
|
actionCallback = function () {
|
|
fileBrowserCallback(self.getEl('inp').id, self.value(), fileType, window);
|
|
};
|
|
}
|
|
}
|
|
}
|
|
if (actionCallback) {
|
|
settings.icon = 'browse';
|
|
settings.onaction = actionCallback;
|
|
}
|
|
self._super(settings);
|
|
self.classes.add('filepicker');
|
|
setupAutoCompleteHandler(self, editorSettings, editor.getBody(), fileType);
|
|
setupLinkValidatorHandler(self, editorSettings, fileType);
|
|
}
|
|
});
|
|
|
|
var FitLayout = AbsoluteLayout.extend({
|
|
recalc: function (container) {
|
|
var contLayoutRect = container.layoutRect(), paddingBox = container.paddingBox;
|
|
container.items().filter(':visible').each(function (ctrl) {
|
|
ctrl.layoutRect({
|
|
x: paddingBox.left,
|
|
y: paddingBox.top,
|
|
w: contLayoutRect.innerW - paddingBox.right - paddingBox.left,
|
|
h: contLayoutRect.innerH - paddingBox.top - paddingBox.bottom
|
|
});
|
|
if (ctrl.recalc) {
|
|
ctrl.recalc();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
var FlexLayout = AbsoluteLayout.extend({
|
|
recalc: function (container) {
|
|
var i, l, items, contLayoutRect, contPaddingBox, contSettings, align, pack, spacing, totalFlex, availableSpace, direction;
|
|
var ctrl, ctrlLayoutRect, ctrlSettings, flex;
|
|
var maxSizeItems = [];
|
|
var size, maxSize, ratio, rect, pos, maxAlignEndPos;
|
|
var sizeName, minSizeName, posName, maxSizeName, beforeName, innerSizeName, deltaSizeName, contentSizeName;
|
|
var alignAxisName, alignInnerSizeName, alignSizeName, alignMinSizeName, alignBeforeName, alignAfterName;
|
|
var alignDeltaSizeName, alignContentSizeName;
|
|
var max = Math.max, min = Math.min;
|
|
items = container.items().filter(':visible');
|
|
contLayoutRect = container.layoutRect();
|
|
contPaddingBox = container.paddingBox;
|
|
contSettings = container.settings;
|
|
direction = container.isRtl() ? contSettings.direction || 'row-reversed' : contSettings.direction;
|
|
align = contSettings.align;
|
|
pack = container.isRtl() ? contSettings.pack || 'end' : contSettings.pack;
|
|
spacing = contSettings.spacing || 0;
|
|
if (direction === 'row-reversed' || direction === 'column-reverse') {
|
|
items = items.set(items.toArray().reverse());
|
|
direction = direction.split('-')[0];
|
|
}
|
|
if (direction === 'column') {
|
|
posName = 'y';
|
|
sizeName = 'h';
|
|
minSizeName = 'minH';
|
|
maxSizeName = 'maxH';
|
|
innerSizeName = 'innerH';
|
|
beforeName = 'top';
|
|
deltaSizeName = 'deltaH';
|
|
contentSizeName = 'contentH';
|
|
alignBeforeName = 'left';
|
|
alignSizeName = 'w';
|
|
alignAxisName = 'x';
|
|
alignInnerSizeName = 'innerW';
|
|
alignMinSizeName = 'minW';
|
|
alignAfterName = 'right';
|
|
alignDeltaSizeName = 'deltaW';
|
|
alignContentSizeName = 'contentW';
|
|
} else {
|
|
posName = 'x';
|
|
sizeName = 'w';
|
|
minSizeName = 'minW';
|
|
maxSizeName = 'maxW';
|
|
innerSizeName = 'innerW';
|
|
beforeName = 'left';
|
|
deltaSizeName = 'deltaW';
|
|
contentSizeName = 'contentW';
|
|
alignBeforeName = 'top';
|
|
alignSizeName = 'h';
|
|
alignAxisName = 'y';
|
|
alignInnerSizeName = 'innerH';
|
|
alignMinSizeName = 'minH';
|
|
alignAfterName = 'bottom';
|
|
alignDeltaSizeName = 'deltaH';
|
|
alignContentSizeName = 'contentH';
|
|
}
|
|
availableSpace = contLayoutRect[innerSizeName] - contPaddingBox[beforeName] - contPaddingBox[beforeName];
|
|
maxAlignEndPos = totalFlex = 0;
|
|
for (i = 0, l = items.length; i < l; i++) {
|
|
ctrl = items[i];
|
|
ctrlLayoutRect = ctrl.layoutRect();
|
|
ctrlSettings = ctrl.settings;
|
|
flex = ctrlSettings.flex;
|
|
availableSpace -= i < l - 1 ? spacing : 0;
|
|
if (flex > 0) {
|
|
totalFlex += flex;
|
|
if (ctrlLayoutRect[maxSizeName]) {
|
|
maxSizeItems.push(ctrl);
|
|
}
|
|
ctrlLayoutRect.flex = flex;
|
|
}
|
|
availableSpace -= ctrlLayoutRect[minSizeName];
|
|
size = contPaddingBox[alignBeforeName] + ctrlLayoutRect[alignMinSizeName] + contPaddingBox[alignAfterName];
|
|
if (size > maxAlignEndPos) {
|
|
maxAlignEndPos = size;
|
|
}
|
|
}
|
|
rect = {};
|
|
if (availableSpace < 0) {
|
|
rect[minSizeName] = contLayoutRect[minSizeName] - availableSpace + contLayoutRect[deltaSizeName];
|
|
} else {
|
|
rect[minSizeName] = contLayoutRect[innerSizeName] - availableSpace + contLayoutRect[deltaSizeName];
|
|
}
|
|
rect[alignMinSizeName] = maxAlignEndPos + contLayoutRect[alignDeltaSizeName];
|
|
rect[contentSizeName] = contLayoutRect[innerSizeName] - availableSpace;
|
|
rect[alignContentSizeName] = maxAlignEndPos;
|
|
rect.minW = min(rect.minW, contLayoutRect.maxW);
|
|
rect.minH = min(rect.minH, contLayoutRect.maxH);
|
|
rect.minW = max(rect.minW, contLayoutRect.startMinWidth);
|
|
rect.minH = max(rect.minH, contLayoutRect.startMinHeight);
|
|
if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
|
|
rect.w = rect.minW;
|
|
rect.h = rect.minH;
|
|
container.layoutRect(rect);
|
|
this.recalc(container);
|
|
if (container._lastRect === null) {
|
|
var parentCtrl = container.parent();
|
|
if (parentCtrl) {
|
|
parentCtrl._lastRect = null;
|
|
parentCtrl.recalc();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
ratio = availableSpace / totalFlex;
|
|
for (i = 0, l = maxSizeItems.length; i < l; i++) {
|
|
ctrl = maxSizeItems[i];
|
|
ctrlLayoutRect = ctrl.layoutRect();
|
|
maxSize = ctrlLayoutRect[maxSizeName];
|
|
size = ctrlLayoutRect[minSizeName] + ctrlLayoutRect.flex * ratio;
|
|
if (size > maxSize) {
|
|
availableSpace -= ctrlLayoutRect[maxSizeName] - ctrlLayoutRect[minSizeName];
|
|
totalFlex -= ctrlLayoutRect.flex;
|
|
ctrlLayoutRect.flex = 0;
|
|
ctrlLayoutRect.maxFlexSize = maxSize;
|
|
} else {
|
|
ctrlLayoutRect.maxFlexSize = 0;
|
|
}
|
|
}
|
|
ratio = availableSpace / totalFlex;
|
|
pos = contPaddingBox[beforeName];
|
|
rect = {};
|
|
if (totalFlex === 0) {
|
|
if (pack === 'end') {
|
|
pos = availableSpace + contPaddingBox[beforeName];
|
|
} else if (pack === 'center') {
|
|
pos = Math.round(contLayoutRect[innerSizeName] / 2 - (contLayoutRect[innerSizeName] - availableSpace) / 2) + contPaddingBox[beforeName];
|
|
if (pos < 0) {
|
|
pos = contPaddingBox[beforeName];
|
|
}
|
|
} else if (pack === 'justify') {
|
|
pos = contPaddingBox[beforeName];
|
|
spacing = Math.floor(availableSpace / (items.length - 1));
|
|
}
|
|
}
|
|
rect[alignAxisName] = contPaddingBox[alignBeforeName];
|
|
for (i = 0, l = items.length; i < l; i++) {
|
|
ctrl = items[i];
|
|
ctrlLayoutRect = ctrl.layoutRect();
|
|
size = ctrlLayoutRect.maxFlexSize || ctrlLayoutRect[minSizeName];
|
|
if (align === 'center') {
|
|
rect[alignAxisName] = Math.round(contLayoutRect[alignInnerSizeName] / 2 - ctrlLayoutRect[alignSizeName] / 2);
|
|
} else if (align === 'stretch') {
|
|
rect[alignSizeName] = max(ctrlLayoutRect[alignMinSizeName] || 0, contLayoutRect[alignInnerSizeName] - contPaddingBox[alignBeforeName] - contPaddingBox[alignAfterName]);
|
|
rect[alignAxisName] = contPaddingBox[alignBeforeName];
|
|
} else if (align === 'end') {
|
|
rect[alignAxisName] = contLayoutRect[alignInnerSizeName] - ctrlLayoutRect[alignSizeName] - contPaddingBox.top;
|
|
}
|
|
if (ctrlLayoutRect.flex > 0) {
|
|
size += ctrlLayoutRect.flex * ratio;
|
|
}
|
|
rect[sizeName] = size;
|
|
rect[posName] = pos;
|
|
ctrl.layoutRect(rect);
|
|
if (ctrl.recalc) {
|
|
ctrl.recalc();
|
|
}
|
|
pos += size + spacing;
|
|
}
|
|
}
|
|
});
|
|
|
|
var FlowLayout = Layout$1.extend({
|
|
Defaults: {
|
|
containerClass: 'flow-layout',
|
|
controlClass: 'flow-layout-item',
|
|
endClass: 'break'
|
|
},
|
|
recalc: function (container) {
|
|
container.items().filter(':visible').each(function (ctrl) {
|
|
if (ctrl.recalc) {
|
|
ctrl.recalc();
|
|
}
|
|
});
|
|
},
|
|
isNative: function () {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
function ClosestOrAncestor (is, ancestor, scope, a, isRoot) {
|
|
return is(scope, a) ? Option.some(scope) : isFunction$1(isRoot) && isRoot(scope) ? Option.none() : ancestor(scope, a, isRoot);
|
|
}
|
|
|
|
var first$1 = function (predicate) {
|
|
return descendant($_d2glpe1amjjgwek8t.body(), predicate);
|
|
};
|
|
var ancestor = function (scope, predicate, isRoot) {
|
|
var element = scope.dom();
|
|
var stop = isFunction$1(isRoot) ? isRoot : constant(false);
|
|
while (element.parentNode) {
|
|
element = element.parentNode;
|
|
var el = Element$$1.fromDom(element);
|
|
if (predicate(el))
|
|
return Option.some(el);
|
|
else if (stop(el))
|
|
break;
|
|
}
|
|
return Option.none();
|
|
};
|
|
var closest = function (scope, predicate, isRoot) {
|
|
var is = function (scope) {
|
|
return predicate(scope);
|
|
};
|
|
return ClosestOrAncestor(is, ancestor, scope, predicate, isRoot);
|
|
};
|
|
var sibling = function (scope, predicate) {
|
|
var element = scope.dom();
|
|
if (!element.parentNode)
|
|
return Option.none();
|
|
return child$1(Element$$1.fromDom(element.parentNode), function (x) {
|
|
return !$_36s5ie1axjjgweka1.eq(scope, x) && predicate(x);
|
|
});
|
|
};
|
|
var child$1 = function (scope, predicate) {
|
|
var result = find(scope.dom().childNodes, compose(predicate, Element$$1.fromDom));
|
|
return result.map(Element$$1.fromDom);
|
|
};
|
|
var descendant = function (scope, predicate) {
|
|
var descend = function (node) {
|
|
for (var i = 0; i < node.childNodes.length; i++) {
|
|
if (predicate(Element$$1.fromDom(node.childNodes[i])))
|
|
return Option.some(Element$$1.fromDom(node.childNodes[i]));
|
|
var res = descend(node.childNodes[i]);
|
|
if (res.isSome())
|
|
return res;
|
|
}
|
|
return Option.none();
|
|
};
|
|
return descend(scope.dom());
|
|
};
|
|
var $_df9cwz1bgjjgwekcd = {
|
|
first: first$1,
|
|
ancestor: ancestor,
|
|
closest: closest,
|
|
sibling: sibling,
|
|
child: child$1,
|
|
descendant: descendant
|
|
};
|
|
|
|
var first$2 = function (selector) {
|
|
return $_e63uk51bajjgwekbq.one(selector);
|
|
};
|
|
var ancestor$1 = function (scope, selector, isRoot) {
|
|
return $_df9cwz1bgjjgwekcd.ancestor(scope, function (e) {
|
|
return $_e63uk51bajjgwekbq.is(e, selector);
|
|
}, isRoot);
|
|
};
|
|
var sibling$1 = function (scope, selector) {
|
|
return $_df9cwz1bgjjgwekcd.sibling(scope, function (e) {
|
|
return $_e63uk51bajjgwekbq.is(e, selector);
|
|
});
|
|
};
|
|
var child$2 = function (scope, selector) {
|
|
return $_df9cwz1bgjjgwekcd.child(scope, function (e) {
|
|
return $_e63uk51bajjgwekbq.is(e, selector);
|
|
});
|
|
};
|
|
var descendant$1 = function (scope, selector) {
|
|
return $_e63uk51bajjgwekbq.one(selector, scope);
|
|
};
|
|
var closest$1 = function (scope, selector, isRoot) {
|
|
return ClosestOrAncestor($_e63uk51bajjgwekbq.is, ancestor$1, scope, selector, isRoot);
|
|
};
|
|
var $_6nlstg1bfjjgwekcb = {
|
|
first: first$2,
|
|
ancestor: ancestor$1,
|
|
sibling: sibling$1,
|
|
child: child$2,
|
|
descendant: descendant$1,
|
|
closest: closest$1
|
|
};
|
|
|
|
var toggleFormat = function (editor, fmt) {
|
|
return function () {
|
|
editor.execCommand('mceToggleFormat', false, fmt);
|
|
};
|
|
};
|
|
var addFormatChangedListener = function (editor, name, changed) {
|
|
var handler = function (state) {
|
|
changed(state, name);
|
|
};
|
|
if (editor.formatter) {
|
|
editor.formatter.formatChanged(name, handler);
|
|
} else {
|
|
editor.on('init', function () {
|
|
editor.formatter.formatChanged(name, handler);
|
|
});
|
|
}
|
|
};
|
|
var postRenderFormatToggle = function (editor, name) {
|
|
return function (e) {
|
|
addFormatChangedListener(editor, name, function (state) {
|
|
e.control.active(state);
|
|
});
|
|
};
|
|
};
|
|
|
|
var register = function (editor) {
|
|
var alignFormats = [
|
|
'alignleft',
|
|
'aligncenter',
|
|
'alignright',
|
|
'alignjustify'
|
|
];
|
|
var defaultAlign = 'alignleft';
|
|
var alignMenuItems = [
|
|
{
|
|
text: 'Left',
|
|
icon: 'alignleft',
|
|
onclick: toggleFormat(editor, 'alignleft')
|
|
},
|
|
{
|
|
text: 'Center',
|
|
icon: 'aligncenter',
|
|
onclick: toggleFormat(editor, 'aligncenter')
|
|
},
|
|
{
|
|
text: 'Right',
|
|
icon: 'alignright',
|
|
onclick: toggleFormat(editor, 'alignright')
|
|
},
|
|
{
|
|
text: 'Justify',
|
|
icon: 'alignjustify',
|
|
onclick: toggleFormat(editor, 'alignjustify')
|
|
}
|
|
];
|
|
editor.addMenuItem('align', {
|
|
text: 'Align',
|
|
menu: alignMenuItems
|
|
});
|
|
editor.addButton('align', {
|
|
type: 'menubutton',
|
|
icon: defaultAlign,
|
|
menu: alignMenuItems,
|
|
onShowMenu: function (e) {
|
|
var menu = e.control.menu;
|
|
global$4.each(alignFormats, function (formatName, idx) {
|
|
menu.items().eq(idx).each(function (item) {
|
|
return item.active(editor.formatter.match(formatName));
|
|
});
|
|
});
|
|
},
|
|
onPostRender: function (e) {
|
|
var ctrl = e.control;
|
|
global$4.each(alignFormats, function (formatName, idx) {
|
|
addFormatChangedListener(editor, formatName, function (state) {
|
|
ctrl.icon(defaultAlign);
|
|
if (state) {
|
|
ctrl.icon(formatName);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
global$4.each({
|
|
alignleft: [
|
|
'Align left',
|
|
'JustifyLeft'
|
|
],
|
|
aligncenter: [
|
|
'Align center',
|
|
'JustifyCenter'
|
|
],
|
|
alignright: [
|
|
'Align right',
|
|
'JustifyRight'
|
|
],
|
|
alignjustify: [
|
|
'Justify',
|
|
'JustifyFull'
|
|
],
|
|
alignnone: [
|
|
'No alignment',
|
|
'JustifyNone'
|
|
]
|
|
}, function (item, name) {
|
|
editor.addButton(name, {
|
|
active: false,
|
|
tooltip: item[0],
|
|
cmd: item[1],
|
|
onPostRender: postRenderFormatToggle(editor, name)
|
|
});
|
|
});
|
|
};
|
|
var $_7uh4c31bijjgwekcw = { register: register };
|
|
|
|
var getFirstFont = function (fontFamily) {
|
|
return fontFamily ? fontFamily.split(',')[0] : '';
|
|
};
|
|
var findMatchingValue = function (items, fontFamily) {
|
|
var font = fontFamily ? fontFamily.toLowerCase() : '';
|
|
var value;
|
|
global$4.each(items, function (item) {
|
|
if (item.value.toLowerCase() === font) {
|
|
value = item.value;
|
|
}
|
|
});
|
|
global$4.each(items, function (item) {
|
|
if (!value && getFirstFont(item.value).toLowerCase() === getFirstFont(font).toLowerCase()) {
|
|
value = item.value;
|
|
}
|
|
});
|
|
return value;
|
|
};
|
|
var createFontNameListBoxChangeHandler = function (editor, items) {
|
|
return function () {
|
|
var self = this;
|
|
self.state.set('value', null);
|
|
editor.on('init nodeChange', function (e) {
|
|
var fontFamily = editor.queryCommandValue('FontName');
|
|
var match = findMatchingValue(items, fontFamily);
|
|
self.value(match ? match : null);
|
|
if (!match && fontFamily) {
|
|
self.text(getFirstFont(fontFamily));
|
|
}
|
|
});
|
|
};
|
|
};
|
|
var createFormats = function (formats) {
|
|
formats = formats.replace(/;$/, '').split(';');
|
|
var i = formats.length;
|
|
while (i--) {
|
|
formats[i] = formats[i].split('=');
|
|
}
|
|
return formats;
|
|
};
|
|
var getFontItems = function (editor) {
|
|
var defaultFontsFormats = 'Andale Mono=andale mono,monospace;' + 'Arial=arial,helvetica,sans-serif;' + 'Arial Black=arial black,sans-serif;' + 'Book Antiqua=book antiqua,palatino,serif;' + 'Comic Sans MS=comic sans ms,sans-serif;' + 'Courier New=courier new,courier,monospace;' + 'Georgia=georgia,palatino,serif;' + 'Helvetica=helvetica,arial,sans-serif;' + 'Impact=impact,sans-serif;' + 'Symbol=symbol;' + 'Tahoma=tahoma,arial,helvetica,sans-serif;' + 'Terminal=terminal,monaco,monospace;' + 'Times New Roman=times new roman,times,serif;' + 'Trebuchet MS=trebuchet ms,geneva,sans-serif;' + 'Verdana=verdana,geneva,sans-serif;' + 'Webdings=webdings;' + 'Wingdings=wingdings,zapf dingbats';
|
|
var fonts = createFormats(editor.settings.font_formats || defaultFontsFormats);
|
|
return global$4.map(fonts, function (font) {
|
|
return {
|
|
text: { raw: font[0] },
|
|
value: font[1],
|
|
textStyle: font[1].indexOf('dings') === -1 ? 'font-family:' + font[1] : ''
|
|
};
|
|
});
|
|
};
|
|
var registerButtons = function (editor) {
|
|
editor.addButton('fontselect', function () {
|
|
var items = getFontItems(editor);
|
|
return {
|
|
type: 'listbox',
|
|
text: 'Font Family',
|
|
tooltip: 'Font Family',
|
|
values: items,
|
|
fixedWidth: true,
|
|
onPostRender: createFontNameListBoxChangeHandler(editor, items),
|
|
onselect: function (e) {
|
|
if (e.control.settings.value) {
|
|
editor.execCommand('FontName', false, e.control.settings.value);
|
|
}
|
|
}
|
|
};
|
|
});
|
|
};
|
|
var register$1 = function (editor) {
|
|
registerButtons(editor);
|
|
};
|
|
var $_2g5ce1bkjjgwekcz = { register: register$1 };
|
|
|
|
var round = function (number, precision) {
|
|
var factor = Math.pow(10, precision);
|
|
return Math.round(number * factor) / factor;
|
|
};
|
|
var toPt = function (fontSize, precision) {
|
|
if (/[0-9.]+px$/.test(fontSize)) {
|
|
return round(parseInt(fontSize, 10) * 72 / 96, precision || 0) + 'pt';
|
|
}
|
|
return fontSize;
|
|
};
|
|
var findMatchingValue$1 = function (items, pt, px) {
|
|
var value;
|
|
global$4.each(items, function (item) {
|
|
if (item.value === px) {
|
|
value = px;
|
|
} else if (item.value === pt) {
|
|
value = pt;
|
|
}
|
|
});
|
|
return value;
|
|
};
|
|
var createFontSizeListBoxChangeHandler = function (editor, items) {
|
|
return function () {
|
|
var self = this;
|
|
editor.on('init nodeChange', function (e) {
|
|
var px, pt, precision, match;
|
|
px = editor.queryCommandValue('FontSize');
|
|
if (px) {
|
|
for (precision = 3; !match && precision >= 0; precision--) {
|
|
pt = toPt(px, precision);
|
|
match = findMatchingValue$1(items, pt, px);
|
|
}
|
|
}
|
|
self.value(match ? match : null);
|
|
if (!match) {
|
|
self.text(pt);
|
|
}
|
|
});
|
|
};
|
|
};
|
|
var getFontSizeItems = function (editor) {
|
|
var defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt';
|
|
var fontsizeFormats = editor.settings.fontsize_formats || defaultFontsizeFormats;
|
|
return global$4.map(fontsizeFormats.split(' '), function (item) {
|
|
var text = item, value = item;
|
|
var values = item.split('=');
|
|
if (values.length > 1) {
|
|
text = values[0];
|
|
value = values[1];
|
|
}
|
|
return {
|
|
text: text,
|
|
value: value
|
|
};
|
|
});
|
|
};
|
|
var registerButtons$1 = function (editor) {
|
|
editor.addButton('fontsizeselect', function () {
|
|
var items = getFontSizeItems(editor);
|
|
return {
|
|
type: 'listbox',
|
|
text: 'Font Sizes',
|
|
tooltip: 'Font Sizes',
|
|
values: items,
|
|
fixedWidth: true,
|
|
onPostRender: createFontSizeListBoxChangeHandler(editor, items),
|
|
onclick: function (e) {
|
|
if (e.control.settings.value) {
|
|
editor.execCommand('FontSize', false, e.control.settings.value);
|
|
}
|
|
}
|
|
};
|
|
});
|
|
};
|
|
var register$2 = function (editor) {
|
|
registerButtons$1(editor);
|
|
};
|
|
var $_b15nsk1bljjgwekd9 = { register: register$2 };
|
|
|
|
var hideMenuObjects = function (editor, menu) {
|
|
var count = menu.length;
|
|
global$4.each(menu, function (item) {
|
|
if (item.menu) {
|
|
item.hidden = hideMenuObjects(editor, item.menu) === 0;
|
|
}
|
|
var formatName = item.format;
|
|
if (formatName) {
|
|
item.hidden = !editor.formatter.canApply(formatName);
|
|
}
|
|
if (item.hidden) {
|
|
count--;
|
|
}
|
|
});
|
|
return count;
|
|
};
|
|
var hideFormatMenuItems = function (editor, menu) {
|
|
var count = menu.items().length;
|
|
menu.items().each(function (item) {
|
|
if (item.menu) {
|
|
item.visible(hideFormatMenuItems(editor, item.menu) > 0);
|
|
}
|
|
if (!item.menu && item.settings.menu) {
|
|
item.visible(hideMenuObjects(editor, item.settings.menu) > 0);
|
|
}
|
|
var formatName = item.settings.format;
|
|
if (formatName) {
|
|
item.visible(editor.formatter.canApply(formatName));
|
|
}
|
|
if (!item.visible()) {
|
|
count--;
|
|
}
|
|
});
|
|
return count;
|
|
};
|
|
var createFormatMenu = function (editor) {
|
|
var count = 0;
|
|
var newFormats = [];
|
|
var defaultStyleFormats = [
|
|
{
|
|
title: 'Headings',
|
|
items: [
|
|
{
|
|
title: 'Heading 1',
|
|
format: 'h1'
|
|
},
|
|
{
|
|
title: 'Heading 2',
|
|
format: 'h2'
|
|
},
|
|
{
|
|
title: 'Heading 3',
|
|
format: 'h3'
|
|
},
|
|
{
|
|
title: 'Heading 4',
|
|
format: 'h4'
|
|
},
|
|
{
|
|
title: 'Heading 5',
|
|
format: 'h5'
|
|
},
|
|
{
|
|
title: 'Heading 6',
|
|
format: 'h6'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
title: 'Inline',
|
|
items: [
|
|
{
|
|
title: 'Bold',
|
|
icon: 'bold',
|
|
format: 'bold'
|
|
},
|
|
{
|
|
title: 'Italic',
|
|
icon: 'italic',
|
|
format: 'italic'
|
|
},
|
|
{
|
|
title: 'Underline',
|
|
icon: 'underline',
|
|
format: 'underline'
|
|
},
|
|
{
|
|
title: 'Strikethrough',
|
|
icon: 'strikethrough',
|
|
format: 'strikethrough'
|
|
},
|
|
{
|
|
title: 'Superscript',
|
|
icon: 'superscript',
|
|
format: 'superscript'
|
|
},
|
|
{
|
|
title: 'Subscript',
|
|
icon: 'subscript',
|
|
format: 'subscript'
|
|
},
|
|
{
|
|
title: 'Code',
|
|
icon: 'code',
|
|
format: 'code'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
title: 'Blocks',
|
|
items: [
|
|
{
|
|
title: 'Paragraph',
|
|
format: 'p'
|
|
},
|
|
{
|
|
title: 'Blockquote',
|
|
format: 'blockquote'
|
|
},
|
|
{
|
|
title: 'Div',
|
|
format: 'div'
|
|
},
|
|
{
|
|
title: 'Pre',
|
|
format: 'pre'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
title: 'Alignment',
|
|
items: [
|
|
{
|
|
title: 'Left',
|
|
icon: 'alignleft',
|
|
format: 'alignleft'
|
|
},
|
|
{
|
|
title: 'Center',
|
|
icon: 'aligncenter',
|
|
format: 'aligncenter'
|
|
},
|
|
{
|
|
title: 'Right',
|
|
icon: 'alignright',
|
|
format: 'alignright'
|
|
},
|
|
{
|
|
title: 'Justify',
|
|
icon: 'alignjustify',
|
|
format: 'alignjustify'
|
|
}
|
|
]
|
|
}
|
|
];
|
|
var createMenu = function (formats) {
|
|
var menu = [];
|
|
if (!formats) {
|
|
return;
|
|
}
|
|
global$4.each(formats, function (format) {
|
|
var menuItem = {
|
|
text: format.title,
|
|
icon: format.icon
|
|
};
|
|
if (format.items) {
|
|
menuItem.menu = createMenu(format.items);
|
|
} else {
|
|
var formatName = format.format || 'custom' + count++;
|
|
if (!format.format) {
|
|
format.name = formatName;
|
|
newFormats.push(format);
|
|
}
|
|
menuItem.format = formatName;
|
|
menuItem.cmd = format.cmd;
|
|
}
|
|
menu.push(menuItem);
|
|
});
|
|
return menu;
|
|
};
|
|
var createStylesMenu = function () {
|
|
var menu;
|
|
if (editor.settings.style_formats_merge) {
|
|
if (editor.settings.style_formats) {
|
|
menu = createMenu(defaultStyleFormats.concat(editor.settings.style_formats));
|
|
} else {
|
|
menu = createMenu(defaultStyleFormats);
|
|
}
|
|
} else {
|
|
menu = createMenu(editor.settings.style_formats || defaultStyleFormats);
|
|
}
|
|
return menu;
|
|
};
|
|
editor.on('init', function () {
|
|
global$4.each(newFormats, function (format) {
|
|
editor.formatter.register(format.name, format);
|
|
});
|
|
});
|
|
return {
|
|
type: 'menu',
|
|
items: createStylesMenu(),
|
|
onPostRender: function (e) {
|
|
editor.fire('renderFormatsMenu', { control: e.control });
|
|
},
|
|
itemDefaults: {
|
|
preview: true,
|
|
textStyle: function () {
|
|
if (this.settings.format) {
|
|
return editor.formatter.getCssText(this.settings.format);
|
|
}
|
|
},
|
|
onPostRender: function () {
|
|
var self = this;
|
|
self.parent().on('show', function () {
|
|
var formatName, command;
|
|
formatName = self.settings.format;
|
|
if (formatName) {
|
|
self.disabled(!editor.formatter.canApply(formatName));
|
|
self.active(editor.formatter.match(formatName));
|
|
}
|
|
command = self.settings.cmd;
|
|
if (command) {
|
|
self.active(editor.queryCommandState(command));
|
|
}
|
|
});
|
|
},
|
|
onclick: function () {
|
|
if (this.settings.format) {
|
|
toggleFormat(editor, this.settings.format)();
|
|
}
|
|
if (this.settings.cmd) {
|
|
editor.execCommand(this.settings.cmd);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
var registerMenuItems = function (editor, formatMenu) {
|
|
editor.addMenuItem('formats', {
|
|
text: 'Formats',
|
|
menu: formatMenu
|
|
});
|
|
};
|
|
var registerButtons$2 = function (editor, formatMenu) {
|
|
editor.addButton('styleselect', {
|
|
type: 'menubutton',
|
|
text: 'Formats',
|
|
menu: formatMenu,
|
|
onShowMenu: function () {
|
|
if (editor.settings.style_formats_autohide) {
|
|
hideFormatMenuItems(editor, this.menu);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var register$3 = function (editor) {
|
|
var formatMenu = createFormatMenu(editor);
|
|
registerMenuItems(editor, formatMenu);
|
|
registerButtons$2(editor, formatMenu);
|
|
};
|
|
var $_9qaa1r1bmjjgwekdc = { register: register$3 };
|
|
|
|
var defaultBlocks = 'Paragraph=p;' + 'Heading 1=h1;' + 'Heading 2=h2;' + 'Heading 3=h3;' + 'Heading 4=h4;' + 'Heading 5=h5;' + 'Heading 6=h6;' + 'Preformatted=pre';
|
|
var createFormats$1 = function (formats) {
|
|
formats = formats.replace(/;$/, '').split(';');
|
|
var i = formats.length;
|
|
while (i--) {
|
|
formats[i] = formats[i].split('=');
|
|
}
|
|
return formats;
|
|
};
|
|
var createListBoxChangeHandler = function (editor, items, formatName) {
|
|
return function () {
|
|
var self = this;
|
|
editor.on('nodeChange', function (e) {
|
|
var formatter = editor.formatter;
|
|
var value = null;
|
|
global$4.each(e.parents, function (node) {
|
|
global$4.each(items, function (item) {
|
|
if (formatName) {
|
|
if (formatter.matchNode(node, formatName, { value: item.value })) {
|
|
value = item.value;
|
|
}
|
|
} else {
|
|
if (formatter.matchNode(node, item.value)) {
|
|
value = item.value;
|
|
}
|
|
}
|
|
if (value) {
|
|
return false;
|
|
}
|
|
});
|
|
if (value) {
|
|
return false;
|
|
}
|
|
});
|
|
self.value(value);
|
|
});
|
|
};
|
|
};
|
|
var lazyFormatSelectBoxItems = function (editor, blocks) {
|
|
return function () {
|
|
var items = [];
|
|
global$4.each(blocks, function (block) {
|
|
items.push({
|
|
text: block[0],
|
|
value: block[1],
|
|
textStyle: function () {
|
|
return editor.formatter.getCssText(block[1]);
|
|
}
|
|
});
|
|
});
|
|
return {
|
|
type: 'listbox',
|
|
text: blocks[0][0],
|
|
values: items,
|
|
fixedWidth: true,
|
|
onselect: function (e) {
|
|
if (e.control) {
|
|
var fmt = e.control.value();
|
|
toggleFormat(editor, fmt)();
|
|
}
|
|
},
|
|
onPostRender: createListBoxChangeHandler(editor, items)
|
|
};
|
|
};
|
|
};
|
|
var buildMenuItems = function (editor, blocks) {
|
|
return global$4.map(blocks, function (block) {
|
|
return {
|
|
text: block[0],
|
|
onclick: toggleFormat(editor, block[1]),
|
|
textStyle: function () {
|
|
return editor.formatter.getCssText(block[1]);
|
|
}
|
|
};
|
|
});
|
|
};
|
|
var register$4 = function (editor) {
|
|
var blocks = createFormats$1(editor.settings.block_formats || defaultBlocks);
|
|
editor.addMenuItem('blockformats', {
|
|
text: 'Blocks',
|
|
menu: buildMenuItems(editor, blocks)
|
|
});
|
|
editor.addButton('formatselect', lazyFormatSelectBoxItems(editor, blocks));
|
|
};
|
|
var $_a3xw9u1bnjjgwekdh = { register: register$4 };
|
|
|
|
var createCustomMenuItems = function (editor, names) {
|
|
var items, nameList;
|
|
if (typeof names === 'string') {
|
|
nameList = names.split(' ');
|
|
} else if (global$4.isArray(names)) {
|
|
return flatten$1(global$4.map(names, function (names) {
|
|
return createCustomMenuItems(editor, names);
|
|
}));
|
|
}
|
|
items = global$4.grep(nameList, function (name) {
|
|
return name === '|' || name in editor.menuItems;
|
|
});
|
|
return global$4.map(items, function (name) {
|
|
return name === '|' ? { text: '-' } : editor.menuItems[name];
|
|
});
|
|
};
|
|
var isSeparator = function (menuItem) {
|
|
return menuItem && menuItem.text === '-';
|
|
};
|
|
var trimMenuItems = function (menuItems) {
|
|
var menuItems2 = filter(menuItems, function (menuItem, i, menuItems) {
|
|
return !isSeparator(menuItem) || !isSeparator(menuItems[i - 1]);
|
|
});
|
|
return filter(menuItems2, function (menuItem, i, menuItems) {
|
|
return !isSeparator(menuItem) || i > 0 && i < menuItems.length - 1;
|
|
});
|
|
};
|
|
var createContextMenuItems = function (editor, context) {
|
|
var outputMenuItems = [{ text: '-' }];
|
|
var menuItems = global$4.grep(editor.menuItems, function (menuItem) {
|
|
return menuItem.context === context;
|
|
});
|
|
global$4.each(menuItems, function (menuItem) {
|
|
if (menuItem.separator === 'before') {
|
|
outputMenuItems.push({ text: '|' });
|
|
}
|
|
if (menuItem.prependToContext) {
|
|
outputMenuItems.unshift(menuItem);
|
|
} else {
|
|
outputMenuItems.push(menuItem);
|
|
}
|
|
if (menuItem.separator === 'after') {
|
|
outputMenuItems.push({ text: '|' });
|
|
}
|
|
});
|
|
return outputMenuItems;
|
|
};
|
|
var createInsertMenu = function (editor) {
|
|
var insertButtonItems = editor.settings.insert_button_items;
|
|
if (insertButtonItems) {
|
|
return trimMenuItems(createCustomMenuItems(editor, insertButtonItems));
|
|
} else {
|
|
return trimMenuItems(createContextMenuItems(editor, 'insert'));
|
|
}
|
|
};
|
|
var registerButtons$3 = function (editor) {
|
|
editor.addButton('insert', {
|
|
type: 'menubutton',
|
|
icon: 'insert',
|
|
menu: [],
|
|
oncreatemenu: function () {
|
|
this.menu.add(createInsertMenu(editor));
|
|
this.menu.renderNew();
|
|
}
|
|
});
|
|
};
|
|
var register$5 = function (editor) {
|
|
registerButtons$3(editor);
|
|
};
|
|
var $_dvqvtt1bojjgwekdj = { register: register$5 };
|
|
|
|
var registerFormatButtons = function (editor) {
|
|
global$4.each({
|
|
bold: 'Bold',
|
|
italic: 'Italic',
|
|
underline: 'Underline',
|
|
strikethrough: 'Strikethrough',
|
|
subscript: 'Subscript',
|
|
superscript: 'Superscript'
|
|
}, function (text, name) {
|
|
editor.addButton(name, {
|
|
active: false,
|
|
tooltip: text,
|
|
onPostRender: postRenderFormatToggle(editor, name),
|
|
onclick: toggleFormat(editor, name)
|
|
});
|
|
});
|
|
};
|
|
var registerCommandButtons = function (editor) {
|
|
global$4.each({
|
|
outdent: [
|
|
'Decrease indent',
|
|
'Outdent'
|
|
],
|
|
indent: [
|
|
'Increase indent',
|
|
'Indent'
|
|
],
|
|
cut: [
|
|
'Cut',
|
|
'Cut'
|
|
],
|
|
copy: [
|
|
'Copy',
|
|
'Copy'
|
|
],
|
|
paste: [
|
|
'Paste',
|
|
'Paste'
|
|
],
|
|
help: [
|
|
'Help',
|
|
'mceHelp'
|
|
],
|
|
selectall: [
|
|
'Select all',
|
|
'SelectAll'
|
|
],
|
|
visualaid: [
|
|
'Visual aids',
|
|
'mceToggleVisualAid'
|
|
],
|
|
newdocument: [
|
|
'New document',
|
|
'mceNewDocument'
|
|
],
|
|
removeformat: [
|
|
'Clear formatting',
|
|
'RemoveFormat'
|
|
],
|
|
remove: [
|
|
'Remove',
|
|
'Delete'
|
|
]
|
|
}, function (item, name) {
|
|
editor.addButton(name, {
|
|
tooltip: item[0],
|
|
cmd: item[1]
|
|
});
|
|
});
|
|
};
|
|
var registerCommandToggleButtons = function (editor) {
|
|
global$4.each({
|
|
blockquote: [
|
|
'Blockquote',
|
|
'mceBlockQuote'
|
|
],
|
|
subscript: [
|
|
'Subscript',
|
|
'Subscript'
|
|
],
|
|
superscript: [
|
|
'Superscript',
|
|
'Superscript'
|
|
]
|
|
}, function (item, name) {
|
|
editor.addButton(name, {
|
|
active: false,
|
|
tooltip: item[0],
|
|
cmd: item[1],
|
|
onPostRender: postRenderFormatToggle(editor, name)
|
|
});
|
|
});
|
|
};
|
|
var registerButtons$4 = function (editor) {
|
|
registerFormatButtons(editor);
|
|
registerCommandButtons(editor);
|
|
registerCommandToggleButtons(editor);
|
|
};
|
|
var registerMenuItems$1 = function (editor) {
|
|
global$4.each({
|
|
bold: [
|
|
'Bold',
|
|
'Bold',
|
|
'Meta+B'
|
|
],
|
|
italic: [
|
|
'Italic',
|
|
'Italic',
|
|
'Meta+I'
|
|
],
|
|
underline: [
|
|
'Underline',
|
|
'Underline',
|
|
'Meta+U'
|
|
],
|
|
strikethrough: [
|
|
'Strikethrough',
|
|
'Strikethrough'
|
|
],
|
|
subscript: [
|
|
'Subscript',
|
|
'Subscript'
|
|
],
|
|
superscript: [
|
|
'Superscript',
|
|
'Superscript'
|
|
],
|
|
removeformat: [
|
|
'Clear formatting',
|
|
'RemoveFormat'
|
|
],
|
|
newdocument: [
|
|
'New document',
|
|
'mceNewDocument'
|
|
],
|
|
cut: [
|
|
'Cut',
|
|
'Cut',
|
|
'Meta+X'
|
|
],
|
|
copy: [
|
|
'Copy',
|
|
'Copy',
|
|
'Meta+C'
|
|
],
|
|
paste: [
|
|
'Paste',
|
|
'Paste',
|
|
'Meta+V'
|
|
],
|
|
selectall: [
|
|
'Select all',
|
|
'SelectAll',
|
|
'Meta+A'
|
|
]
|
|
}, function (item, name) {
|
|
editor.addMenuItem(name, {
|
|
text: item[0],
|
|
icon: name,
|
|
shortcut: item[2],
|
|
cmd: item[1]
|
|
});
|
|
});
|
|
editor.addMenuItem('codeformat', {
|
|
text: 'Code',
|
|
icon: 'code',
|
|
onclick: toggleFormat(editor, 'code')
|
|
});
|
|
};
|
|
var register$6 = function (editor) {
|
|
registerButtons$4(editor);
|
|
registerMenuItems$1(editor);
|
|
};
|
|
var $_2ywvy11bpjjgwekdn = { register: register$6 };
|
|
|
|
var toggleUndoRedoState = function (editor, type) {
|
|
return function () {
|
|
var self = this;
|
|
var checkState = function () {
|
|
var typeFn = type === 'redo' ? 'hasRedo' : 'hasUndo';
|
|
return editor.undoManager ? editor.undoManager[typeFn]() : false;
|
|
};
|
|
self.disabled(!checkState());
|
|
editor.on('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', function () {
|
|
self.disabled(editor.readonly || !checkState());
|
|
});
|
|
};
|
|
};
|
|
var registerMenuItems$2 = function (editor) {
|
|
editor.addMenuItem('undo', {
|
|
text: 'Undo',
|
|
icon: 'undo',
|
|
shortcut: 'Meta+Z',
|
|
onPostRender: toggleUndoRedoState(editor, 'undo'),
|
|
cmd: 'undo'
|
|
});
|
|
editor.addMenuItem('redo', {
|
|
text: 'Redo',
|
|
icon: 'redo',
|
|
shortcut: 'Meta+Y',
|
|
onPostRender: toggleUndoRedoState(editor, 'redo'),
|
|
cmd: 'redo'
|
|
});
|
|
};
|
|
var registerButtons$5 = function (editor) {
|
|
editor.addButton('undo', {
|
|
tooltip: 'Undo',
|
|
onPostRender: toggleUndoRedoState(editor, 'undo'),
|
|
cmd: 'undo'
|
|
});
|
|
editor.addButton('redo', {
|
|
tooltip: 'Redo',
|
|
onPostRender: toggleUndoRedoState(editor, 'redo'),
|
|
cmd: 'redo'
|
|
});
|
|
};
|
|
var register$7 = function (editor) {
|
|
registerMenuItems$2(editor);
|
|
registerButtons$5(editor);
|
|
};
|
|
var $_5qfrkx1bqjjgwekdq = { register: register$7 };
|
|
|
|
var toggleVisualAidState = function (editor) {
|
|
return function () {
|
|
var self = this;
|
|
editor.on('VisualAid', function (e) {
|
|
self.active(e.hasVisual);
|
|
});
|
|
self.active(editor.hasVisual);
|
|
};
|
|
};
|
|
var registerMenuItems$3 = function (editor) {
|
|
editor.addMenuItem('visualaid', {
|
|
text: 'Visual aids',
|
|
selectable: true,
|
|
onPostRender: toggleVisualAidState(editor),
|
|
cmd: 'mceToggleVisualAid'
|
|
});
|
|
};
|
|
var register$8 = function (editor) {
|
|
registerMenuItems$3(editor);
|
|
};
|
|
var $_ebb6rc1brjjgwekdr = { register: register$8 };
|
|
|
|
var setupEnvironment = function () {
|
|
Widget.tooltips = !global$1.iOS;
|
|
Control$1.translate = function (text) {
|
|
return global$5.translate(text);
|
|
};
|
|
};
|
|
var setupUiContainer = function (editor) {
|
|
if (editor.settings.ui_container) {
|
|
global$1.container = $_6nlstg1bfjjgwekcb.descendant(Element$$1.fromDom(document.body), editor.settings.ui_container).fold(constant(null), function (elm) {
|
|
return elm.dom();
|
|
});
|
|
}
|
|
};
|
|
var setupRtlMode = function (editor) {
|
|
if (editor.rtl) {
|
|
Control$1.rtl = true;
|
|
}
|
|
};
|
|
var setupHideFloatPanels = function (editor) {
|
|
editor.on('mousedown', function () {
|
|
FloatPanel.hideAll();
|
|
});
|
|
};
|
|
var setup = function (editor) {
|
|
setupRtlMode(editor);
|
|
setupHideFloatPanels(editor);
|
|
setupUiContainer(editor);
|
|
setupEnvironment();
|
|
$_a3xw9u1bnjjgwekdh.register(editor);
|
|
$_7uh4c31bijjgwekcw.register(editor);
|
|
$_2ywvy11bpjjgwekdn.register(editor);
|
|
$_5qfrkx1bqjjgwekdq.register(editor);
|
|
$_b15nsk1bljjgwekd9.register(editor);
|
|
$_2g5ce1bkjjgwekcz.register(editor);
|
|
$_9qaa1r1bmjjgwekdc.register(editor);
|
|
$_ebb6rc1brjjgwekdr.register(editor);
|
|
$_dvqvtt1bojjgwekdj.register(editor);
|
|
};
|
|
var $_gg6ikw1bejjgwekc5 = { setup: setup };
|
|
|
|
var GridLayout = AbsoluteLayout.extend({
|
|
recalc: function (container) {
|
|
var settings, rows, cols, items, contLayoutRect, width, height, rect, ctrlLayoutRect, ctrl, x, y, posX, posY, ctrlSettings, contPaddingBox, align, spacingH, spacingV, alignH, alignV, maxX, maxY;
|
|
var colWidths = [];
|
|
var rowHeights = [];
|
|
var ctrlMinWidth, ctrlMinHeight, availableWidth, availableHeight, reverseRows, idx;
|
|
settings = container.settings;
|
|
items = container.items().filter(':visible');
|
|
contLayoutRect = container.layoutRect();
|
|
cols = settings.columns || Math.ceil(Math.sqrt(items.length));
|
|
rows = Math.ceil(items.length / cols);
|
|
spacingH = settings.spacingH || settings.spacing || 0;
|
|
spacingV = settings.spacingV || settings.spacing || 0;
|
|
alignH = settings.alignH || settings.align;
|
|
alignV = settings.alignV || settings.align;
|
|
contPaddingBox = container.paddingBox;
|
|
reverseRows = 'reverseRows' in settings ? settings.reverseRows : container.isRtl();
|
|
if (alignH && typeof alignH === 'string') {
|
|
alignH = [alignH];
|
|
}
|
|
if (alignV && typeof alignV === 'string') {
|
|
alignV = [alignV];
|
|
}
|
|
for (x = 0; x < cols; x++) {
|
|
colWidths.push(0);
|
|
}
|
|
for (y = 0; y < rows; y++) {
|
|
rowHeights.push(0);
|
|
}
|
|
for (y = 0; y < rows; y++) {
|
|
for (x = 0; x < cols; x++) {
|
|
ctrl = items[y * cols + x];
|
|
if (!ctrl) {
|
|
break;
|
|
}
|
|
ctrlLayoutRect = ctrl.layoutRect();
|
|
ctrlMinWidth = ctrlLayoutRect.minW;
|
|
ctrlMinHeight = ctrlLayoutRect.minH;
|
|
colWidths[x] = ctrlMinWidth > colWidths[x] ? ctrlMinWidth : colWidths[x];
|
|
rowHeights[y] = ctrlMinHeight > rowHeights[y] ? ctrlMinHeight : rowHeights[y];
|
|
}
|
|
}
|
|
availableWidth = contLayoutRect.innerW - contPaddingBox.left - contPaddingBox.right;
|
|
for (maxX = 0, x = 0; x < cols; x++) {
|
|
maxX += colWidths[x] + (x > 0 ? spacingH : 0);
|
|
availableWidth -= (x > 0 ? spacingH : 0) + colWidths[x];
|
|
}
|
|
availableHeight = contLayoutRect.innerH - contPaddingBox.top - contPaddingBox.bottom;
|
|
for (maxY = 0, y = 0; y < rows; y++) {
|
|
maxY += rowHeights[y] + (y > 0 ? spacingV : 0);
|
|
availableHeight -= (y > 0 ? spacingV : 0) + rowHeights[y];
|
|
}
|
|
maxX += contPaddingBox.left + contPaddingBox.right;
|
|
maxY += contPaddingBox.top + contPaddingBox.bottom;
|
|
rect = {};
|
|
rect.minW = maxX + (contLayoutRect.w - contLayoutRect.innerW);
|
|
rect.minH = maxY + (contLayoutRect.h - contLayoutRect.innerH);
|
|
rect.contentW = rect.minW - contLayoutRect.deltaW;
|
|
rect.contentH = rect.minH - contLayoutRect.deltaH;
|
|
rect.minW = Math.min(rect.minW, contLayoutRect.maxW);
|
|
rect.minH = Math.min(rect.minH, contLayoutRect.maxH);
|
|
rect.minW = Math.max(rect.minW, contLayoutRect.startMinWidth);
|
|
rect.minH = Math.max(rect.minH, contLayoutRect.startMinHeight);
|
|
if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
|
|
rect.w = rect.minW;
|
|
rect.h = rect.minH;
|
|
container.layoutRect(rect);
|
|
this.recalc(container);
|
|
if (container._lastRect === null) {
|
|
var parentCtrl = container.parent();
|
|
if (parentCtrl) {
|
|
parentCtrl._lastRect = null;
|
|
parentCtrl.recalc();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (contLayoutRect.autoResize) {
|
|
rect = container.layoutRect(rect);
|
|
rect.contentW = rect.minW - contLayoutRect.deltaW;
|
|
rect.contentH = rect.minH - contLayoutRect.deltaH;
|
|
}
|
|
var flexV;
|
|
if (settings.packV === 'start') {
|
|
flexV = 0;
|
|
} else {
|
|
flexV = availableHeight > 0 ? Math.floor(availableHeight / rows) : 0;
|
|
}
|
|
var totalFlex = 0;
|
|
var flexWidths = settings.flexWidths;
|
|
if (flexWidths) {
|
|
for (x = 0; x < flexWidths.length; x++) {
|
|
totalFlex += flexWidths[x];
|
|
}
|
|
} else {
|
|
totalFlex = cols;
|
|
}
|
|
var ratio = availableWidth / totalFlex;
|
|
for (x = 0; x < cols; x++) {
|
|
colWidths[x] += flexWidths ? flexWidths[x] * ratio : ratio;
|
|
}
|
|
posY = contPaddingBox.top;
|
|
for (y = 0; y < rows; y++) {
|
|
posX = contPaddingBox.left;
|
|
height = rowHeights[y] + flexV;
|
|
for (x = 0; x < cols; x++) {
|
|
if (reverseRows) {
|
|
idx = y * cols + cols - 1 - x;
|
|
} else {
|
|
idx = y * cols + x;
|
|
}
|
|
ctrl = items[idx];
|
|
if (!ctrl) {
|
|
break;
|
|
}
|
|
ctrlSettings = ctrl.settings;
|
|
ctrlLayoutRect = ctrl.layoutRect();
|
|
width = Math.max(colWidths[x], ctrlLayoutRect.startMinWidth);
|
|
ctrlLayoutRect.x = posX;
|
|
ctrlLayoutRect.y = posY;
|
|
align = ctrlSettings.alignH || (alignH ? alignH[x] || alignH[0] : null);
|
|
if (align === 'center') {
|
|
ctrlLayoutRect.x = posX + width / 2 - ctrlLayoutRect.w / 2;
|
|
} else if (align === 'right') {
|
|
ctrlLayoutRect.x = posX + width - ctrlLayoutRect.w;
|
|
} else if (align === 'stretch') {
|
|
ctrlLayoutRect.w = width;
|
|
}
|
|
align = ctrlSettings.alignV || (alignV ? alignV[x] || alignV[0] : null);
|
|
if (align === 'center') {
|
|
ctrlLayoutRect.y = posY + height / 2 - ctrlLayoutRect.h / 2;
|
|
} else if (align === 'bottom') {
|
|
ctrlLayoutRect.y = posY + height - ctrlLayoutRect.h;
|
|
} else if (align === 'stretch') {
|
|
ctrlLayoutRect.h = height;
|
|
}
|
|
ctrl.layoutRect(ctrlLayoutRect);
|
|
posX += width + spacingH;
|
|
if (ctrl.recalc) {
|
|
ctrl.recalc();
|
|
}
|
|
}
|
|
posY += height + spacingV;
|
|
}
|
|
}
|
|
});
|
|
|
|
var Iframe = Widget.extend({
|
|
renderHtml: function () {
|
|
var self = this;
|
|
self.classes.add('iframe');
|
|
self.canFocus = false;
|
|
return '<iframe id="' + self._id + '" class="' + self.classes + '" tabindex="-1" src="' + (self.settings.url || 'javascript:\'\'') + '" frameborder="0"></iframe>';
|
|
},
|
|
src: function (src) {
|
|
this.getEl().src = src;
|
|
},
|
|
html: function (html, callback) {
|
|
var self = this, body = this.getEl().contentWindow.document.body;
|
|
if (!body) {
|
|
global$3.setTimeout(function () {
|
|
self.html(html);
|
|
});
|
|
} else {
|
|
body.innerHTML = html;
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
});
|
|
|
|
var InfoBox = Widget.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
self._super(settings);
|
|
self.classes.add('widget').add('infobox');
|
|
self.canFocus = false;
|
|
},
|
|
severity: function (level) {
|
|
this.classes.remove('error');
|
|
this.classes.remove('warning');
|
|
this.classes.remove('success');
|
|
this.classes.add(level);
|
|
},
|
|
help: function (state) {
|
|
this.state.set('help', state);
|
|
},
|
|
renderHtml: function () {
|
|
var self = this, prefix = self.classPrefix;
|
|
return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + self.encode(self.state.get('text')) + '<button role="button" tabindex="-1">' + '<i class="' + prefix + 'ico ' + prefix + 'i-help"></i>' + '</button>' + '</div>' + '</div>';
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self.state.on('change:text', function (e) {
|
|
self.getEl('body').firstChild.data = self.encode(e.value);
|
|
if (self.state.get('rendered')) {
|
|
self.updateLayoutRect();
|
|
}
|
|
});
|
|
self.state.on('change:help', function (e) {
|
|
self.classes.toggle('has-help', e.value);
|
|
if (self.state.get('rendered')) {
|
|
self.updateLayoutRect();
|
|
}
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
var Label = Widget.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
self._super(settings);
|
|
self.classes.add('widget').add('label');
|
|
self.canFocus = false;
|
|
if (settings.multiline) {
|
|
self.classes.add('autoscroll');
|
|
}
|
|
if (settings.strong) {
|
|
self.classes.add('strong');
|
|
}
|
|
},
|
|
initLayoutRect: function () {
|
|
var self = this, layoutRect = self._super();
|
|
if (self.settings.multiline) {
|
|
var size = funcs.getSize(self.getEl());
|
|
if (size.width > layoutRect.maxW) {
|
|
layoutRect.minW = layoutRect.maxW;
|
|
self.classes.add('multiline');
|
|
}
|
|
self.getEl().style.width = layoutRect.minW + 'px';
|
|
layoutRect.startMinH = layoutRect.h = layoutRect.minH = Math.min(layoutRect.maxH, funcs.getSize(self.getEl()).height);
|
|
}
|
|
return layoutRect;
|
|
},
|
|
repaint: function () {
|
|
var self = this;
|
|
if (!self.settings.multiline) {
|
|
self.getEl().style.lineHeight = self.layoutRect().h + 'px';
|
|
}
|
|
return self._super();
|
|
},
|
|
severity: function (level) {
|
|
this.classes.remove('error');
|
|
this.classes.remove('warning');
|
|
this.classes.remove('success');
|
|
this.classes.add(level);
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var targetCtrl, forName, forId = self.settings.forId;
|
|
var text = self.settings.html ? self.settings.html : self.encode(self.state.get('text'));
|
|
if (!forId && (forName = self.settings.forName)) {
|
|
targetCtrl = self.getRoot().find('#' + forName)[0];
|
|
if (targetCtrl) {
|
|
forId = targetCtrl._id;
|
|
}
|
|
}
|
|
if (forId) {
|
|
return '<label id="' + self._id + '" class="' + self.classes + '"' + (forId ? ' for="' + forId + '"' : '') + '>' + text + '</label>';
|
|
}
|
|
return '<span id="' + self._id + '" class="' + self.classes + '">' + text + '</span>';
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self.state.on('change:text', function (e) {
|
|
self.innerHtml(self.encode(e.value));
|
|
if (self.state.get('rendered')) {
|
|
self.updateLayoutRect();
|
|
}
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
var Toolbar$1 = Container.extend({
|
|
Defaults: {
|
|
role: 'toolbar',
|
|
layout: 'flow'
|
|
},
|
|
init: function (settings) {
|
|
var self = this;
|
|
self._super(settings);
|
|
self.classes.add('toolbar');
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
self.items().each(function (ctrl) {
|
|
ctrl.classes.add('toolbar-item');
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
var MenuBar = Toolbar$1.extend({
|
|
Defaults: {
|
|
role: 'menubar',
|
|
containerCls: 'menubar',
|
|
ariaRoot: true,
|
|
defaults: { type: 'menubutton' }
|
|
}
|
|
});
|
|
|
|
function isChildOf$1(node, parent$$1) {
|
|
while (node) {
|
|
if (parent$$1 === node) {
|
|
return true;
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
var MenuButton = Button.extend({
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
self$$1._renderOpen = true;
|
|
self$$1._super(settings);
|
|
settings = self$$1.settings;
|
|
self$$1.classes.add('menubtn');
|
|
if (settings.fixedWidth) {
|
|
self$$1.classes.add('fixed-width');
|
|
}
|
|
self$$1.aria('haspopup', true);
|
|
self$$1.state.set('menu', settings.menu || self$$1.render());
|
|
},
|
|
showMenu: function (toggle) {
|
|
var self$$1 = this;
|
|
var menu;
|
|
if (self$$1.menu && self$$1.menu.visible() && toggle !== false) {
|
|
return self$$1.hideMenu();
|
|
}
|
|
if (!self$$1.menu) {
|
|
menu = self$$1.state.get('menu') || [];
|
|
self$$1.classes.add('opened');
|
|
if (menu.length) {
|
|
menu = {
|
|
type: 'menu',
|
|
animate: true,
|
|
items: menu
|
|
};
|
|
} else {
|
|
menu.type = menu.type || 'menu';
|
|
menu.animate = true;
|
|
}
|
|
if (!menu.renderTo) {
|
|
self$$1.menu = global$11.create(menu).parent(self$$1).renderTo();
|
|
} else {
|
|
self$$1.menu = menu.parent(self$$1).show().renderTo();
|
|
}
|
|
self$$1.fire('createmenu');
|
|
self$$1.menu.reflow();
|
|
self$$1.menu.on('cancel', function (e) {
|
|
if (e.control.parent() === self$$1.menu) {
|
|
e.stopPropagation();
|
|
self$$1.focus();
|
|
self$$1.hideMenu();
|
|
}
|
|
});
|
|
self$$1.menu.on('select', function () {
|
|
self$$1.focus();
|
|
});
|
|
self$$1.menu.on('show hide', function (e) {
|
|
if (e.control === self$$1.menu) {
|
|
self$$1.activeMenu(e.type === 'show');
|
|
self$$1.classes.toggle('opened', e.type === 'show');
|
|
}
|
|
self$$1.aria('expanded', e.type === 'show');
|
|
}).fire('show');
|
|
}
|
|
self$$1.menu.show();
|
|
self$$1.menu.layoutRect({ w: self$$1.layoutRect().w });
|
|
self$$1.menu.repaint();
|
|
self$$1.menu.moveRel(self$$1.getEl(), self$$1.isRtl() ? [
|
|
'br-tr',
|
|
'tr-br'
|
|
] : [
|
|
'bl-tl',
|
|
'tl-bl'
|
|
]);
|
|
self$$1.fire('showmenu');
|
|
},
|
|
hideMenu: function () {
|
|
var self$$1 = this;
|
|
if (self$$1.menu) {
|
|
self$$1.menu.items().each(function (item) {
|
|
if (item.hideMenu) {
|
|
item.hideMenu();
|
|
}
|
|
});
|
|
self$$1.menu.hide();
|
|
}
|
|
},
|
|
activeMenu: function (state) {
|
|
this.classes.toggle('active', state);
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this, id = self$$1._id, prefix = self$$1.classPrefix;
|
|
var icon = self$$1.settings.icon, image;
|
|
var text = self$$1.state.get('text');
|
|
var textHtml = '';
|
|
image = self$$1.settings.image;
|
|
if (image) {
|
|
icon = 'none';
|
|
if (typeof image !== 'string') {
|
|
image = window.getSelection ? image[0] : image[1];
|
|
}
|
|
image = ' style="background-image: url(\'' + image + '\')"';
|
|
} else {
|
|
image = '';
|
|
}
|
|
if (text) {
|
|
self$$1.classes.add('btn-has-text');
|
|
textHtml = '<span class="' + prefix + 'txt">' + self$$1.encode(text) + '</span>';
|
|
}
|
|
icon = self$$1.settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
|
|
self$$1.aria('role', self$$1.parent() instanceof MenuBar ? 'menuitem' : 'button');
|
|
return '<div id="' + id + '" class="' + self$$1.classes + '" tabindex="-1" aria-labelledby="' + id + '">' + '<button id="' + id + '-open" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this;
|
|
self$$1.on('click', function (e) {
|
|
if (e.control === self$$1 && isChildOf$1(e.target, self$$1.getEl())) {
|
|
self$$1.focus();
|
|
self$$1.showMenu(!e.aria);
|
|
if (e.aria) {
|
|
self$$1.menu.items().filter(':visible')[0].focus();
|
|
}
|
|
}
|
|
});
|
|
self$$1.on('mouseenter', function (e) {
|
|
var overCtrl = e.control;
|
|
var parent$$1 = self$$1.parent();
|
|
var hasVisibleSiblingMenu;
|
|
if (overCtrl && parent$$1 && overCtrl instanceof MenuButton && overCtrl.parent() === parent$$1) {
|
|
parent$$1.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();
|
|
overCtrl.showMenu();
|
|
}
|
|
}
|
|
});
|
|
return self$$1._super();
|
|
},
|
|
bindStates: function () {
|
|
var self$$1 = this;
|
|
self$$1.state.on('change:menu', function () {
|
|
if (self$$1.menu) {
|
|
self$$1.menu.remove();
|
|
}
|
|
self$$1.menu = null;
|
|
});
|
|
return self$$1._super();
|
|
},
|
|
remove: function () {
|
|
this._super();
|
|
if (this.menu) {
|
|
this.menu.remove();
|
|
}
|
|
}
|
|
});
|
|
|
|
function Throbber (elm, inline) {
|
|
var self = this;
|
|
var state;
|
|
var classPrefix = Control$1.classPrefix;
|
|
var timer;
|
|
self.show = function (time, callback) {
|
|
function render() {
|
|
if (state) {
|
|
global$7(elm).append('<div class="' + classPrefix + 'throbber' + (inline ? ' ' + classPrefix + 'throbber-inline' : '') + '"></div>');
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
}
|
|
self.hide();
|
|
state = true;
|
|
if (time) {
|
|
timer = global$3.setTimeout(render, time);
|
|
} else {
|
|
render();
|
|
}
|
|
return self;
|
|
};
|
|
self.hide = function () {
|
|
var child = elm.lastChild;
|
|
global$3.clearTimeout(timer);
|
|
if (child && child.className.indexOf('throbber') !== -1) {
|
|
child.parentNode.removeChild(child);
|
|
}
|
|
state = false;
|
|
return self;
|
|
};
|
|
}
|
|
|
|
var Menu = FloatPanel.extend({
|
|
Defaults: {
|
|
defaultType: 'menuitem',
|
|
border: 1,
|
|
layout: 'stack',
|
|
role: 'application',
|
|
bodyRole: 'menu',
|
|
ariaRoot: true
|
|
},
|
|
init: function (settings) {
|
|
var self = this;
|
|
settings.autohide = true;
|
|
settings.constrainToViewport = true;
|
|
if (typeof settings.items === 'function') {
|
|
settings.itemsFactory = settings.items;
|
|
settings.items = [];
|
|
}
|
|
if (settings.itemDefaults) {
|
|
var items = settings.items;
|
|
var i = items.length;
|
|
while (i--) {
|
|
items[i] = global$4.extend({}, settings.itemDefaults, items[i]);
|
|
}
|
|
}
|
|
self._super(settings);
|
|
self.classes.add('menu');
|
|
if (settings.animate && global$1.ie !== 11) {
|
|
self.classes.add('animate');
|
|
}
|
|
},
|
|
repaint: function () {
|
|
this.classes.toggle('menu-align', true);
|
|
this._super();
|
|
this.getEl().style.height = '';
|
|
this.getEl('body').style.height = '';
|
|
return this;
|
|
},
|
|
cancel: function () {
|
|
var self = this;
|
|
self.hideAll();
|
|
self.fire('select');
|
|
},
|
|
load: function () {
|
|
var self = this;
|
|
var time, factory;
|
|
function hideThrobber() {
|
|
if (self.throbber) {
|
|
self.throbber.hide();
|
|
self.throbber = null;
|
|
}
|
|
}
|
|
factory = self.settings.itemsFactory;
|
|
if (!factory) {
|
|
return;
|
|
}
|
|
if (!self.throbber) {
|
|
self.throbber = new Throbber(self.getEl('body'), true);
|
|
if (self.items().length === 0) {
|
|
self.throbber.show();
|
|
self.fire('loading');
|
|
} else {
|
|
self.throbber.show(100, function () {
|
|
self.items().remove();
|
|
self.fire('loading');
|
|
});
|
|
}
|
|
self.on('hide close', hideThrobber);
|
|
}
|
|
self.requestTime = time = new Date().getTime();
|
|
self.settings.itemsFactory(function (items) {
|
|
if (items.length === 0) {
|
|
self.hide();
|
|
return;
|
|
}
|
|
if (self.requestTime !== time) {
|
|
return;
|
|
}
|
|
self.getEl().style.width = '';
|
|
self.getEl('body').style.width = '';
|
|
hideThrobber();
|
|
self.items().remove();
|
|
self.getEl('body').innerHTML = '';
|
|
self.add(items);
|
|
self.renderNew();
|
|
self.fire('loaded');
|
|
});
|
|
},
|
|
hideAll: function () {
|
|
var self = this;
|
|
this.find('menuitem').exec('hideMenu');
|
|
return self._super();
|
|
},
|
|
preRender: function () {
|
|
var self = this;
|
|
self.items().each(function (ctrl) {
|
|
var settings = ctrl.settings;
|
|
if (settings.icon || settings.image || settings.selectable) {
|
|
self._hasIcons = true;
|
|
return false;
|
|
}
|
|
});
|
|
if (self.settings.itemsFactory) {
|
|
self.on('postrender', function () {
|
|
if (self.settings.itemsFactory) {
|
|
self.load();
|
|
}
|
|
});
|
|
}
|
|
self.on('show hide', function (e) {
|
|
if (e.control === self) {
|
|
if (e.type === 'show') {
|
|
global$3.setTimeout(function () {
|
|
self.classes.add('in');
|
|
}, 0);
|
|
} else {
|
|
self.classes.remove('in');
|
|
}
|
|
}
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
var ListBox = MenuButton.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
var values, selected, selectedText, lastItemCtrl;
|
|
function setSelected(menuValues) {
|
|
for (var i = 0; i < menuValues.length; i++) {
|
|
selected = menuValues[i].selected || settings.value === menuValues[i].value;
|
|
if (selected) {
|
|
selectedText = selectedText || menuValues[i].text;
|
|
self.state.set('value', menuValues[i].value);
|
|
return true;
|
|
}
|
|
if (menuValues[i].menu) {
|
|
if (setSelected(menuValues[i].menu)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
self._super(settings);
|
|
settings = self.settings;
|
|
self._values = values = settings.values;
|
|
if (values) {
|
|
if (typeof settings.value !== 'undefined') {
|
|
setSelected(values);
|
|
}
|
|
if (!selected && values.length > 0) {
|
|
selectedText = values[0].text;
|
|
self.state.set('value', values[0].value);
|
|
}
|
|
self.state.set('menu', values);
|
|
}
|
|
self.state.set('text', settings.text || selectedText);
|
|
self.classes.add('listbox');
|
|
self.on('select', function (e) {
|
|
var ctrl = e.control;
|
|
if (lastItemCtrl) {
|
|
e.lastControl = lastItemCtrl;
|
|
}
|
|
if (settings.multiple) {
|
|
ctrl.active(!ctrl.active());
|
|
} else {
|
|
self.value(e.control.value());
|
|
}
|
|
lastItemCtrl = ctrl;
|
|
});
|
|
},
|
|
value: function (value) {
|
|
if (arguments.length === 0) {
|
|
return this.state.get('value');
|
|
}
|
|
if (typeof value === 'undefined') {
|
|
return this;
|
|
}
|
|
if (this.settings.values) {
|
|
var matchingValues = global$4.grep(this.settings.values, function (a) {
|
|
return a.value === value;
|
|
});
|
|
if (matchingValues.length > 0) {
|
|
this.state.set('value', value);
|
|
} else if (value === null) {
|
|
this.state.set('value', null);
|
|
}
|
|
} else {
|
|
this.state.set('value', value);
|
|
}
|
|
return this;
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
function activateMenuItemsByValue(menu, value) {
|
|
if (menu instanceof Menu) {
|
|
menu.items().each(function (ctrl) {
|
|
if (!ctrl.hasMenus()) {
|
|
ctrl.active(ctrl.value() === value);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function getSelectedItem(menuValues, value) {
|
|
var selectedItem;
|
|
if (!menuValues) {
|
|
return;
|
|
}
|
|
for (var i = 0; i < menuValues.length; i++) {
|
|
if (menuValues[i].value === value) {
|
|
return menuValues[i];
|
|
}
|
|
if (menuValues[i].menu) {
|
|
selectedItem = getSelectedItem(menuValues[i].menu, value);
|
|
if (selectedItem) {
|
|
return selectedItem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
self.on('show', function (e) {
|
|
activateMenuItemsByValue(e.control, self.value());
|
|
});
|
|
self.state.on('change:value', function (e) {
|
|
var selectedItem = getSelectedItem(self.state.get('menu'), e.value);
|
|
if (selectedItem) {
|
|
self.text(selectedItem.text);
|
|
} else {
|
|
self.text(self.settings.text);
|
|
}
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
var toggleTextStyle = function (ctrl, state) {
|
|
var textStyle = ctrl._textStyle;
|
|
if (textStyle) {
|
|
var textElm = ctrl.getEl('text');
|
|
textElm.setAttribute('style', textStyle);
|
|
if (state) {
|
|
textElm.style.color = '';
|
|
textElm.style.backgroundColor = '';
|
|
}
|
|
}
|
|
};
|
|
var MenuItem = Widget.extend({
|
|
Defaults: {
|
|
border: 0,
|
|
role: 'menuitem'
|
|
},
|
|
init: function (settings) {
|
|
var self = this;
|
|
var 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);
|
|
}
|
|
},
|
|
hasMenus: function () {
|
|
return !!this.settings.menu;
|
|
},
|
|
showMenu: function () {
|
|
var self = this;
|
|
var settings = self.settings;
|
|
var menu;
|
|
var parent = self.parent();
|
|
parent.items().each(function (ctrl) {
|
|
if (ctrl !== self) {
|
|
ctrl.hideMenu();
|
|
}
|
|
});
|
|
if (settings.menu) {
|
|
menu = self.menu;
|
|
if (!menu) {
|
|
menu = settings.menu;
|
|
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 = global$11.create(menu).parent(self).renderTo();
|
|
menu.reflow();
|
|
menu.on('cancel', function (e) {
|
|
e.stopPropagation();
|
|
self.focus();
|
|
menu.hide();
|
|
});
|
|
menu.on('show hide', function (e) {
|
|
if (e.control.items) {
|
|
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);
|
|
}
|
|
},
|
|
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;
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var id = self._id;
|
|
var settings = self.settings;
|
|
var prefix = self.classPrefix;
|
|
var text = self.state.get('text');
|
|
var icon = self.settings.icon, image = '', shortcut = settings.shortcut;
|
|
var url = self.encode(settings.url), iconHtml = '';
|
|
function convertShortcut(shortcut) {
|
|
var i, value, replace = {};
|
|
if (global$1.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('+');
|
|
}
|
|
function escapeRegExp(str) {
|
|
return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
}
|
|
function markMatches(text) {
|
|
var match = settings.match || '';
|
|
return match ? text.replace(new RegExp(escapeRegExp(match), 'gi'), function (match) {
|
|
return '!mce~match[' + match + ']mce~match!';
|
|
}) : text;
|
|
}
|
|
function boldMatches(text) {
|
|
return text.replace(new RegExp(escapeRegExp('!mce~match['), 'g'), '<b>').replace(new RegExp(escapeRegExp(']mce~match!'), 'g'), '</b>');
|
|
}
|
|
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');
|
|
iconHtml = text !== '-' ? '<i class="' + icon + '"' + image + '></i>\xA0' : '';
|
|
text = boldMatches(self.encode(markMatches(text)));
|
|
url = boldMatches(self.encode(markMatches(url)));
|
|
return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1">' + iconHtml + (text !== '-' ? '<span id="' + id + '-text" class="' + prefix + 'text">' + text + '</span>' : '') + (shortcut ? '<div id="' + id + '-shortcut" class="' + prefix + 'menu-shortcut">' + shortcut + '</div>' : '') + (settings.menu ? '<div class="' + prefix + 'caret"></div>' : '') + (url ? '<div class="' + prefix + 'menu-item-link">' + url + '</div>' : '') + '</div>';
|
|
},
|
|
postRender: function () {
|
|
var self = this, settings = self.settings;
|
|
var textStyle = settings.textStyle;
|
|
if (typeof textStyle === 'function') {
|
|
textStyle = textStyle.call(this);
|
|
}
|
|
if (textStyle) {
|
|
var textElm = self.getEl('text');
|
|
if (textElm) {
|
|
textElm.setAttribute('style', textStyle);
|
|
self._textStyle = textStyle;
|
|
}
|
|
}
|
|
self.on('mouseenter click', function (e) {
|
|
if (e.control === self) {
|
|
if (!settings.menu && e.type === 'click') {
|
|
self.fire('select');
|
|
global$3.requestAnimationFrame(function () {
|
|
self.parent().hideAll();
|
|
});
|
|
} else {
|
|
self.showMenu();
|
|
if (e.aria) {
|
|
self.menu.focus(true);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
self._super();
|
|
return self;
|
|
},
|
|
hover: function () {
|
|
var self = this;
|
|
self.parent().items().each(function (ctrl) {
|
|
ctrl.classes.remove('selected');
|
|
});
|
|
self.classes.toggle('selected', true);
|
|
return self;
|
|
},
|
|
active: function (state) {
|
|
toggleTextStyle(this, state);
|
|
if (typeof state !== 'undefined') {
|
|
this.aria('checked', state);
|
|
}
|
|
return this._super(state);
|
|
},
|
|
remove: function () {
|
|
this._super();
|
|
if (this.menu) {
|
|
this.menu.remove();
|
|
}
|
|
}
|
|
});
|
|
|
|
var Radio = Checkbox.extend({
|
|
Defaults: {
|
|
classes: 'radio',
|
|
role: 'radio'
|
|
}
|
|
});
|
|
|
|
var ResizeHandle = Widget.extend({
|
|
renderHtml: function () {
|
|
var self = this, prefix = self.classPrefix;
|
|
self.classes.add('resizehandle');
|
|
if (self.settings.direction === 'both') {
|
|
self.classes.add('resizehandle-both');
|
|
}
|
|
self.canFocus = false;
|
|
return '<div id="' + self._id + '" class="' + self.classes + '">' + '<i class="' + prefix + 'ico ' + prefix + 'i-resize"></i>' + '</div>';
|
|
},
|
|
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();
|
|
}
|
|
});
|
|
|
|
function createOptions(options) {
|
|
var strOptions = '';
|
|
if (options) {
|
|
for (var i = 0; i < options.length; i++) {
|
|
strOptions += '<option value="' + options[i] + '">' + options[i] + '</option>';
|
|
}
|
|
}
|
|
return strOptions;
|
|
}
|
|
var SelectBox = Widget.extend({
|
|
Defaults: {
|
|
classes: 'selectbox',
|
|
role: 'selectbox',
|
|
options: []
|
|
},
|
|
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();
|
|
self.parents().reverse().each(function (ctrl) {
|
|
if (ctrl.toJSON) {
|
|
rootControl = ctrl;
|
|
return false;
|
|
}
|
|
});
|
|
self.fire('submit', { data: rootControl.toJSON() });
|
|
}
|
|
});
|
|
},
|
|
options: function (state) {
|
|
if (!arguments.length) {
|
|
return this.state.get('options');
|
|
}
|
|
this.state.set('options', state);
|
|
return this;
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var options, size = '';
|
|
options = createOptions(self._options);
|
|
if (self.size) {
|
|
size = ' size = "' + self.size + '"';
|
|
}
|
|
return '<select id="' + self._id + '" class="' + self.classes + '"' + size + '>' + options + '</select>';
|
|
},
|
|
bindStates: function () {
|
|
var self = this;
|
|
self.state.on('change:options', function (e) {
|
|
self.getEl().innerHTML = createOptions(e.value);
|
|
});
|
|
return self._super();
|
|
}
|
|
});
|
|
|
|
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) - funcs.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);
|
|
}
|
|
var Slider = Widget.extend({
|
|
init: function (settings) {
|
|
var self = this;
|
|
if (!settings.previewFilter) {
|
|
settings.previewFilter = function (value) {
|
|
return Math.round(value * 100) / 100;
|
|
};
|
|
}
|
|
self._super(settings);
|
|
self.classes.add('slider');
|
|
if (settings.orientation === 'v') {
|
|
self.classes.add('vertical');
|
|
}
|
|
self._minValue = isNumber$1(settings.minValue) ? settings.minValue : 0;
|
|
self._maxValue = isNumber$1(settings.maxValue) ? settings.maxValue : 100;
|
|
self._initValue = self.state.get('value');
|
|
},
|
|
renderHtml: function () {
|
|
var self = this, id = self._id, prefix = self.classPrefix;
|
|
return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-handle" class="' + prefix + 'slider-handle" role="slider" tabindex="-1"></div>' + '</div>';
|
|
},
|
|
reset: function () {
|
|
this.value(this._initValue).repaint();
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
var 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) - funcs.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);
|
|
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();
|
|
}
|
|
});
|
|
|
|
var Spacer = Widget.extend({
|
|
renderHtml: function () {
|
|
var self = this;
|
|
self.classes.add('spacer');
|
|
self.canFocus = false;
|
|
return '<div id="' + self._id + '" class="' + self.classes + '"></div>';
|
|
}
|
|
});
|
|
|
|
var SplitButton = MenuButton.extend({
|
|
Defaults: {
|
|
classes: 'widget btn splitbtn',
|
|
role: 'button'
|
|
},
|
|
repaint: function () {
|
|
var self$$1 = this;
|
|
var elm = self$$1.getEl();
|
|
var rect = self$$1.layoutRect();
|
|
var mainButtonElm, menuButtonElm;
|
|
self$$1._super();
|
|
mainButtonElm = elm.firstChild;
|
|
menuButtonElm = elm.lastChild;
|
|
global$7(mainButtonElm).css({
|
|
width: rect.w - funcs.getSize(menuButtonElm).width,
|
|
height: rect.h - 2
|
|
});
|
|
global$7(menuButtonElm).css({ height: rect.h - 2 });
|
|
return self$$1;
|
|
},
|
|
activeMenu: function (state) {
|
|
var self$$1 = this;
|
|
global$7(self$$1.getEl().lastChild).toggleClass(self$$1.classPrefix + 'active', state);
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this;
|
|
var id = self$$1._id;
|
|
var prefix = self$$1.classPrefix;
|
|
var image;
|
|
var icon = self$$1.state.get('icon');
|
|
var text = self$$1.state.get('text');
|
|
var settings = self$$1.settings;
|
|
var textHtml = '', ariaPressed;
|
|
image = settings.image;
|
|
if (image) {
|
|
icon = 'none';
|
|
if (typeof image !== 'string') {
|
|
image = window.getSelection ? image[0] : image[1];
|
|
}
|
|
image = ' style="background-image: url(\'' + image + '\')"';
|
|
} else {
|
|
image = '';
|
|
}
|
|
icon = settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
|
|
if (text) {
|
|
self$$1.classes.add('btn-has-text');
|
|
textHtml = '<span class="' + prefix + 'txt">' + self$$1.encode(text) + '</span>';
|
|
}
|
|
ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
|
|
return '<div id="' + id + '" class="' + self$$1.classes + '" role="button"' + ariaPressed + ' tabindex="-1">' + '<button type="button" hidefocus="1" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '<button type="button" class="' + prefix + 'open" hidefocus="1" tabindex="-1">' + (self$$1._menuBtnText ? (icon ? '\xA0' : '') + self$$1._menuBtnText : '') + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this, onClickHandler = self$$1.settings.onclick;
|
|
self$$1.on('click', function (e) {
|
|
var node = e.target;
|
|
if (e.control === this) {
|
|
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$$1.settings.onclick;
|
|
return self$$1._super();
|
|
}
|
|
});
|
|
|
|
var StackLayout = FlowLayout.extend({
|
|
Defaults: {
|
|
containerClass: 'stack-layout',
|
|
controlClass: 'stack-layout-item',
|
|
endClass: 'break'
|
|
},
|
|
isNative: function () {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
var TabPanel = Panel.extend({
|
|
Defaults: {
|
|
layout: 'absolute',
|
|
defaults: { type: 'panel' }
|
|
},
|
|
activateTab: function (idx) {
|
|
var activeTabElm;
|
|
if (this.activeTabId) {
|
|
activeTabElm = this.getEl(this.activeTabId);
|
|
global$7(activeTabElm).removeClass(this.classPrefix + 'active');
|
|
activeTabElm.setAttribute('aria-selected', 'false');
|
|
}
|
|
this.activeTabId = 't' + idx;
|
|
activeTabElm = this.getEl('t' + idx);
|
|
activeTabElm.setAttribute('aria-selected', 'true');
|
|
global$7(activeTabElm).addClass(this.classPrefix + 'active');
|
|
this.items()[idx].show().fire('showtab');
|
|
this.reflow();
|
|
this.items().each(function (item, i) {
|
|
if (idx !== i) {
|
|
item.hide();
|
|
}
|
|
});
|
|
},
|
|
renderHtml: function () {
|
|
var self = this;
|
|
var layout = self._layout;
|
|
var tabsHtml = '';
|
|
var 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 += '<div id="' + id + '" class="' + prefix + 'tab" ' + 'unselectable="on" role="tab" aria-controls="' + ctrl._id + '" aria-selected="false" tabIndex="-1">' + self.encode(ctrl.settings.title) + '</div>';
|
|
});
|
|
return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + '<div id="' + self._id + '-head" class="' + prefix + 'tabs" role="tablist">' + tabsHtml + '</div>' + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>' + '</div>';
|
|
},
|
|
postRender: function () {
|
|
var self = this;
|
|
self._super();
|
|
self.settings.activeTab = self.settings.activeTab || 0;
|
|
self.activateTab(self.settings.activeTab);
|
|
this.on('click', function (e) {
|
|
var targetParent = e.target.parentNode;
|
|
if (targetParent && targetParent.id === self._id + '-head') {
|
|
var i = targetParent.childNodes.length;
|
|
while (i--) {
|
|
if (targetParent.childNodes[i] === e.target) {
|
|
self.activateTab(i);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
},
|
|
initLayoutRect: function () {
|
|
var self = this;
|
|
var rect, minW, minH;
|
|
minW = funcs.getSize(self.getEl('head')).width;
|
|
minW = minW < 0 ? 0 : minW;
|
|
minH = 0;
|
|
self.items().each(function (item) {
|
|
minW = Math.max(minW, item.layoutRect().minW);
|
|
minH = Math.max(minH, item.layoutRect().minH);
|
|
});
|
|
self.items().each(function (ctrl) {
|
|
ctrl.settings.x = 0;
|
|
ctrl.settings.y = 0;
|
|
ctrl.settings.w = minW;
|
|
ctrl.settings.h = minH;
|
|
ctrl.layoutRect({
|
|
x: 0,
|
|
y: 0,
|
|
w: minW,
|
|
h: minH
|
|
});
|
|
});
|
|
var headH = funcs.getSize(self.getEl('head')).height;
|
|
self.settings.minWidth = minW;
|
|
self.settings.minHeight = minH + headH;
|
|
rect = self._super();
|
|
rect.deltaH += headH;
|
|
rect.innerH = rect.h - rect.deltaH;
|
|
return rect;
|
|
}
|
|
});
|
|
|
|
var TextBox = Widget.extend({
|
|
init: function (settings) {
|
|
var self$$1 = this;
|
|
self$$1._super(settings);
|
|
self$$1.classes.add('textbox');
|
|
if (settings.multiline) {
|
|
self$$1.classes.add('multiline');
|
|
} else {
|
|
self$$1.on('keydown', function (e) {
|
|
var rootControl;
|
|
if (e.keyCode === 13) {
|
|
e.preventDefault();
|
|
self$$1.parents().reverse().each(function (ctrl) {
|
|
if (ctrl.toJSON) {
|
|
rootControl = ctrl;
|
|
return false;
|
|
}
|
|
});
|
|
self$$1.fire('submit', { data: rootControl.toJSON() });
|
|
}
|
|
});
|
|
self$$1.on('keyup', function (e) {
|
|
self$$1.state.set('value', e.target.value);
|
|
});
|
|
}
|
|
},
|
|
repaint: function () {
|
|
var self$$1 = this;
|
|
var style, rect, borderBox, borderW, borderH = 0, lastRepaintRect;
|
|
style = self$$1.getEl().style;
|
|
rect = self$$1._layoutRect;
|
|
lastRepaintRect = self$$1._lastRepaintRect || {};
|
|
var doc = document;
|
|
if (!self$$1.settings.multiline && doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
|
|
style.lineHeight = rect.h - borderH + 'px';
|
|
}
|
|
borderBox = self$$1.borderBox;
|
|
borderW = borderBox.left + borderBox.right + 8;
|
|
borderH = borderBox.top + borderBox.bottom + (self$$1.settings.multiline ? 8 : 0);
|
|
if (rect.x !== lastRepaintRect.x) {
|
|
style.left = rect.x + 'px';
|
|
lastRepaintRect.x = rect.x;
|
|
}
|
|
if (rect.y !== lastRepaintRect.y) {
|
|
style.top = rect.y + 'px';
|
|
lastRepaintRect.y = rect.y;
|
|
}
|
|
if (rect.w !== lastRepaintRect.w) {
|
|
style.width = rect.w - borderW + 'px';
|
|
lastRepaintRect.w = rect.w;
|
|
}
|
|
if (rect.h !== lastRepaintRect.h) {
|
|
style.height = rect.h - borderH + 'px';
|
|
lastRepaintRect.h = rect.h;
|
|
}
|
|
self$$1._lastRepaintRect = lastRepaintRect;
|
|
self$$1.fire('repaint', {}, false);
|
|
return self$$1;
|
|
},
|
|
renderHtml: function () {
|
|
var self$$1 = this;
|
|
var settings = self$$1.settings;
|
|
var attrs, elm;
|
|
attrs = {
|
|
id: self$$1._id,
|
|
hidefocus: '1'
|
|
};
|
|
global$4.each([
|
|
'rows',
|
|
'spellcheck',
|
|
'maxLength',
|
|
'size',
|
|
'readonly',
|
|
'min',
|
|
'max',
|
|
'step',
|
|
'list',
|
|
'pattern',
|
|
'placeholder',
|
|
'required',
|
|
'multiple'
|
|
], function (name$$1) {
|
|
attrs[name$$1] = settings[name$$1];
|
|
});
|
|
if (self$$1.disabled()) {
|
|
attrs.disabled = 'disabled';
|
|
}
|
|
if (settings.subtype) {
|
|
attrs.type = settings.subtype;
|
|
}
|
|
elm = funcs.create(settings.multiline ? 'textarea' : 'input', attrs);
|
|
elm.value = self$$1.state.get('value');
|
|
elm.className = self$$1.classes.toString();
|
|
return elm.outerHTML;
|
|
},
|
|
value: function (value) {
|
|
if (arguments.length) {
|
|
this.state.set('value', value);
|
|
return this;
|
|
}
|
|
if (this.state.get('rendered')) {
|
|
this.state.set('value', this.getEl().value);
|
|
}
|
|
return this.state.get('value');
|
|
},
|
|
postRender: function () {
|
|
var self$$1 = this;
|
|
self$$1.getEl().value = self$$1.state.get('value');
|
|
self$$1._super();
|
|
self$$1.$el.on('change', function (e) {
|
|
self$$1.state.set('value', e.target.value);
|
|
self$$1.fire('change', e);
|
|
});
|
|
},
|
|
bindStates: function () {
|
|
var self$$1 = this;
|
|
self$$1.state.on('change:value', function (e) {
|
|
if (self$$1.getEl().value !== e.value) {
|
|
self$$1.getEl().value = e.value;
|
|
}
|
|
});
|
|
self$$1.state.on('change:disabled', function (e) {
|
|
self$$1.getEl().disabled = e.value;
|
|
});
|
|
return self$$1._super();
|
|
},
|
|
remove: function () {
|
|
this.$el.off();
|
|
this._super();
|
|
}
|
|
});
|
|
|
|
var getApi = function () {
|
|
return {
|
|
Selector: Selector,
|
|
Collection: Collection$2,
|
|
ReflowQueue: $_cqjgb518wjjgwek2f,
|
|
Control: Control$1,
|
|
Factory: global$11,
|
|
KeyboardNavigation: KeyboardNavigation,
|
|
Container: Container,
|
|
DragHelper: DragHelper,
|
|
Scrollable: $_8woeth19ajjgwek4b,
|
|
Panel: Panel,
|
|
Movable: $_8zu82i18yjjgwek2l,
|
|
Resizable: $_20hy1119bjjgwek4f,
|
|
FloatPanel: FloatPanel,
|
|
Window: Window$$1,
|
|
MessageBox: MessageBox,
|
|
Tooltip: Tooltip,
|
|
Widget: Widget,
|
|
Progress: Progress,
|
|
Notification: Notification,
|
|
Layout: Layout$1,
|
|
AbsoluteLayout: AbsoluteLayout,
|
|
Button: Button,
|
|
ButtonGroup: ButtonGroup,
|
|
Checkbox: Checkbox,
|
|
ComboBox: ComboBox,
|
|
ColorBox: ColorBox,
|
|
PanelButton: PanelButton,
|
|
ColorButton: ColorButton,
|
|
ColorPicker: ColorPicker,
|
|
Path: Path,
|
|
ElementPath: ElementPath,
|
|
FormItem: FormItem,
|
|
Form: Form,
|
|
FieldSet: FieldSet,
|
|
FilePicker: FilePicker,
|
|
FitLayout: FitLayout,
|
|
FlexLayout: FlexLayout,
|
|
FlowLayout: FlowLayout,
|
|
FormatControls: $_gg6ikw1bejjgwekc5,
|
|
GridLayout: GridLayout,
|
|
Iframe: Iframe,
|
|
InfoBox: InfoBox,
|
|
Label: Label,
|
|
Toolbar: Toolbar$1,
|
|
MenuBar: MenuBar,
|
|
MenuButton: MenuButton,
|
|
MenuItem: MenuItem,
|
|
Throbber: Throbber,
|
|
Menu: Menu,
|
|
ListBox: ListBox,
|
|
Radio: Radio,
|
|
ResizeHandle: ResizeHandle,
|
|
SelectBox: SelectBox,
|
|
Slider: Slider,
|
|
Spacer: Spacer,
|
|
SplitButton: SplitButton,
|
|
StackLayout: StackLayout,
|
|
TabPanel: TabPanel,
|
|
TextBox: TextBox,
|
|
DropZone: DropZone,
|
|
BrowseButton: BrowseButton
|
|
};
|
|
};
|
|
var appendTo = function (target) {
|
|
if (target.ui) {
|
|
global$4.each(getApi(), function (ref, key) {
|
|
target.ui[key] = ref;
|
|
});
|
|
} else {
|
|
target.ui = getApi();
|
|
}
|
|
};
|
|
var registerToFactory = function () {
|
|
global$4.each(getApi(), function (ref, key) {
|
|
global$11.add(key, ref);
|
|
});
|
|
};
|
|
var Api = {
|
|
appendTo: appendTo,
|
|
registerToFactory: registerToFactory
|
|
};
|
|
|
|
Api.registerToFactory();
|
|
Api.appendTo(window.tinymce ? window.tinymce : {});
|
|
global.add('inlite', function (editor) {
|
|
var panel = create$3();
|
|
$_gg6ikw1bejjgwekc5.setup(editor);
|
|
$_epdxt419djjgwek4l.addToEditor(editor, panel);
|
|
return $_7y4x3k17sjjgwejyw.get(editor, panel);
|
|
});
|
|
function Theme () {
|
|
}
|
|
|
|
return Theme;
|
|
|
|
}());
|
|
})();
|