: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
}, function (item, name) {
editor.addMenuItem(name, {
editor.addMenuItem('codeformat', {
onclick: toggleFormat(editor, 'code')
var register$6 = function (editor) {
registerButtons$4(editor);
registerMenuItems$1(editor);
var SimpleControls = { register: register$6 };
var toggleUndoRedoState = function (editor, type) {
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', {
onPostRender: toggleUndoRedoState(editor, 'undo'),
editor.addMenuItem('redo', {
onPostRender: toggleUndoRedoState(editor, 'redo'),
var registerButtons$5 = function (editor) {
editor.addButton('undo', {
onPostRender: toggleUndoRedoState(editor, 'undo'),
editor.addButton('redo', {
onPostRender: toggleUndoRedoState(editor, 'redo'),
var register$7 = function (editor) {
registerMenuItems$2(editor);
registerButtons$5(editor);
var UndoRedo = { register: register$7 };
var toggleVisualAidState = function (editor) {
editor.on('VisualAid', function (e) {
self.active(e.hasVisual);
self.active(editor.hasVisual);
var registerMenuItems$3 = function (editor) {
editor.addMenuItem('visualaid', {
onPostRender: toggleVisualAidState(editor),
cmd: 'mceToggleVisualAid'
var register$8 = function (editor) {
registerMenuItems$3(editor);
var VisualAid = { 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 = descendant(Element.fromDom(domGlobals.document.body), editor.settings.ui_container).fold(constant(null), function (elm) {
var setupRtlMode = function (editor) {
var setupHideFloatPanels = function (editor) {
editor.on('mousedown progressstate', function () {
var setup = function (editor) {
setupHideFloatPanels(editor);
setupUiContainer(editor);
FormatSelect.register(editor);
SimpleControls.register(editor);
UndoRedo.register(editor);
FontSizeSelect.register(editor);
FontSelect.register(editor);
Formats.register(editor);
VisualAid.register(editor);
InsertButton.register(editor);
var FormatControls = { 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 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') {
if (alignV && typeof alignV === 'string') {
for (x = 0; x < cols; x++) {
for (y = 0; y < rows; y++) {
for (y = 0; y < rows; y++) {
for (x = 0; x < cols; x++) {
ctrl = items[y * cols + x];
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.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)) {
container.layoutRect(rect);
if (container._lastRect === null) {
var parentCtrl = container.parent();
parentCtrl._lastRect = null;
if (contLayoutRect.autoResize) {
rect = container.layoutRect(rect);
rect.contentW = rect.minW - contLayoutRect.deltaW;
rect.contentH = rect.minH - contLayoutRect.deltaH;
if (settings.packV === 'start') {
flexV = availableHeight > 0 ? Math.floor(availableHeight / rows) : 0;
var flexWidths = settings.flexWidths;
for (x = 0; x < flexWidths.length; x++) {
totalFlex += flexWidths[x];
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++) {
idx = y * cols + cols - 1 - x;
ctrlSettings = ctrl.settings;
ctrlLayoutRect = ctrl.layoutRect();
width = Math.max(colWidths[x], ctrlLayoutRect.startMinWidth);
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;
posY += height + spacingV;
var Iframe = Widget.extend({
renderHtml: function () {
self.classes.add('iframe');
return '<iframe id="' + self._id + '" class="' + self.classes + '" tabindex="-1" src="' + (self.settings.url || 'javascript:\'\'') + '" frameborder="0"></iframe>';
html: function (html, callback) {
var self = this, body = this.getEl().contentWindow.document.body;
global$3.setTimeout(function () {
var InfoBox = Widget.extend({
init: function (settings) {
self.classes.add('widget').add('infobox');
severity: function (level) {
this.classes.remove('error');
this.classes.remove('warning');
this.classes.remove('success');
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 () {
self.state.on('change:text', function (e) {
self.getEl('body').firstChild.data = self.encode(e.value);
if (self.state.get('rendered')) {
self.state.on('change:help', function (e) {
self.classes.toggle('has-help', e.value);
if (self.state.get('rendered')) {
var Label = Widget.extend({
init: function (settings) {
self.classes.add('widget').add('label');
if (settings.multiline) {
self.classes.add('autoscroll');
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);
if (!self.settings.multiline) {
self.getEl().style.lineHeight = self.layoutRect().h + 'px';
severity: function (level) {
this.classes.remove('error');
this.classes.remove('warning');
this.classes.remove('success');
renderHtml: function () {
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];
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 () {
self.state.on('change:text', function (e) {
self.innerHtml(self.encode(e.value));
if (self.state.get('rendered')) {
var Toolbar$1 = Container.extend({
init: function (settings) {
self.classes.add('toolbar');
postRender: function () {
self.items().each(function (ctrl) {
ctrl.classes.add('toolbar-item');
var MenuBar = Toolbar$1.extend({
defaults: { type: 'menubutton' }
function isChildOf$1(node, parent) {
var MenuButton = Button.extend({
init: function (settings) {
settings = self.settings;
self.classes.add('menubtn');
if (settings.fixedWidth) {
self.classes.add('fixed-width');
self.aria('haspopup', true);
self.state.set('menu', settings.menu || self.render());
showMenu: function (toggle) {
if (self.menu && self.menu.visible() && toggle !== false) {
menu = self.state.get('menu') || [];
self.classes.add('opened');
menu.type = menu.type || 'menu';
self.menu = global$b.create(menu).parent(self).renderTo();
self.menu = menu.parent(self).show().renderTo();
self.menu.on('cancel', function (e) {
if (e.control.parent() === self.menu) {
self.menu.on('select', function () {
self.menu.on('show hide', function (e) {