1(function () {
2var modern = (function (domGlobals) {
3 'use strict';
4
5 var global = tinymce.util.Tools.resolve('tinymce.ThemeManager');
6
7 var global$1 = tinymce.util.Tools.resolve('tinymce.EditorManager');
8
9 var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
10
11 var isBrandingEnabled = function (editor) {
12 return editor.getParam('branding', true, 'boolean');
13 };
14 var hasMenubar = function (editor) {
15 return getMenubar(editor) !== false;
16 };
17 var getMenubar = function (editor) {
18 return editor.getParam('menubar');
19 };
20 var hasStatusbar = function (editor) {
21 return editor.getParam('statusbar', true, 'boolean');
22 };
23 var getToolbarSize = function (editor) {
24 return editor.getParam('toolbar_items_size');
25 };
26 var isReadOnly = function (editor) {
27 return editor.getParam('readonly', false, 'boolean');
28 };
29 var getFixedToolbarContainer = function (editor) {
30 return editor.getParam('fixed_toolbar_container');
31 };
32 var getInlineToolbarPositionHandler = function (editor) {
33 return editor.getParam('inline_toolbar_position_handler');
34 };
35 var getMenu = function (editor) {
36 return editor.getParam('menu');
37 };
38 var getRemovedMenuItems = function (editor) {
39 return editor.getParam('removed_menuitems', '');
40 };
41 var getMinWidth = function (editor) {
42 return editor.getParam('min_width', 100, 'number');
43 };
44 var getMinHeight = function (editor) {
45 return editor.getParam('min_height', 100, 'number');
46 };
47 var getMaxWidth = function (editor) {
48 return editor.getParam('max_width', 65535, 'number');
49 };
50 var getMaxHeight = function (editor) {
51 return editor.getParam('max_height', 65535, 'number');
52 };
53 var isSkinDisabled = function (editor) {
54 return editor.settings.skin === false;
55 };
56 var isInline = function (editor) {
57 return editor.getParam('inline', false, 'boolean');
58 };
59 var getResize = function (editor) {
60 var resize = editor.getParam('resize', 'vertical');
61 if (resize === false) {
62 return 'none';
63 } else if (resize === 'both') {
64 return 'both';
65 } else {
66 return 'vertical';
67 }
68 };
69 var getSkinUrl = function (editor) {
70 var settings = editor.settings;
71 var skin = settings.skin;
72 var skinUrl = settings.skin_url;
73 if (skin !== false) {
74 var skinName = skin ? skin : 'lightgray';
75 if (skinUrl) {
76 skinUrl = editor.documentBaseURI.toAbsolute(skinUrl);
77 } else {
78 skinUrl = global$1.baseURL + '/skins/' + skinName;
79 }
80 }
81 return skinUrl;
82 };
83 var getIndexedToolbars = function (settings, defaultToolbar) {
84 var toolbars = [];
85 for (var i = 1; i < 10; i++) {
86 var toolbar = settings['toolbar' + i];
87 if (!toolbar) {
88 break;
89 }
90 toolbars.push(toolbar);
91 }
92 var mainToolbar = settings.toolbar ? [settings.toolbar] : [defaultToolbar];
93 return toolbars.length > 0 ? toolbars : mainToolbar;
94 };
95 var getToolbars = function (editor) {
96 var toolbar = editor.getParam('toolbar');
97 var defaultToolbar = 'undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image';
98 if (toolbar === false) {
99 return [];
100 } else if (global$2.isArray(toolbar)) {
101 return global$2.grep(toolbar, function (toolbar) {
102 return toolbar.length > 0;
103 });
104 } else {
105 return getIndexedToolbars(editor.settings, defaultToolbar);
106 }
107 };
108
109 var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
110
111 var global$4 = tinymce.util.Tools.resolve('tinymce.ui.Factory');
112
113 var global$5 = tinymce.util.Tools.resolve('tinymce.util.I18n');
114
115 var fireSkinLoaded = function (editor) {
116 return editor.fire('SkinLoaded');
117 };
118 var fireResizeEditor = function (editor) {
119 return editor.fire('ResizeEditor');
120 };
121 var fireBeforeRenderUI = function (editor) {
122 return editor.fire('BeforeRenderUI');
123 };
124 var Events = {
125 fireSkinLoaded: fireSkinLoaded,
126 fireResizeEditor: fireResizeEditor,
127 fireBeforeRenderUI: fireBeforeRenderUI
128 };
129
130 var focus = function (panel, type) {
131 return function () {
132 var item = panel.find(type)[0];
133 if (item) {
134 item.focus(true);
135 }
136 };
137 };
138 var addKeys = function (editor, panel) {
139 editor.shortcuts.add('Alt+F9', '', focus(panel, 'menubar'));
140 editor.shortcuts.add('Alt+F10,F10', '', focus(panel, 'toolbar'));
141 editor.shortcuts.add('Alt+F11', '', focus(panel, 'elementpath'));
142 panel.on('cancel', function () {
143 editor.focus();
144 });
145 };
146 var A11y = { addKeys: addKeys };
147
148 var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
149
150 var global$7 = tinymce.util.Tools.resolve('tinymce.util.Delay');
151
152 var noop = function () {
153 };
154 var constant = function (value) {
155 return function () {
156 return value;
157 };
158 };
159 var never = constant(false);
160 var always = constant(true);
161
162 var none = function () {
163 return NONE;
164 };
165 var NONE = function () {
166 var eq = function (o) {
167 return o.isNone();
168 };
169 var call = function (thunk) {
170 return thunk();
171 };
172 var id = function (n) {
173 return n;
174 };
175 var me = {
176 fold: function (n, s) {
177 return n();
178 },
179 is: never,
180 isSome: never,
181 isNone: always,
182 getOr: id,
183 getOrThunk: call,
184 getOrDie: function (msg) {
185 throw new Error(msg || 'error: getOrDie called on none.');
186 },
187 getOrNull: constant(null),
188 getOrUndefined: constant(undefined),
189 or: id,
190 orThunk: call,
191 map: none,
192 each: noop,
193 bind: none,
194 exists: never,
195 forall: always,
196 filter: none,
197 equals: eq,
198 equals_: eq,
199 toArray: function () {
200 return [];
201 },
202 toString: constant('none()')
203 };
204 if (Object.freeze) {
205 Object.freeze(me);
206 }
207 return me;
208 }();
209 var some = function (a) {
210 var constant_a = constant(a);
211 var self = function () {
212 return me;
213 };
214 var bind = function (f) {
215 return f(a);
216 };
217 var me = {
218 fold: function (n, s) {
219 return s(a);
220 },
221 is: function (v) {
222 return a === v;
223 },
224 isSome: always,
225 isNone: never,
226 getOr: constant_a,
227 getOrThunk: constant_a,
228 getOrDie: constant_a,
229 getOrNull: constant_a,
230 getOrUndefined: constant_a,
231 or: self,
232 orThunk: self,
233 map: function (f) {
234 return some(f(a));
235 },
236 each: function (f) {
237 f(a);
238 },
239 bind: bind,
240 exists: bind,
241 forall: bind,
242 filter: function (f) {
243 return f(a) ? me : NONE;
244 },
245 toArray: function () {
246 return [a];
247 },
248 toString: function () {
249 return 'some(' + a + ')';
250 },
251 equals: function (o) {
252 return o.is(a);
253 },
254 equals_: function (o, elementEq) {
255 return o.fold(never, function (b) {
256 return elementEq(a, b);
257 });
258 }
259 };
260 return me;
261 };
262 var from = function (value) {
263 return value === null || value === undefined ? NONE : some(value);
264 };
265 var Option = {
266 some: some,
267 none: none,
268 from: from
269 };
270
271 var getUiContainerDelta = function (ctrl) {
272 var uiContainer = getUiContainer(ctrl);
273 if (uiContainer && global$3.DOM.getStyle(uiContainer, 'position', true) !== 'static') {
274 var containerPos = global$3.DOM.getPos(uiContainer);
275 var dx = uiContainer.scrollLeft - containerPos.x;
276 var dy = uiContainer.scrollTop - containerPos.y;
277 return Option.some({
278 x: dx,
279 y: dy
280 });
281 } else {
282 return Option.none();
283 }
284 };
285 var setUiContainer = function (editor, ctrl) {
286 var uiContainer = global$3.DOM.select(editor.settings.ui_container)[0];
287 ctrl.getRoot().uiContainer = uiContainer;
288 };
289 var getUiContainer = function (ctrl) {
290 return ctrl ? ctrl.getRoot().uiContainer : null;
291 };
292 var inheritUiContainer = function (fromCtrl, toCtrl) {
293 return toCtrl.uiContainer = getUiContainer(fromCtrl);
294 };
295 var UiContainer = {
296 getUiContainerDelta: getUiContainerDelta,
297 setUiContainer: setUiContainer,
298 getUiContainer: getUiContainer,
299 inheritUiContainer: inheritUiContainer
300 };
301
302 var createToolbar = function (editor, items, size) {
303 var toolbarItems = [];
304 var buttonGroup;
305 if (!items) {
306 return;
307 }
308 global$2.each(items.split(/[ ,]/), function (item) {
309 var itemName;
310 var bindSelectorChanged = function () {
311 var selection = editor.selection;
312 if (item.settings.stateSelector) {
313 selection.selectorChanged(item.settings.stateSelector, function (state) {
314 item.active(state);
315 }, true);
316 }
317 if (item.settings.disabledStateSelector) {
318 selection.selectorChanged(item.settings.disabledStateSelector, function (state) {
319 item.disabled(state);
320 });
321 }
322 };
323 if (item === '|') {
324 buttonGroup = null;
325 } else {
326 if (!buttonGroup) {
327 buttonGroup = {
328 type: 'buttongroup',
329 items: []
330 };
331 toolbarItems.push(buttonGroup);
332 }
333 if (editor.buttons[item]) {
334 itemName = item;
335 item = editor.buttons[itemName];
336 if (typeof item === 'function') {
337 item = item();
338 }
339 item.type = item.type || 'button';
340 item.size = size;
341 item = global$4.create(item);
342 buttonGroup.items.push(item);
343 if (editor.initialized) {
344 bindSelectorChanged();
345 } else {
346 editor.on('init', bindSelectorChanged);
347 }
348 }
349 }
350 });
351 return {
352 type: 'toolbar',
353 layout: 'flow',
354 items: toolbarItems
355 };
356 };
357 var createToolbars = function (editor, size) {
358 var toolbars = [];
359 var addToolbar = function (items) {
360 if (items) {
361 toolbars.push(createToolbar(editor, items, size));
362 }
363 };
364 global$2.each(getToolbars(editor), function (toolbar) {
365 addToolbar(toolbar);
366 });
367 if (toolbars.length) {
368 return {
369 type: 'panel',
370 layout: 'stack',
371 classes: 'toolbar-grp',
372 ariaRoot: true,
373 ariaRemember: true,
374 items: toolbars
375 };
376 }
377 };
378 var Toolbar = {
379 createToolbar: createToolbar,
380 createToolbars: createToolbars
381 };
382
383 var DOM = global$3.DOM;
384 var toClientRect = function (geomRect) {
385 return {
386 left: geomRect.x,
387 top: geomRect.y,
388 width: geomRect.w,
389 height: geomRect.h,
390 right: geomRect.x + geomRect.w,
391 bottom: geomRect.y + geomRect.h
392 };
393 };
394 var hideAllFloatingPanels = function (editor) {
395 global$2.each(editor.contextToolbars, function (toolbar) {
396 if (toolbar.panel) {
397 toolbar.panel.hide();
398 }
399 });
400 };
401 var movePanelTo = function (panel, pos) {
402 panel.moveTo(pos.left, pos.top);
403 };
404 var togglePositionClass = function (panel, relPos, predicate) {
405 relPos = relPos ? relPos.substr(0, 2) : '';
406 global$2.each({
407 t: 'down',
408 b: 'up'
409 }, function (cls, pos) {
410 panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(0, 1)));
411 });
412 global$2.each({
413 l: 'left',
414 r: 'right'
415 }, function (cls, pos) {
416 panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(1, 1)));
417 });
418 };
419 var userConstrain = function (handler, x, y, elementRect, contentAreaRect, panelRect) {
420 panelRect = toClientRect({
421 x: x,
422 y: y,
423 w: panelRect.w,
424 h: panelRect.h
425 });
426 if (handler) {
427 panelRect = handler({
428 elementRect: toClientRect(elementRect),
429 contentAreaRect: toClientRect(contentAreaRect),
430 panelRect: panelRect
431 });
432 }
433 return panelRect;
434 };
435 var addContextualToolbars = function (editor) {
436 var scrollContainer;
437 var getContextToolbars = function () {
438 return editor.contextToolbars || [];
439 };
440 var getElementRect = function (elm) {
441 var pos, targetRect, root;
442 pos = DOM.getPos(editor.getContentAreaContainer());
443 targetRect = editor.dom.getRect(elm);
444 root = editor.dom.getRoot();
445 if (root.nodeName === 'BODY') {
446 targetRect.x -= root.ownerDocument.documentElement.scrollLeft || root.scrollLeft;
447 targetRect.y -= root.ownerDocument.documentElement.scrollTop || root.scrollTop;
448 }
449 targetRect.x += pos.x;
450 targetRect.y += pos.y;
451 return targetRect;
452 };
453 var reposition = function (match, shouldShow) {
454 var relPos, panelRect, elementRect, contentAreaRect, panel, relRect, testPositions, smallElementWidthThreshold;
455 var handler = getInlineToolbarPositionHandler(editor);
456 if (editor.removed) {
457 return;
458 }
459 if (!match || !match.toolbar.panel) {
460 hideAllFloatingPanels(editor);
461 return;
462 }
463 testPositions = [
464 'bc-tc',
465 'tc-bc',
466 'tl-bl',
467 'bl-tl',
468 'tr-br',
469 'br-tr'
470 ];
471 panel = match.toolbar.panel;
472 if (shouldShow) {
473 panel.show();
474 }
475 elementRect = getElementRect(match.element);
476 panelRect = DOM.getRect(panel.getEl());
477 contentAreaRect = DOM.getRect(editor.getContentAreaContainer() || editor.getBody());
478 var delta = UiContainer.getUiContainerDelta(panel).getOr({
479 x: 0,
480 y: 0
481 });
482 elementRect.x += delta.x;
483 elementRect.y += delta.y;
484 panelRect.x += delta.x;
485 panelRect.y += delta.y;
486 contentAreaRect.x += delta.x;
487 contentAreaRect.y += delta.y;
488 smallElementWidthThreshold = 25;
489 if (DOM.getStyle(match.element, 'display', true) !== 'inline') {
490 var clientRect = match.element.getBoundingClientRect();
491 elementRect.w = clientRect.width;
492 elementRect.h = clientRect.height;
493 }
494 if (!editor.inline) {
495 contentAreaRect.w = editor.getDoc().documentElement.offsetWidth;
496 }
497 if (editor.selection.controlSelection.isResizable(match.element) && elementRect.w < smallElementWidthThreshold) {
498 elementRect = global$6.inflate(elementRect, 0, 8);
499 }
500 relPos = global$6.findBestRelativePosition(panelRect, elementRect, contentAreaRect, testPositions);
501 elementRect = global$6.clamp(elementRect, contentAreaRect);
502 if (relPos) {
503 relRect = global$6.relativePosition(panelRect, elementRect, relPos);
504 movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect));
505 } else {
506 contentAreaRect.h += panelRect.h;
507 elementRect = global$6.intersect(contentAreaRect, elementRect);
508 if (elementRect) {
509 relPos = global$6.findBestRelativePosition(panelRect, elementRect, contentAreaRect, [
510 'bc-tc',
511 'bl-tl',
512 'br-tr'
513 ]);
514 if (relPos) {
515 relRect = global$6.relativePosition(panelRect, elementRect, relPos);
516 movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect));
517 } else {
518 movePanelTo(panel, userConstrain(handler, elementRect.x, elementRect.y, elementRect, contentAreaRect, panelRect));
519 }
520 } else {
521 panel.hide();
522 }
523 }
524 togglePositionClass(panel, relPos, function (pos1, pos2) {
525 return pos1 === pos2;
526 });
527 };
528 var repositionHandler = function (show) {
529 return function () {
530 var execute = function () {
531 if (editor.selection) {
532 reposition(findFrontMostMatch(editor.selection.getNode()), show);
533 }
534 };
535 global$7.requestAnimationFrame(execute);
536 };
537 };
538 var bindScrollEvent = function (panel) {
539 if (!scrollContainer) {
540 var reposition_1 = repositionHandler(true);
541 var uiContainer_1 = UiContainer.getUiContainer(panel);
542 scrollContainer = editor.selection.getScrollContainer() || editor.getWin();
543 DOM.bind(scrollContainer, 'scroll', reposition_1);
544 DOM.bind(uiContainer_1, 'scroll', reposition_1);
545 editor.on('remove', function () {
546 DOM.unbind(scrollContainer, 'scroll', reposition_1);
547 DOM.unbind(uiContainer_1, 'scroll', reposition_1);
548 });
549 }
550 };
551 var showContextToolbar = function (match) {
552 var panel;
553 if (match.toolbar.panel) {
554 match.toolbar.panel.show();
555 reposition(match);
556 return;
557 }
558 panel = global$4.create({
559 type: 'floatpanel',
560 role: 'dialog',
561 classes: 'tinymce tinymce-inline arrow',
562 ariaLabel: 'Inline toolbar',
563 layout: 'flex',
564 direction: 'column',
565 align: 'stretch',
566 autohide: false,
567 autofix: true,
568 fixed: true,
569 border: 1,
570 items: Toolbar.createToolbar(editor, match.toolbar.items),
571 oncancel: function () {
572 editor.focus();
573 }
574 });
575 UiContainer.setUiContainer(editor, panel);
576 bindScrollEvent(panel);
577 match.toolbar.panel = panel;
578 panel.renderTo().reflow();
579 reposition(match);
580 };
581 var hideAllContextToolbars = function () {
582 global$2.each(getContextToolbars(), function (toolbar) {
583 if (toolbar.panel) {
584 toolbar.panel.hide();
585 }
586 });
587 };
588 var findFrontMostMatch = function (targetElm) {
589 var i, y, parentsAndSelf;
590 var toolbars = getContextToolbars();
591 parentsAndSelf = editor.$(targetElm).parents().add(targetElm);
592 for (i = parentsAndSelf.length - 1; i >= 0; i--) {
593 for (y = toolbars.length - 1; y >= 0; y--) {
594 if (toolbars[y].predicate(parentsAndSelf[i])) {
595 return {
596 toolbar: toolbars[y],
597 element: parentsAndSelf[i]
598 };
599 }
600 }
601 }
602 return null;
603 };
604 editor.on('click keyup setContent ObjectResized', function (e) {
605 if (e.type === 'setcontent' && !e.selection) {
606 return;
607 }
608 global$7.setEditorTimeout(editor, function () {
609 var match;
610 match = findFrontMostMatch(editor.selection.getNode());
611 if (match) {
612 hideAllContextToolbars();
613 showContextToolbar(match);
614 } else {
615 hideAllContextToolbars();
616 }
617 });
618 });
619 editor.on('blur hide contextmenu', hideAllContextToolbars);
620 editor.on('ObjectResizeStart', function () {
621 var match = findFrontMostMatch(editor.selection.getNode());
622 if (match && match.toolbar.panel) {
623 match.toolbar.panel.hide();
624 }
625 });
626 editor.on('ResizeEditor ResizeWindow', repositionHandler(true));
627 editor.on('nodeChange', repositionHandler(false));
628 editor.on('remove', function () {
629 global$2.each(getContextToolbars(), function (toolbar) {
630 if (toolbar.panel) {
631 toolbar.panel.remove();
632 }
633 });
634 editor.contextToolbars = {};
635 });
636 editor.shortcuts.add('ctrl+F9', '', function () {
637 var match = findFrontMostMatch(editor.selection.getNode());
638 if (match && match.toolbar.panel) {
639 match.toolbar.panel.items()[0].focus();
640 }
641 });
642 };
643 var ContextToolbars = { addContextualToolbars: addContextualToolbars };
644
645 var typeOf = function (x) {
646 if (x === null) {
647 return 'null';
648 }
649 var t = typeof x;
650 if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
651 return 'array';
652 }
653 if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
654 return 'string';
655 }
656 return t;
657 };
658 var isType = function (type) {
659 return function (value) {
660 return typeOf(value) === type;
661 };
662 };
663 var isArray = isType('array');
664 var isFunction = isType('function');
665 var isNumber = isType('number');
666
667 var nativeSlice = Array.prototype.slice;
668 var nativeIndexOf = Array.prototype.indexOf;
669 var nativePush = Array.prototype.push;
670 var rawIndexOf = function (ts, t) {
671 return nativeIndexOf.call(ts, t);
672 };
673 var indexOf = function (xs, x) {
674 var r = rawIndexOf(xs, x);
675 return r === -1 ? Option.none() : Option.some(r);
676 };
677 var exists = function (xs, pred) {
678 for (var i = 0, len = xs.length; i < len; i++) {
679 var x = xs[i];
680 if (pred(x, i)) {
681 return true;
682 }
683 }
684 return false;
685 };
686 var map = function (xs, f) {
687 var len = xs.length;
688 var r = new Array(len);
689 for (var i = 0; i < len; i++) {
690 var x = xs[i];
691 r[i] = f(x, i);
692 }
693 return r;
694 };
695 var each = function (xs, f) {
696 for (var i = 0, len = xs.length; i < len; i++) {
697 var x = xs[i];
698 f(x, i);
699 }
700 };
701 var filter = function (xs, pred) {
702 var r = [];
703 for (var i = 0, len = xs.length; i < len; i++) {
704 var x = xs[i];
705 if (pred(x, i)) {
706 r.push(x);
707 }
708 }
709 return r;
710 };
711 var foldl = function (xs, f, acc) {
712 each(xs, function (x) {
713 acc = f(acc, x);
714 });
715 return acc;
716 };
717 var find = function (xs, pred) {
718 for (var i = 0, len = xs.length; i < len; i++) {
719 var x = xs[i];
720 if (pred(x, i)) {
721 return Option.some(x);
722 }
723 }
724 return Option.none();
725 };
726 var findIndex = function (xs, pred) {
727 for (var i = 0, len = xs.length; i < len; i++) {
728 var x = xs[i];
729 if (pred(x, i)) {
730 return Option.some(i);
731 }
732 }
733 return Option.none();
734 };
735 var flatten = function (xs) {
736 var r = [];
737 for (var i = 0, len = xs.length; i < len; ++i) {
738 if (!isArray(xs[i])) {
739 throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
740 }
741 nativePush.apply(r, xs[i]);
742 }
743 return r;
744 };
745 var from$1 = isFunction(Array.from) ? Array.from : function (x) {
746 return nativeSlice.call(x);
747 };
748
749 var defaultMenus = {
750 file: {
751 title: 'File',
752 items: 'newdocument restoredraft | preview | print'
753 },
754 edit: {
755 title: 'Edit',
756 items: 'undo redo | cut copy paste pastetext | selectall'
757 },
758 view: {
759 title: 'View',
760 items: 'code | visualaid visualchars visualblocks | spellchecker | preview fullscreen'
761 },
762 insert: {
763 title: 'Insert',
764 items: 'image link media template codesample inserttable | charmap hr | pagebreak nonbreaking anchor toc | insertdatetime'
765 },
766 format: {
767 title: 'Format',
768 items: 'bold italic underline strikethrough superscript subscript codeformat | blockformats align | removeformat'
769 },
770 tools: {
771 title: 'Tools',
772 items: 'spellchecker spellcheckerlanguage | a11ycheck code'
773 },
774 table: { title: 'Table' },
775 help: { title: 'Help' }
776 };
777 var delimiterMenuNamePair = function () {
778 return {
779 name: '|',
780 item: { text: '|' }
781 };
782 };
783 var createMenuNameItemPair = function (name, item) {
784 var menuItem = item ? {
785 name: name,
786 item: item
787 } : null;
788 return name === '|' ? delimiterMenuNamePair() : menuItem;
789 };
790 var hasItemName = function (namedMenuItems, name) {
791 return findIndex(namedMenuItems, function (namedMenuItem) {
792 return namedMenuItem.name === name;
793 }).isSome();
794 };
795 var isSeparator = function (namedMenuItem) {
796 return namedMenuItem && namedMenuItem.item.text === '|';
797 };
798 var cleanupMenu = function (namedMenuItems, removedMenuItems) {
799 var menuItemsPass1 = filter(namedMenuItems, function (namedMenuItem) {
800 return removedMenuItems.hasOwnProperty(namedMenuItem.name) === false;
801 });
802 var menuItemsPass2 = filter(menuItemsPass1, function (namedMenuItem, i) {
803 return !isSeparator(namedMenuItem) || !isSeparator(menuItemsPass1[i - 1]);
804 });
805 return filter(menuItemsPass2, function (namedMenuItem, i) {
806 return !isSeparator(namedMenuItem) || i > 0 && i < menuItemsPass2.length - 1;
807 });
808 };
809 var createMenu = function (editorMenuItems, menus, removedMenuItems, context) {
810 var menuButton, menu, namedMenuItems, isUserDefined;
811 if (menus) {
812 menu = menus[context];
813 isUserDefined = true;
814 } else {
815 menu = defaultMenus[context];
816 }
817 if (menu) {
818 menuButton = { text: menu.title };
819 namedMenuItems = [];
820 global$2.each((menu.items || '').split(/[ ,]/), function (name) {
821 var namedMenuItem = createMenuNameItemPair(name, editorMenuItems[name]);
822 if (namedMenuItem) {
823 namedMenuItems.push(namedMenuItem);
824 }
825 });
826 if (!isUserDefined) {
827 global$2.each(editorMenuItems, function (item, name) {
828 if (item.context === context && !hasItemName(namedMenuItems, name)) {
829 if (item.separator === 'before') {
830 namedMenuItems.push(delimiterMenuNamePair());
831 }
832 if (item.prependToContext) {
833 namedMenuItems.unshift(createMenuNameItemPair(name, item));
834 } else {
835 namedMenuItems.push(createMenuNameItemPair(name, item));
836 }
837 if (item.separator === 'after') {
838 namedMenuItems.push(delimiterMenuNamePair());
839 }
840 }
841 });
842 }
843 menuButton.menu = map(cleanupMenu(namedMenuItems, removedMenuItems), function (menuItem) {
844 return menuItem.item;
845 });
846 if (!menuButton.menu.length) {
847 return null;
848 }
849 }
850 return menuButton;
851 };
852 var getDefaultMenubar = function (editor) {
853 var name;
854 var defaultMenuBar = [];
855 var menu = getMenu(editor);
856 if (menu) {
857 for (name in menu) {
858 defaultMenuBar.push(name);
859 }
860 } else {
861 for (name in defaultMenus) {
862 defaultMenuBar.push(name);
863 }
864 }
865 return defaultMenuBar;
866 };
867 var createMenuButtons = function (editor) {
868 var menuButtons = [];
869 var defaultMenuBar = getDefaultMenubar(editor);
870 var removedMenuItems = global$2.makeMap(getRemovedMenuItems(editor).split(/[ ,]/));
871 var menubar = getMenubar(editor);
872 var enabledMenuNames = typeof menubar === 'string' ? menubar.split(/[ ,]/) : defaultMenuBar;
873 for (var i = 0; i < enabledMenuNames.length; i++) {
874 var menuItems = enabledMenuNames[i];
875 var menu = createMenu(editor.menuItems, getMenu(editor), removedMenuItems, menuItems);
876 if (menu) {
877 menuButtons.push(menu);
878 }
879 }
880 return menuButtons;
881 };
882 var Menubar = { createMenuButtons: createMenuButtons };
883
884 var DOM$1 = global$3.DOM;
885 var getSize = function (elm) {
886 return {
887 width: elm.clientWidth,
888 height: elm.clientHeight
889 };
890 };
891 var resizeTo = function (editor, width, height) {
892 var containerElm, iframeElm, containerSize, iframeSize;
893 containerElm = editor.getContainer();
894 iframeElm = editor.getContentAreaContainer().firstChild;
895 containerSize = getSize(containerElm);
896 iframeSize = getSize(iframeElm);
897 if (width !== null) {
898 width = Math.max(getMinWidth(editor), width);
899 width = Math.min(getMaxWidth(editor), width);
900 DOM$1.setStyle(containerElm, 'width', width + (containerSize.width - iframeSize.width));
901 DOM$1.setStyle(iframeElm, 'width', width);
902 }
903 height = Math.max(getMinHeight(editor), height);
904 height = Math.min(getMaxHeight(editor), height);
905 DOM$1.setStyle(iframeElm, 'height', height);
906 Events.fireResizeEditor(editor);
907 };
908 var resizeBy = function (editor, dw, dh) {
909 var elm = editor.getContentAreaContainer();
910 resizeTo(editor, elm.clientWidth + dw, elm.clientHeight + dh);
911 };
912 var Resize = {
913 resizeTo: resizeTo,
914 resizeBy: resizeBy
915 };
916
917 var global$8 = tinymce.util.Tools.resolve('tinymce.Env');
918
919 var api = function (elm) {
920 return {
921 element: function () {
922 return elm;
923 }
924 };
925 };
926 var trigger = function (sidebar, panel, callbackName) {
927 var callback = sidebar.settings[callbackName];
928 if (callback) {
929 callback(api(panel.getEl('body')));
930 }
931 };
932 var hidePanels = function (name, container, sidebars) {
933 global$2.each(sidebars, function (sidebar) {
934 var panel = container.items().filter('#' + sidebar.name)[0];
935 if (panel && panel.visible() && sidebar.name !== name) {
936 trigger(sidebar, panel, 'onhide');
937 panel.visible(false);
938 }
939 });
940 };
941 var deactivateButtons = function (toolbar) {
942 toolbar.items().each(function (ctrl) {
943 ctrl.active(false);
944 });
945 };
946 var findSidebar = function (sidebars, name) {
947 return global$2.grep(sidebars, function (sidebar) {
948 return sidebar.name === name;
949 })[0];
950 };
951 var showPanel = function (editor, name, sidebars) {
952 return function (e) {
953 var btnCtrl = e.control;
954 var container = btnCtrl.parents().filter('panel')[0];
955 var panel = container.find('#' + name)[0];
956 var sidebar = findSidebar(sidebars, name);
957 hidePanels(name, container, sidebars);
958 deactivateButtons(btnCtrl.parent());
959 if (panel && panel.visible()) {
960 trigger(sidebar, panel, 'onhide');
961 panel.hide();
962 btnCtrl.active(false);
963 } else {
964 if (panel) {
965 panel.show();
966 trigger(sidebar, panel, 'onshow');
967 } else {
968 panel = global$4.create({
969 type: 'container',
970 name: name,
971 layout: 'stack',
972 classes: 'sidebar-panel',
973 html: ''
974 });
975 container.prepend(panel);
976 trigger(sidebar, panel, 'onrender');
977 trigger(sidebar, panel, 'onshow');
978 }
979 btnCtrl.active(true);
980 }
981 Events.fireResizeEditor(editor);
982 };
983 };
984 var isModernBrowser = function () {
985 return !global$8.ie || global$8.ie >= 11;
986 };
987 var hasSidebar = function (editor) {
988 return isModernBrowser() && editor.sidebars ? editor.sidebars.length > 0 : false;
989 };
990 var createSidebar = function (editor) {
991 var buttons = global$2.map(editor.sidebars, function (sidebar) {
992 var settings = sidebar.settings;
993 return {
994 type: 'button',
995 icon: settings.icon,
996 image: settings.image,
997 tooltip: settings.tooltip,
998 onclick: showPanel(editor, sidebar.name, editor.sidebars)
999 };
1000 });
1001 return {
1002 type: 'panel',
1003 name: 'sidebar',
1004 layout: 'stack',
1005 classes: 'sidebar',
1006 items: [{
1007 type: 'toolbar',
1008 layout: 'stack',
1009 classes: 'sidebar-toolbar',
1010 items: buttons
1011 }]
1012 };
1013 };
1014 var Sidebar = {
1015 hasSidebar: hasSidebar,
1016 createSidebar: createSidebar
1017 };
1018
1019 var fireSkinLoaded$1 = function (editor) {
1020 var done = function () {
1021 editor._skinLoaded = true;
1022 Events.fireSkinLoaded(editor);
1023 };
1024 return function () {
1025 if (editor.initialized) {
1026 done();
1027 } else {
1028 editor.on('init', done);
1029 }
1030 };
1031 };
1032 var SkinLoaded = { fireSkinLoaded: fireSkinLoaded$1 };
1033
1034 var DOM$2 = global$3.DOM;
1035 var switchMode = function (panel) {
1036 return function (e) {
1037 panel.find('*').disabled(e.mode === 'readonly');
1038 };
1039 };
1040 var editArea = function (border) {
1041 return {
1042 type: 'panel',
1043 name: 'iframe',
1044 layout: 'stack',
1045 classes: 'edit-area',
1046 border: border,
1047 html: ''
1048 };
1049 };
1050 var editAreaContainer = function (editor) {
1051 return {
1052 type: 'panel',
1053 layout: 'stack',
1054 classes: 'edit-aria-container',
1055 border: '1 0 0 0',
1056 items: [
1057 editArea('0'),
1058 Sidebar.createSidebar(editor)
1059 ]
1060 };
1061 };
1062 var render = function (editor, theme, args) {
1063 var panel, resizeHandleCtrl, startSize;
1064 if (isSkinDisabled(editor) === false && args.skinUiCss) {
1065 DOM$2.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor));
1066 } else {
1067 SkinLoaded.fireSkinLoaded(editor)();
1068 }
1069 panel = theme.panel = global$4.create({
1070 type: 'panel',
1071 role: 'application',
1072 classes: 'tinymce',
1073 style: 'visibility: hidden',
1074 layout: 'stack',
1075 border: 1,
1076 items: [
1077 {
1078 type: 'container',
1079 classes: 'top-part',
1080 items: [
1081 hasMenubar(editor) === false ? null : {
1082 type: 'menubar',
1083 border: '0 0 1 0',
1084 items: Menubar.createMenuButtons(editor)
1085 },
1086 Toolbar.createToolbars(editor, getToolbarSize(editor))
1087 ]
1088 },
1089 Sidebar.hasSidebar(editor) ? editAreaContainer(editor) : editArea('1 0 0 0')
1090 ]
1091 });
1092 UiContainer.setUiContainer(editor, panel);
1093 if (getResize(editor) !== 'none') {
1094 resizeHandleCtrl = {
1095 type: 'resizehandle',
1096 direction: getResize(editor),
1097 onResizeStart: function () {
1098 var elm = editor.getContentAreaContainer().firstChild;
1099 startSize = {
1100 width: elm.clientWidth,
1101 height: elm.clientHeight
1102 };
1103 },
1104 onResize: function (e) {
1105 if (getResize(editor) === 'both') {
1106 Resize.resizeTo(editor, startSize.width + e.deltaX, startSize.height + e.deltaY);
1107 } else {
1108 Resize.resizeTo(editor, null, startSize.height + e.deltaY);
1109 }
1110 }
1111 };
1112 }
1113 if (hasStatusbar(editor)) {
1114 var linkHtml = '<a href="https://www.tiny.cloud/?utm_campaign=editor_referral&utm_medium=poweredby&utm_source=tinymce" rel="noopener" target="_blank" role="presentation" tabindex="-1">Tiny</a>';
1115 var html = global$5.translate([
1116 'Powered by {0}',
1117 linkHtml
1118 ]);
1119 var brandingLabel = isBrandingEnabled(editor) ? {
1120 type: 'label',
1121 classes: 'branding',
1122 html: ' ' + html
1123 } : null;
1124 panel.add({
1125 type: 'panel',
1126 name: 'statusbar',
1127 classes: 'statusbar',
1128 layout: 'flow',
1129 border: '1 0 0 0',
1130 ariaRoot: true,
1131 items: [
1132 {
1133 type: 'elementpath',
1134 editor: editor
1135 },
1136 resizeHandleCtrl,
1137 brandingLabel
1138 ]
1139 });
1140 }
1141 Events.fireBeforeRenderUI(editor);
1142 editor.on('SwitchMode', switchMode(panel));
1143 panel.renderBefore(args.targetNode).reflow();
1144 if (isReadOnly(editor)) {
1145 editor.setMode('readonly');
1146 }
1147 if (args.width) {
1148 DOM$2.setStyle(panel.getEl(), 'width', args.width);
1149 }
1150 editor.on('remove', function () {
1151 panel.remove();
1152 panel = null;
1153 });
1154 A11y.addKeys(editor, panel);
1155 ContextToolbars.addContextualToolbars(editor);
1156 return {
1157 iframeContainer: panel.find('#iframe')[0].getEl(),
1158 editorContainer: panel.getEl()
1159 };
1160 };
1161 var Iframe = { render: render };
1162
1163 var global$9 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
1164
1165 var count = 0;
1166 var funcs = {
1167 id: function () {
1168 return 'mceu_' + count++;
1169 },
1170 create: function (name, attrs, children) {
1171 var elm = domGlobals.document.createElement(name);
1172 global$3.DOM.setAttribs(elm, attrs);
1173 if (typeof children === 'string') {
1174 elm.innerHTML = children;
1175 } else {
1176 global$2.each(children, function (child) {
1177 if (child.nodeType) {
1178 elm.appendChild(child);
1179 }
1180 });
1181 }
1182 return elm;
1183 },
1184 createFragment: function (html) {
1185 return global$3.DOM.createFragment(html);
1186 },
1187 getWindowSize: function () {
1188 return global$3.DOM.getViewPort();
1189 },
1190 getSize: function (elm) {
1191 var width, height;
1192 if (elm.getBoundingClientRect) {
1193 var rect = elm.getBoundingClientRect();
1194 width = Math.max(rect.width || rect.right - rect.left, elm.offsetWidth);
1195 height = Math.max(rect.height || rect.bottom - rect.bottom, elm.offsetHeight);
1196 } else {
1197 width = elm.offsetWidth;
1198 height = elm.offsetHeight;
1199 }
1200 return {
1201 width: width,
1202 height: height
1203 };
1204 },
1205 getPos: function (elm, root) {
1206 return global$3.DOM.getPos(elm, root || funcs.getContainer());
1207 },
1208 getContainer: function () {
1209 return global$8.container ? global$8.container : domGlobals.document.body;
1210 },
1211 getViewPort: function (win) {
1212 return global$3.DOM.getViewPort(win);
1213 },
1214 get: function (id) {
1215 return domGlobals.document.getElementById(id);
1216 },
1217 addClass: function (elm, cls) {
1218 return global$3.DOM.addClass(elm, cls);
1219 },
1220 removeClass: function (elm, cls) {
1221 return global$3.DOM.removeClass(elm, cls);
1222 },
1223 hasClass: function (elm, cls) {
1224 return global$3.DOM.hasClass(elm, cls);
1225 },
1226 toggleClass: function (elm, cls, state) {
1227 return global$3.DOM.toggleClass(elm, cls, state);
1228 },
1229 css: function (elm, name, value) {
1230 return global$3.DOM.setStyle(elm, name, value);
1231 },
1232 getRuntimeStyle: function (elm, name) {
1233 return global$3.DOM.getStyle(elm, name, true);
1234 },
1235 on: function (target, name, callback, scope) {
1236 return global$3.DOM.bind(target, name, callback, scope);
1237 },
1238 off: function (target, name, callback) {
1239 return global$3.DOM.unbind(target, name, callback);
1240 },
1241 fire: function (target, name, args) {
1242 return global$3.DOM.fire(target, name, args);
1243 },
1244 innerHtml: function (elm, html) {
1245 global$3.DOM.setHTML(elm, html);
1246 }
1247 };
1248
1249 var isStatic = function (elm) {
1250 return funcs.getRuntimeStyle(elm, 'position') === 'static';
1251 };
1252 var isFixed = function (ctrl) {
1253 return ctrl.state.get('fixed');
1254 };
1255 function calculateRelativePosition(ctrl, targetElm, rel) {
1256 var ctrlElm, pos, x, y, selfW, selfH, targetW, targetH, viewport, size;
1257 viewport = getWindowViewPort();
1258 pos = funcs.getPos(targetElm, UiContainer.getUiContainer(ctrl));
1259 x = pos.x;
1260 y = pos.y;
1261 if (isFixed(ctrl) && isStatic(domGlobals.document.body)) {
1262 x -= viewport.x;
1263 y -= viewport.y;
1264 }
1265 ctrlElm = ctrl.getEl();
1266 size = funcs.getSize(ctrlElm);
1267 selfW = size.width;
1268 selfH = size.height;
1269 size = funcs.getSize(targetElm);
1270 targetW = size.width;
1271 targetH = size.height;
1272 rel = (rel || '').split('');
1273 if (rel[0] === 'b') {
1274 y += targetH;
1275 }
1276 if (rel[1] === 'r') {
1277 x += targetW;
1278 }
1279 if (rel[0] === 'c') {
1280 y += Math.round(targetH / 2);
1281 }
1282 if (rel[1] === 'c') {
1283 x += Math.round(targetW / 2);
1284 }
1285 if (rel[3] === 'b') {
1286 y -= selfH;
1287 }
1288 if (rel[4] === 'r') {
1289 x -= selfW;
1290 }
1291 if (rel[3] === 'c') {
1292 y -= Math.round(selfH / 2);
1293 }
1294 if (rel[4] === 'c') {
1295 x -= Math.round(selfW / 2);
1296 }
1297 return {
1298 x: x,
1299 y: y,
1300 w: selfW,
1301 h: selfH
1302 };
1303 }
1304 var getUiContainerViewPort = function (customUiContainer) {
1305 return {
1306 x: 0,
1307 y: 0,
1308 w: customUiContainer.scrollWidth - 1,
1309 h: customUiContainer.scrollHeight - 1
1310 };
1311 };
1312 var getWindowViewPort = function () {
1313 var win = domGlobals.window;
1314 var x = Math.max(win.pageXOffset, domGlobals.document.body.scrollLeft, domGlobals.document.documentElement.scrollLeft);
1315 var y = Math.max(win.pageYOffset, domGlobals.document.body.scrollTop, domGlobals.document.documentElement.scrollTop);
1316 var w = win.innerWidth || domGlobals.document.documentElement.clientWidth;
1317 var h = win.innerHeight || domGlobals.document.documentElement.clientHeight;
1318 return {
1319 x: x,
1320 y: y,
1321 w: w,
1322 h: h
1323 };
1324 };
1325 var getViewPortRect = function (ctrl) {
1326 var customUiContainer = UiContainer.getUiContainer(ctrl);
1327 return customUiContainer && !isFixed(ctrl) ? getUiContainerViewPort(customUiContainer) : getWindowViewPort();
1328 };
1329 var Movable = {
1330 testMoveRel: function (elm, rels) {
1331 var viewPortRect = getViewPortRect(this);
1332 for (var i = 0; i < rels.length; i++) {
1333 var pos = calculateRelativePosition(this, elm, rels[i]);
1334 if (isFixed(this)) {
1335 if (pos.x > 0 && pos.x + pos.w < viewPortRect.w && pos.y > 0 && pos.y + pos.h < viewPortRect.h) {
1336 return rels[i];
1337 }
1338 } else {
1339 if (pos.x > viewPortRect.x && pos.x + pos.w < viewPortRect.w + viewPortRect.x && pos.y > viewPortRect.y && pos.y + pos.h < viewPortRect.h + viewPortRect.y) {
1340 return rels[i];
1341 }
1342 }
1343 }
1344 return rels[0];
1345 },
1346 moveRel: function (elm, rel) {
1347 if (typeof rel !== 'string') {
1348 rel = this.testMoveRel(elm, rel);
1349 }
1350 var pos = calculateRelativePosition(this, elm, rel);
1351 return this.moveTo(pos.x, pos.y);
1352 },
1353 moveBy: function (dx, dy) {
1354 var self = this, rect = self.layoutRect();
1355 self.moveTo(rect.x + dx, rect.y + dy);
1356 return self;
1357 },
1358 moveTo: function (x, y) {
1359 var self = this;
1360 function constrain(value, max, size) {
1361 if (value < 0) {
1362 return 0;
1363 }
1364 if (value + size > max) {
1365 value = max - size;
1366 return value < 0 ? 0 : value;
1367 }
1368 return value;
1369 }
1370 if (self.settings.constrainToViewport) {
1371 var viewPortRect = getViewPortRect(this);
1372 var layoutRect = self.layoutRect();
1373 x = constrain(x, viewPortRect.w + viewPortRect.x, layoutRect.w);
1374 y = constrain(y, viewPortRect.h + viewPortRect.y, layoutRect.h);
1375 }
1376 var uiContainer = UiContainer.getUiContainer(self);
1377 if (uiContainer && isStatic(uiContainer) && !isFixed(self)) {
1378 x -= uiContainer.scrollLeft;
1379 y -= uiContainer.scrollTop;
1380 }
1381 if (uiContainer) {
1382 x += 1;
1383 y += 1;
1384 }
1385 if (self.state.get('rendered')) {
1386 self.layoutRect({
1387 x: x,
1388 y: y
1389 }).repaint();
1390 } else {
1391 self.settings.x = x;
1392 self.settings.y = y;
1393 }
1394 self.fire('move', {
1395 x: x,
1396 y: y
1397 });
1398 return self;
1399 }
1400 };
1401
1402 var global$a = tinymce.util.Tools.resolve('tinymce.util.Class');
1403
1404 var global$b = tinymce.util.Tools.resolve('tinymce.util.EventDispatcher');
1405
1406 var BoxUtils = {
1407 parseBox: function (value) {
1408 var len;
1409 var radix = 10;
1410 if (!value) {
1411 return;
1412 }
1413 if (typeof value === 'number') {
1414 value = value || 0;
1415 return {
1416 top: value,
1417 left: value,
1418 bottom: value,
1419 right: value
1420 };
1421 }
1422 value = value.split(' ');
1423 len = value.length;
1424 if (len === 1) {
1425 value[1] = value[2] = value[3] = value[0];
1426 } else if (len === 2) {
1427 value[2] = value[0];
1428 value[3] = value[1];
1429 } else if (len === 3) {
1430 value[3] = value[1];
1431 }
1432 return {
1433 top: parseInt(value[0], radix) || 0,
1434 right: parseInt(value[1], radix) || 0,
1435 bottom: parseInt(value[2], radix) || 0,
1436 left: parseInt(value[3], radix) || 0
1437 };
1438 },
1439 measureBox: function (elm, prefix) {
1440 function getStyle(name) {
1441 var defaultView = elm.ownerDocument.defaultView;
1442 if (defaultView) {
1443 var computedStyle = defaultView.getComputedStyle(elm, null);
1444 if (computedStyle) {
1445 name = name.replace(/[A-Z]/g, function (a) {
1446 return '-' + a;
1447 });
1448 return computedStyle.getPropertyValue(name);
1449 } else {
1450 return null;
1451 }
1452 }
1453 return elm.currentStyle[name];
1454 }
1455 function getSide(name) {
1456 var val = parseFloat(getStyle(name));
1457 return isNaN(val) ? 0 : val;
1458 }
1459 return {
1460 top: getSide(prefix + 'TopWidth'),
1461 right: getSide(prefix + 'RightWidth'),
1462 bottom: getSide(prefix + 'BottomWidth'),
1463 left: getSide(prefix + 'LeftWidth')
1464 };
1465 }
1466 };
1467
1468 function noop$1() {
1469 }
1470 function ClassList(onchange) {
1471 this.cls = [];
1472 this.cls._map = {};
1473 this.onchange = onchange || noop$1;
1474 this.prefix = '';
1475 }
1476 global$2.extend(ClassList.prototype, {
1477 add: function (cls) {
1478 if (cls && !this.contains(cls)) {
1479 this.cls._map[cls] = true;
1480 this.cls.push(cls);
1481 this._change();
1482 }
1483 return this;
1484 },
1485 remove: function (cls) {
1486 if (this.contains(cls)) {
1487 var i = void 0;
1488 for (i = 0; i < this.cls.length; i++) {
1489 if (this.cls[i] === cls) {
1490 break;
1491 }
1492 }
1493 this.cls.splice(i, 1);
1494 delete this.cls._map[cls];
1495 this._change();
1496 }
1497 return this;
1498 },
1499 toggle: function (cls, state) {
1500 var curState = this.contains(cls);
1501 if (curState !== state) {
1502 if (curState) {
1503 this.remove(cls);
1504 } else {
1505 this.add(cls);
1506 }
1507 this._change();
1508 }
1509 return this;
1510 },
1511 contains: function (cls) {
1512 return !!this.cls._map[cls];
1513 },
1514 _change: function () {
1515 delete this.clsValue;
1516 this.onchange.call(this);
1517 }
1518 });
1519 ClassList.prototype.toString = function () {
1520 var value;
1521 if (this.clsValue) {
1522 return this.clsValue;
1523 }
1524 value = '';
1525 for (var i = 0; i < this.cls.length; i++) {
1526 if (i > 0) {
1527 value += ' ';
1528 }
1529 value += this.prefix + this.cls[i];
1530 }
1531 return value;
1532 };
1533
1534 function unique(array) {
1535 var uniqueItems = [];
1536 var i = array.length, item;
1537 while (i--) {
1538 item = array[i];
1539 if (!item.__checked) {
1540 uniqueItems.push(item);
1541 item.__checked = 1;
1542 }
1543 }
1544 i = uniqueItems.length;
1545 while (i--) {
1546 delete uniqueItems[i].__checked;
1547 }
1548 return uniqueItems;
1549 }
1550 var expression = /^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i;
1551 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g;
1552 var whiteSpace = /^\s*|\s*$/g;
1553 var Collection;
1554 var Selector = global$a.extend({
1555 init: function (selector) {
1556 var match = this.match;
1557 function compileNameFilter(name) {
1558 if (name) {
1559 name = name.toLowerCase();
1560 return function (item) {
1561 return name === '*' || item.type === name;
1562 };
1563 }
1564 }
1565 function compileIdFilter(id) {
1566 if (id) {
1567 return function (item) {
1568 return item._name === id;
1569 };
1570 }
1571 }
1572 function compileClassesFilter(classes) {
1573 if (classes) {
1574 classes = classes.split('.');
1575 return function (item) {
1576 var i = classes.length;
1577 while (i--) {
1578 if (!item.classes.contains(classes[i])) {
1579 return false;
1580 }
1581 }
1582 return true;
1583 };
1584 }
1585 }
1586 function compileAttrFilter(name, cmp, check) {
1587 if (name) {
1588 return function (item) {
1589 var value = item[name] ? item[name]() : '';
1590 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;
1591 };
1592 }
1593 }
1594 function compilePsuedoFilter(name) {
1595 var notSelectors;
1596 if (name) {
1597 name = /(?:not\((.+)\))|(.+)/i.exec(name);
1598 if (!name[1]) {
1599 name = name[2];
1600 return function (item, index, length) {
1601 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;
1602 };
1603 }
1604 notSelectors = parseChunks(name[1], []);
1605 return function (item) {
1606 return !match(item, notSelectors);
1607 };
1608 }
1609 }
1610 function compile(selector, filters, direct) {
1611 var parts;
1612 function add(filter) {
1613 if (filter) {
1614 filters.push(filter);
1615 }
1616 }
1617 parts = expression.exec(selector.replace(whiteSpace, ''));
1618 add(compileNameFilter(parts[1]));
1619 add(compileIdFilter(parts[2]));
1620 add(compileClassesFilter(parts[3]));
1621 add(compileAttrFilter(parts[4], parts[5], parts[6]));
1622 add(compilePsuedoFilter(parts[7]));
1623 filters.pseudo = !!parts[7];
1624 filters.direct = direct;
1625 return filters;
1626 }
1627 function parseChunks(selector, selectors) {
1628 var parts = [];
1629 var extra, matches, i;
1630 do {
1631 chunker.exec('');
1632 matches = chunker.exec(selector);
1633 if (matches) {
1634 selector = matches[3];
1635 parts.push(matches[1]);
1636 if (matches[2]) {
1637 extra = matches[3];
1638 break;
1639 }
1640 }
1641 } while (matches);
1642 if (extra) {
1643 parseChunks(extra, selectors);
1644 }
1645 selector = [];
1646 for (i = 0; i < parts.length; i++) {
1647 if (parts[i] !== '>') {
1648 selector.push(compile(parts[i], [], parts[i - 1] === '>'));
1649 }
1650 }
1651 selectors.push(selector);
1652 return selectors;
1653 }
1654 this._selectors = parseChunks(selector, []);
1655 },
1656 match: function (control, selectors) {
1657 var i, l, si, sl, selector, fi, fl, filters, index, length, siblings, count, item;
1658 selectors = selectors || this._selectors;
1659 for (i = 0, l = selectors.length; i < l; i++) {
1660 selector = selectors[i];
1661 sl = selector.length;
1662 item = control;
1663 count = 0;
1664 for (si = sl - 1; si >= 0; si--) {
1665 filters = selector[si];
1666 while (item) {
1667 if (filters.pseudo) {
1668 siblings = item.parent().items();
1669 index = length = siblings.length;
1670 while (index--) {
1671 if (siblings[index] === item) {
1672 break;
1673 }
1674 }
1675 }
1676 for (fi = 0, fl = filters.length; fi < fl; fi++) {
1677 if (!filters[fi](item, index, length)) {
1678 fi = fl + 1;
1679 break;
1680 }
1681 }
1682 if (fi === fl) {
1683 count++;
1684 break;
1685 } else {
1686 if (si === sl - 1) {
1687 break;
1688 }
1689 }
1690 item = item.parent();
1691 }
1692 }
1693 if (count === sl) {
1694 return true;
1695 }
1696 }
1697 return false;
1698 },
1699 find: function (container) {
1700 var matches = [], i, l;
1701 var selectors = this._selectors;
1702 function collect(items, selector, index) {
1703 var i, l, fi, fl, item;
1704 var filters = selector[index];
1705 for (i = 0, l = items.length; i < l; i++) {
1706 item = items[i];
1707 for (fi = 0, fl = filters.length; fi < fl; fi++) {
1708 if (!filters[fi](item, i, l)) {
1709 fi = fl + 1;
1710 break;
1711 }
1712 }
1713 if (fi === fl) {
1714 if (index === selector.length - 1) {
1715 matches.push(item);
1716 } else {
1717 if (item.items) {
1718 collect(item.items(), selector, index + 1);
1719 }
1720 }
1721 } else if (filters.direct) {
1722 return;
1723 }
1724 if (item.items) {
1725 collect(item.items(), selector, index);
1726 }
1727 }
1728 }
1729 if (container.items) {
1730 for (i = 0, l = selectors.length; i < l; i++) {
1731 collect(container.items(), selectors[i], 0);
1732 }
1733 if (l > 1) {
1734 matches = unique(matches);
1735 }
1736 }
1737 if (!Collection) {
1738 Collection = Selector.Collection;
1739 }
1740 return new Collection(matches);
1741 }
1742 });
1743
1744 var Collection$1, proto;
1745 var push = Array.prototype.push, slice = Array.prototype.slice;
1746 proto = {
1747 length: 0,
1748 init: function (items) {
1749 if (items) {
1750 this.add(items);
1751 }
1752 },
1753 add: function (items) {
1754 var self = this;
1755 if (!global$2.isArray(items)) {
1756 if (items instanceof Collection$1) {
1757 self.add(items.toArray());
1758 } else {
1759 push.call(self, items);
1760 }
1761 } else {
1762 push.apply(self, items);
1763 }
1764 return self;
1765 },
1766 set: function (items) {
1767 var self = this;
1768 var len = self.length;
1769 var i;
1770 self.length = 0;
1771 self.add(items);
1772 for (i = self.length; i < len; i++) {
1773 delete self[i];
1774 }
1775 return self;
1776 },
1777 filter: function (selector) {
1778 var self = this;
1779 var i, l;
1780 var matches = [];
1781 var item, match;
1782 if (typeof selector === 'string') {
1783 selector = new Selector(selector);
1784 match = function (item) {
1785 return selector.match(item);
1786 };
1787 } else {
1788 match = selector;
1789 }
1790 for (i = 0, l = self.length; i < l; i++) {
1791 item = self[i];
1792 if (match(item)) {
1793 matches.push(item);
1794 }
1795 }
1796 return new Collection$1(matches);
1797 },
1798 slice: function () {
1799 return new Collection$1(slice.apply(this, arguments));
1800 },
1801 eq: function (index) {
1802 return index === -1 ? this.slice(index) : this.slice(index, +index + 1);
1803 },
1804 each: function (callback) {
1805 global$2.each(this, callback);
1806 return this;
1807 },
1808 toArray: function () {
1809 return global$2.toArray(this);
1810 },
1811 indexOf: function (ctrl) {
1812 var self = this;
1813 var i = self.length;
1814 while (i--) {
1815 if (self[i] === ctrl) {
1816 break;
1817 }
1818 }
1819 return i;
1820 },
1821 reverse: function () {
1822 return new Collection$1(global$2.toArray(this).reverse());
1823 },
1824 hasClass: function (cls) {
1825 return this[0] ? this[0].classes.contains(cls) : false;
1826 },
1827 prop: function (name, value) {
1828 var self = this;
1829 var item;
1830 if (value !== undefined) {
1831 self.each(function (item) {
1832 if (item[name]) {
1833 item[name](value);
1834 }
1835 });
1836 return self;
1837 }
1838 item = self[0];
1839 if (item && item[name]) {
1840 return item[name]();
1841 }
1842 },
1843 exec: function (name) {
1844 var self = this, args = global$2.toArray(arguments).slice(1);
1845 self.each(function (item) {
1846 if (item[name]) {
1847 item[name].apply(item, args);
1848 }
1849 });
1850 return self;
1851 },
1852 remove: function () {
1853 var i = this.length;
1854 while (i--) {
1855 this[i].remove();
1856 }
1857 return this;
1858 },
1859 addClass: function (cls) {
1860 return this.each(function (item) {
1861 item.classes.add(cls);
1862 });
1863 },
1864 removeClass: function (cls) {
1865 return this.each(function (item) {
1866 item.classes.remove(cls);
1867 });
1868 }
1869 };
1870 global$2.each('fire on off show hide append prepend before after reflow'.split(' '), function (name) {
1871 proto[name] = function () {
1872 var args = global$2.toArray(arguments);
1873 this.each(function (ctrl) {
1874 if (name in ctrl) {
1875 ctrl[name].apply(ctrl, args);
1876 }
1877 });
1878 return this;
1879 };
1880 });
1881 global$2.each('text name disabled active selected checked visible parent value data'.split(' '), function (name) {
1882 proto[name] = function (value) {
1883 return this.prop(name, value);
1884 };
1885 });
1886 Collection$1 = global$a.extend(proto);
1887 Selector.Collection = Collection$1;
1888 var Collection$2 = Collection$1;
1889
1890 var Binding = function (settings) {
1891 this.create = settings.create;
1892 };
1893 Binding.create = function (model, name) {
1894 return new Binding({
1895 create: function (otherModel, otherName) {
1896 var bindings;
1897 var fromSelfToOther = function (e) {
1898 otherModel.set(otherName, e.value);
1899 };
1900 var fromOtherToSelf = function (e) {
1901 model.set(name, e.value);
1902 };
1903 otherModel.on('change:' + otherName, fromOtherToSelf);
1904 model.on('change:' + name, fromSelfToOther);
1905 bindings = otherModel._bindings;
1906 if (!bindings) {
1907 bindings = otherModel._bindings = [];
1908 otherModel.on('destroy', function () {
1909 var i = bindings.length;
1910 while (i--) {
1911 bindings[i]();
1912 }
1913 });
1914 }
1915 bindings.push(function () {
1916 model.off('change:' + name, fromSelfToOther);
1917 });
1918 return model.get(name);
1919 }
1920 });
1921 };
1922
1923 var global$c = tinymce.util.Tools.resolve('tinymce.util.Observable');
1924
1925 function isNode(node) {
1926 return node.nodeType > 0;
1927 }
1928 function isEqual(a, b) {
1929 var k, checked;
1930 if (a === b) {
1931 return true;
1932 }
1933 if (a === null || b === null) {
1934 return a === b;
1935 }
1936 if (typeof a !== 'object' || typeof b !== 'object') {
1937 return a === b;
1938 }
1939 if (global$2.isArray(b)) {
1940 if (a.length !== b.length) {
1941 return false;
1942 }
1943 k = a.length;
1944 while (k--) {
1945 if (!isEqual(a[k], b[k])) {
1946 return false;
1947 }
1948 }
1949 }
1950 if (isNode(a) || isNode(b)) {
1951 return a === b;
1952 }
1953 checked = {};
1954 for (k in b) {
1955 if (!isEqual(a[k], b[k])) {
1956 return false;
1957 }
1958 checked[k] = true;
1959 }
1960 for (k in a) {
1961 if (!checked[k] && !isEqual(a[k], b[k])) {
1962 return false;
1963 }
1964 }
1965 return true;
1966 }
1967 var ObservableObject = global$a.extend({
1968 Mixins: [global$c],
1969 init: function (data) {
1970 var name, value;
1971 data = data || {};
1972 for (name in data) {
1973 value = data[name];
1974 if (value instanceof Binding) {
1975 data[name] = value.create(this, name);
1976 }
1977 }
1978 this.data = data;
1979 },
1980 set: function (name, value) {
1981 var key, args;
1982 var oldValue = this.data[name];
1983 if (value instanceof Binding) {
1984 value = value.create(this, name);
1985 }
1986 if (typeof name === 'object') {
1987 for (key in name) {
1988 this.set(key, name[key]);
1989 }
1990 return this;
1991 }
1992 if (!isEqual(oldValue, value)) {
1993 this.data[name] = value;
1994 args = {
1995 target: this,
1996 name: name,
1997 value: value,
1998 oldValue: oldValue
1999 };
2000 this.fire('change:' + name, args);
2001 this.fire('change', args);
2002 }
2003 return this;
2004 },
2005 get: function (name) {
2006 return this.data[name];
2007 },
2008 has: function (name) {
2009 return name in this.data;
2010 },
2011 bind: function (name) {
2012 return Binding.create(this, name);
2013 },
2014 destroy: function () {
2015 this.fire('destroy');
2016 }
2017 });
2018
2019 var dirtyCtrls = {}, animationFrameRequested;
2020 var ReflowQueue = {
2021 add: function (ctrl) {
2022 var parent = ctrl.parent();
2023 if (parent) {
2024 if (!parent._layout || parent._layout.isNative()) {
2025 return;
2026 }
2027 if (!dirtyCtrls[parent._id]) {
2028 dirtyCtrls[parent._id] = parent;
2029 }
2030 if (!animationFrameRequested) {
2031 animationFrameRequested = true;
2032 global$7.requestAnimationFrame(function () {
2033 var id, ctrl;
2034 animationFrameRequested = false;
2035 for (id in dirtyCtrls) {
2036 ctrl = dirtyCtrls[id];
2037 if (ctrl.state.get('rendered')) {
2038 ctrl.reflow();
2039 }
2040 }
2041 dirtyCtrls = {};
2042 }, domGlobals.document.body);
2043 }
2044 }
2045 },
2046 remove: function (ctrl) {
2047 if (dirtyCtrls[ctrl._id]) {
2048 delete dirtyCtrls[ctrl._id];
2049 }
2050 }
2051 };
2052
2053 var hasMouseWheelEventSupport = 'onmousewheel' in domGlobals.document;
2054 var hasWheelEventSupport = false;
2055 var classPrefix = 'mce-';
2056 var Control, idCounter = 0;
2057 var proto$1 = {
2058 Statics: { classPrefix: classPrefix },
2059 isRtl: function () {
2060 return Control.rtl;
2061 },
2062 classPrefix: classPrefix,
2063 init: function (settings) {
2064 var self = this;
2065 var classes, defaultClasses;
2066 function applyClasses(classes) {
2067 var i;
2068 classes = classes.split(' ');
2069 for (i = 0; i < classes.length; i++) {
2070 self.classes.add(classes[i]);
2071 }
2072 }
2073 self.settings = settings = global$2.extend({}, self.Defaults, settings);
2074 self._id = settings.id || 'mceu_' + idCounter++;
2075 self._aria = { role: settings.role };
2076 self._elmCache = {};
2077 self.$ = global$9;
2078 self.state = new ObservableObject({
2079 visible: true,
2080 active: false,
2081 disabled: false,
2082 value: ''
2083 });
2084 self.data = new ObservableObject(settings.data);
2085 self.classes = new ClassList(function () {
2086 if (self.state.get('rendered')) {
2087 self.getEl().className = this.toString();
2088 }
2089 });
2090 self.classes.prefix = self.classPrefix;
2091 classes = settings.classes;
2092 if (classes) {
2093 if (self.Defaults) {
2094 defaultClasses = self.Defaults.classes;
2095 if (defaultClasses && classes !== defaultClasses) {
2096 applyClasses(defaultClasses);
2097 }
2098 }
2099 applyClasses(classes);
2100 }
2101 global$2.each('title text name visible disabled active value'.split(' '), function (name) {
2102 if (name in settings) {
2103 self[name](settings[name]);
2104 }
2105 });
2106 self.on('click', function () {
2107 if (self.disabled()) {
2108 return false;
2109 }
2110 });
2111 self.settings = settings;
2112 self.borderBox = BoxUtils.parseBox(settings.border);
2113 self.paddingBox = BoxUtils.parseBox(settings.padding);
2114 self.marginBox = BoxUtils.parseBox(settings.margin);
2115 if (settings.hidden) {
2116 self.hide();
2117 }
2118 },
2119 Properties: 'parent,name',
2120 getContainerElm: function () {
2121 var uiContainer = UiContainer.getUiContainer(this);
2122 return uiContainer ? uiContainer : funcs.getContainer();
2123 },
2124 getParentCtrl: function (elm) {
2125 var ctrl;
2126 var lookup = this.getRoot().controlIdLookup;
2127 while (elm && lookup) {
2128 ctrl = lookup[elm.id];
2129 if (ctrl) {
2130 break;
2131 }
2132 elm = elm.parentNode;
2133 }
2134 return ctrl;
2135 },
2136 initLayoutRect: function () {
2137 var self = this;
2138 var settings = self.settings;
2139 var borderBox, layoutRect;
2140 var elm = self.getEl();
2141 var width, height, minWidth, minHeight, autoResize;
2142 var startMinWidth, startMinHeight, initialSize;
2143 borderBox = self.borderBox = self.borderBox || BoxUtils.measureBox(elm, 'border');
2144 self.paddingBox = self.paddingBox || BoxUtils.measureBox(elm, 'padding');
2145 self.marginBox = self.marginBox || BoxUtils.measureBox(elm, 'margin');
2146 initialSize = funcs.getSize(elm);
2147 startMinWidth = settings.minWidth;
2148 startMinHeight = settings.minHeight;
2149 minWidth = startMinWidth || initialSize.width;
2150 minHeight = startMinHeight || initialSize.height;
2151 width = settings.width;
2152 height = settings.height;
2153 autoResize = settings.autoResize;
2154 autoResize = typeof autoResize !== 'undefined' ? autoResize : !width && !height;
2155 width = width || minWidth;
2156 height = height || minHeight;
2157 var deltaW = borderBox.left + borderBox.right;
2158 var deltaH = borderBox.top + borderBox.bottom;
2159 var maxW = settings.maxWidth || 65535;
2160 var maxH = settings.maxHeight || 65535;
2161 self._layoutRect = layoutRect = {
2162 x: settings.x || 0,
2163 y: settings.y || 0,
2164 w: width,
2165 h: height,
2166 deltaW: deltaW,
2167 deltaH: deltaH,
2168 contentW: width - deltaW,
2169 contentH: height - deltaH,
2170 innerW: width - deltaW,
2171 innerH: height - deltaH,
2172 startMinWidth: startMinWidth || 0,
2173 startMinHeight: startMinHeight || 0,
2174 minW: Math.min(minWidth, maxW),
2175 minH: Math.min(minHeight, maxH),
2176 maxW: maxW,
2177 maxH: maxH,
2178 autoResize: autoResize,
2179 scrollW: 0
2180 };
2181 self._lastLayoutRect = {};
2182 return layoutRect;
2183 },
2184 layoutRect: function (newRect) {
2185 var self = this;
2186 var curRect = self._layoutRect, lastLayoutRect, size, deltaWidth, deltaHeight, repaintControls;
2187 if (!curRect) {
2188 curRect = self.initLayoutRect();
2189 }
2190 if (newRect) {
2191 deltaWidth = curRect.deltaW;
2192 deltaHeight = curRect.deltaH;
2193 if (newRect.x !== undefined) {
2194 curRect.x = newRect.x;
2195 }
2196 if (newRect.y !== undefined) {
2197 curRect.y = newRect.y;
2198 }
2199 if (newRect.minW !== undefined) {
2200 curRect.minW = newRect.minW;
2201 }
2202 if (newRect.minH !== undefined) {
2203 curRect.minH = newRect.minH;
2204 }
2205 size = newRect.w;
2206 if (size !== undefined) {
2207 size = size < curRect.minW ? curRect.minW : size;
2208 size = size > curRect.maxW ? curRect.maxW : size;
2209 curRect.w = size;
2210 curRect.innerW = size - deltaWidth;
2211 }
2212 size = newRect.h;
2213 if (size !== undefined) {
2214 size = size < curRect.minH ? curRect.minH : size;
2215 size = size > curRect.maxH ? curRect.maxH : size;
2216 curRect.h = size;
2217 curRect.innerH = size - deltaHeight;
2218 }
2219 size = newRect.innerW;
2220 if (size !== undefined) {
2221 size = size < curRect.minW - deltaWidth ? curRect.minW - deltaWidth : size;
2222 size = size > curRect.maxW - deltaWidth ? curRect.maxW - deltaWidth : size;
2223 curRect.innerW = size;
2224 curRect.w = size + deltaWidth;
2225 }
2226 size = newRect.innerH;
2227 if (size !== undefined) {
2228 size = size < curRect.minH - deltaHeight ? curRect.minH - deltaHeight : size;
2229 size = size > curRect.maxH - deltaHeight ? curRect.maxH - deltaHeight : size;
2230 curRect.innerH = size;
2231 curRect.h = size + deltaHeight;
2232 }
2233 if (newRect.contentW !== undefined) {
2234 curRect.contentW = newRect.contentW;
2235 }
2236 if (newRect.contentH !== undefined) {
2237 curRect.contentH = newRect.contentH;
2238 }
2239 lastLayoutRect = self._lastLayoutRect;
2240 if (lastLayoutRect.x !== curRect.x || lastLayoutRect.y !== curRect.y || lastLayoutRect.w !== curRect.w || lastLayoutRect.h !== curRect.h) {
2241 repaintControls = Control.repaintControls;
2242 if (repaintControls) {
2243 if (repaintControls.map && !repaintControls.map[self._id]) {
2244 repaintControls.push(self);
2245 repaintControls.map[self._id] = true;
2246 }
2247 }
2248 lastLayoutRect.x = curRect.x;
2249 lastLayoutRect.y = curRect.y;
2250 lastLayoutRect.w = curRect.w;
2251 lastLayoutRect.h = curRect.h;
2252 }
2253 return self;
2254 }
2255 return curRect;
2256 },
2257 repaint: function () {
2258 var self = this;
2259 var style, bodyStyle, bodyElm, rect, borderBox;
2260 var borderW, borderH, lastRepaintRect, round, value;
2261 round = !domGlobals.document.createRange ? Math.round : function (value) {
2262 return value;
2263 };
2264 style = self.getEl().style;
2265 rect = self._layoutRect;
2266 lastRepaintRect = self._lastRepaintRect || {};
2267 borderBox = self.borderBox;
2268 borderW = borderBox.left + borderBox.right;
2269 borderH = borderBox.top + borderBox.bottom;
2270 if (rect.x !== lastRepaintRect.x) {
2271 style.left = round(rect.x) + 'px';
2272 lastRepaintRect.x = rect.x;
2273 }
2274 if (rect.y !== lastRepaintRect.y) {
2275 style.top = round(rect.y) + 'px';
2276 lastRepaintRect.y = rect.y;
2277 }
2278 if (rect.w !== lastRepaintRect.w) {
2279 value = round(rect.w - borderW);
2280 style.width = (value >= 0 ? value : 0) + 'px';
2281 lastRepaintRect.w = rect.w;
2282 }
2283 if (rect.h !== lastRepaintRect.h) {
2284 value = round(rect.h - borderH);
2285 style.height = (value >= 0 ? value : 0) + 'px';
2286 lastRepaintRect.h = rect.h;
2287 }
2288 if (self._hasBody && rect.innerW !== lastRepaintRect.innerW) {
2289 value = round(rect.innerW);
2290 bodyElm = self.getEl('body');
2291 if (bodyElm) {
2292 bodyStyle = bodyElm.style;
2293 bodyStyle.width = (value >= 0 ? value : 0) + 'px';
2294 }
2295 lastRepaintRect.innerW = rect.innerW;
2296 }
2297 if (self._hasBody && rect.innerH !== lastRepaintRect.innerH) {
2298 value = round(rect.innerH);
2299 bodyElm = bodyElm || self.getEl('body');
2300 if (bodyElm) {
2301 bodyStyle = bodyStyle || bodyElm.style;
2302 bodyStyle.height = (value >= 0 ? value : 0) + 'px';
2303 }
2304 lastRepaintRect.innerH = rect.innerH;
2305 }
2306 self._lastRepaintRect = lastRepaintRect;
2307 self.fire('repaint', {}, false);
2308 },
2309 updateLayoutRect: function () {
2310 var self = this;
2311 self.parent()._lastRect = null;
2312 funcs.css(self.getEl(), {
2313 width: '',
2314 height: ''
2315 });
2316 self._layoutRect = self._lastRepaintRect = self._lastLayoutRect = null;
2317 self.initLayoutRect();
2318 },
2319 on: function (name, callback) {
2320 var self = this;
2321 function resolveCallbackName(name) {
2322 var callback, scope;
2323 if (typeof name !== 'string') {
2324 return name;
2325 }
2326 return function (e) {
2327 if (!callback) {
2328 self.parentsAndSelf().each(function (ctrl) {
2329 var callbacks = ctrl.settings.callbacks;
2330 if (callbacks && (callback = callbacks[name])) {
2331 scope = ctrl;
2332 return false;
2333 }
2334 });
2335 }
2336 if (!callback) {
2337 e.action = name;
2338 this.fire('execute', e);
2339 return;
2340 }
2341 return callback.call(scope, e);
2342 };
2343 }
2344 getEventDispatcher(self).on(name, resolveCallbackName(callback));
2345 return self;
2346 },
2347 off: function (name, callback) {
2348 getEventDispatcher(this).off(name, callback);
2349 return this;
2350 },
2351 fire: function (name, args, bubble) {
2352 var self = this;
2353 args = args || {};
2354 if (!args.control) {
2355 args.control = self;
2356 }
2357 args = getEventDispatcher(self).fire(name, args);
2358 if (bubble !== false && self.parent) {
2359 var parent = self.parent();
2360 while (parent && !args.isPropagationStopped()) {
2361 parent.fire(name, args, false);
2362 parent = parent.parent();
2363 }
2364 }
2365 return args;
2366 },
2367 hasEventListeners: function (name) {
2368 return getEventDispatcher(this).has(name);
2369 },
2370 parents: function (selector) {
2371 var self = this;
2372 var ctrl, parents = new Collection$2();
2373 for (ctrl = self.parent(); ctrl; ctrl = ctrl.parent()) {
2374 parents.add(ctrl);
2375 }
2376 if (selector) {
2377 parents = parents.filter(selector);
2378 }
2379 return parents;
2380 },
2381 parentsAndSelf: function (selector) {
2382 return new Collection$2(this).add(this.parents(selector));
2383 },
2384 next: function () {
2385 var parentControls = this.parent().items();
2386 return parentControls[parentControls.indexOf(this) + 1];
2387 },
2388 prev: function () {
2389 var parentControls = this.parent().items();
2390 return parentControls[parentControls.indexOf(this) - 1];
2391 },
2392 innerHtml: function (html) {
2393 this.$el.html(html);
2394 return this;
2395 },
2396 getEl: function (suffix) {
2397 var id = suffix ? this._id + '-' + suffix : this._id;
2398 if (!this._elmCache[id]) {
2399 this._elmCache[id] = global$9('#' + id)[0];
2400 }
2401 return this._elmCache[id];
2402 },
2403 show: function () {
2404 return this.visible(true);
2405 },
2406 hide: function () {
2407 return this.visible(false);
2408 },
2409 focus: function () {
2410 try {
2411 this.getEl().focus();
2412 } catch (ex) {
2413 }
2414 return this;
2415 },
2416 blur: function () {
2417 this.getEl().blur();
2418 return this;
2419 },
2420 aria: function (name, value) {
2421 var self = this, elm = self.getEl(self.ariaTarget);
2422 if (typeof value === 'undefined') {
2423 return self._aria[name];
2424 }
2425 self._aria[name] = value;
2426 if (self.state.get('rendered')) {
2427 elm.setAttribute(name === 'role' ? name : 'aria-' + name, value);
2428 }
2429 return self;
2430 },
2431 encode: function (text, translate) {
2432 if (translate !== false) {
2433 text = this.translate(text);
2434 }
2435 return (text || '').replace(/[&<>"]/g, function (match) {
2436 return '&#' + match.charCodeAt(0) + ';';
2437 });
2438 },
2439 translate: function (text) {
2440 return Control.translate ? Control.translate(text) : text;
2441 },
2442 before: function (items) {
2443 var self = this, parent = self.parent();
2444 if (parent) {
2445 parent.insert(items, parent.items().indexOf(self), true);
2446 }
2447 return self;
2448 },
2449 after: function (items) {
2450 var self = this, parent = self.parent();
2451 if (parent) {
2452 parent.insert(items, parent.items().indexOf(self));
2453 }
2454 return self;
2455 },
2456 remove: function () {
2457 var self = this;
2458 var elm = self.getEl();
2459 var parent = self.parent();
2460 var newItems, i;
2461 if (self.items) {
2462 var controls = self.items().toArray();
2463 i = controls.length;
2464 while (i--) {
2465 controls[i].remove();
2466 }
2467 }
2468 if (parent && parent.items) {
2469 newItems = [];
2470 parent.items().each(function (item) {
2471 if (item !== self) {
2472 newItems.push(item);
2473 }
2474 });
2475 parent.items().set(newItems);
2476 parent._lastRect = null;
2477 }
2478 if (self._eventsRoot && self._eventsRoot === self) {
2479 global$9(elm).off();
2480 }
2481 var lookup = self.getRoot().controlIdLookup;
2482 if (lookup) {
2483 delete lookup[self._id];
2484 }
2485 if (elm && elm.parentNode) {
2486 elm.parentNode.removeChild(elm);
2487 }
2488 self.state.set('rendered', false);
2489 self.state.destroy();
2490 self.fire('remove');
2491 return self;
2492 },
2493 renderBefore: function (elm) {
2494 global$9(elm).before(this.renderHtml());
2495 this.postRender();
2496 return this;
2497 },
2498 renderTo: function (elm) {
2499 global$9(elm || this.getContainerElm()).append(this.renderHtml());
2500 this.postRender();
2501 return this;
2502 },
2503 preRender: function () {
2504 },
2505 render: function () {
2506 },
2507 renderHtml: function () {
2508 return '<div id="' + this._id + '" class="' + this.classes + '"></div>';
2509 },
2510 postRender: function () {
2511 var self = this;
2512 var settings = self.settings;
2513 var elm, box, parent, name, parentEventsRoot;
2514 self.$el = global$9(self.getEl());
2515 self.state.set('rendered', true);
2516 for (name in settings) {
2517 if (name.indexOf('on') === 0) {
2518 self.on(name.substr(2), settings[name]);
2519 }
2520 }
2521 if (self._eventsRoot) {
2522 for (parent = self.parent(); !parentEventsRoot && parent; parent = parent.parent()) {
2523 parentEventsRoot = parent._eventsRoot;
2524 }
2525 if (parentEventsRoot) {
2526 for (name in parentEventsRoot._nativeEvents) {
2527 self._nativeEvents[name] = true;
2528 }
2529 }
2530 }
2531 bindPendingEvents(self);
2532 if (settings.style) {
2533 elm = self.getEl();
2534 if (elm) {
2535 elm.setAttribute('style', settings.style);
2536 elm.style.cssText = settings.style;
2537 }
2538 }
2539 if (self.settings.border) {
2540 box = self.borderBox;
2541 self.$el.css({
2542 'border-top-width': box.top,
2543 'border-right-width': box.right,
2544 'border-bottom-width': box.bottom,
2545 'border-left-width': box.left
2546 });
2547 }
2548 var root = self.getRoot();
2549 if (!root.controlIdLookup) {
2550 root.controlIdLookup = {};
2551 }
2552 root.controlIdLookup[self._id] = self;
2553 for (var key in self._aria) {
2554 self.aria(key, self._aria[key]);
2555 }
2556 if (self.state.get('visible') === false) {
2557 self.getEl().style.display = 'none';
2558 }
2559 self.bindStates();
2560 self.state.on('change:visible', function (e) {
2561 var state = e.value;
2562 var parentCtrl;
2563 if (self.state.get('rendered')) {
2564 self.getEl().style.display = state === false ? 'none' : '';
2565 self.getEl().getBoundingClientRect();
2566 }
2567 parentCtrl = self.parent();
2568 if (parentCtrl) {
2569 parentCtrl._lastRect = null;
2570 }
2571 self.fire(state ? 'show' : 'hide');
2572 ReflowQueue.add(self);
2573 });
2574 self.fire('postrender', {}, false);
2575 },
2576 bindStates: function () {
2577 },
2578 scrollIntoView: function (align) {
2579 function getOffset(elm, rootElm) {
2580 var x, y, parent = elm;
2581 x = y = 0;
2582 while (parent && parent !== rootElm && parent.nodeType) {
2583 x += parent.offsetLeft || 0;
2584 y += parent.offsetTop || 0;
2585 parent = parent.offsetParent;
2586 }
2587 return {
2588 x: x,
2589 y: y
2590 };
2591 }
2592 var elm = this.getEl(), parentElm = elm.parentNode;
2593 var x, y, width, height, parentWidth, parentHeight;
2594 var pos = getOffset(elm, parentElm);
2595 x = pos.x;
2596 y = pos.y;
2597 width = elm.offsetWidth;
2598 height = elm.offsetHeight;
2599 parentWidth = parentElm.clientWidth;
2600 parentHeight = parentElm.clientHeight;
2601 if (align === 'end') {
2602 x -= parentWidth - width;
2603 y -= parentHeight - height;
2604 } else if (align === 'center') {
2605 x -= parentWidth / 2 - width / 2;
2606 y -= parentHeight / 2 - height / 2;
2607 }
2608 parentElm.scrollLeft = x;
2609 parentElm.scrollTop = y;
2610 return this;
2611 },
2612 getRoot: function () {
2613 var ctrl = this, rootControl;
2614 var parents = [];
2615 while (ctrl) {
2616 if (ctrl.rootControl) {
2617 rootControl = ctrl.rootControl;
2618 break;
2619 }
2620 parents.push(ctrl);
2621 rootControl = ctrl;
2622 ctrl = ctrl.parent();
2623 }
2624 if (!rootControl) {
2625 rootControl = this;
2626 }
2627 var i = parents.length;
2628 while (i--) {
2629 parents[i].rootControl = rootControl;
2630 }
2631 return rootControl;
2632 },
2633 reflow: function () {
2634 ReflowQueue.remove(this);
2635 var parent = this.parent();
2636 if (parent && parent._layout && !parent._layout.isNative()) {
2637 parent.reflow();
2638 }
2639 return this;
2640 }
2641 };
2642 global$2.each('text title visible disabled active value'.split(' '), function (name) {
2643 proto$1[name] = function (value) {
2644 if (arguments.length === 0) {
2645 return this.state.get(name);
2646 }
2647 if (typeof value !== 'undefined') {
2648 this.state.set(name, value);
2649 }
2650 return this;
2651 };
2652 });
2653 Control = global$a.extend(proto$1);
2654 function getEventDispatcher(obj) {
2655 if (!obj._eventDispatcher) {
2656 obj._eventDispatcher = new global$b({
2657 scope: obj,
2658 toggleEvent: function (name, state) {
2659 if (state && global$b.isNative(name)) {
2660 if (!obj._nativeEvents) {
2661 obj._nativeEvents = {};
2662 }
2663 obj._nativeEvents[name] = true;
2664 if (obj.state.get('rendered')) {
2665 bindPendingEvents(obj);
2666 }
2667 }
2668 }
2669 });
2670 }
2671 return obj._eventDispatcher;
2672 }
2673 function bindPendingEvents(eventCtrl) {
2674 var i, l, parents, eventRootCtrl, nativeEvents, name;
2675 function delegate(e) {
2676 var control = eventCtrl.getParentCtrl(e.target);
2677 if (control) {
2678 control.fire(e.type, e);
2679 }
2680 }
2681 function mouseLeaveHandler() {
2682 var ctrl = eventRootCtrl._lastHoverCtrl;
2683 if (ctrl) {
2684 ctrl.fire('mouseleave', { target: ctrl.getEl() });
2685 ctrl.parents().each(function (ctrl) {
2686 ctrl.fire('mouseleave', { target: ctrl.getEl() });
2687 });
2688 eventRootCtrl._lastHoverCtrl = null;
2689 }
2690 }
2691 function mouseEnterHandler(e) {
2692 var ctrl = eventCtrl.getParentCtrl(e.target), lastCtrl = eventRootCtrl._lastHoverCtrl, idx = 0, i, parents, lastParents;
2693 if (ctrl !== lastCtrl) {
2694 eventRootCtrl._lastHoverCtrl = ctrl;
2695 parents = ctrl.parents().toArray().reverse();
2696 parents.push(ctrl);
2697 if (lastCtrl) {
2698 lastParents = lastCtrl.parents().toArray().reverse();
2699 lastParents.push(lastCtrl);
2700 for (idx = 0; idx < lastParents.length; idx++) {
2701 if (parents[idx] !== lastParents[idx]) {
2702 break;
2703 }
2704 }
2705 for (i = lastParents.length - 1; i >= idx; i--) {
2706 lastCtrl = lastParents[i];
2707 lastCtrl.fire('mouseleave', { target: lastCtrl.getEl() });
2708 }
2709 }
2710 for (i = idx; i < parents.length; i++) {
2711 ctrl = parents[i];
2712 ctrl.fire('mouseenter', { target: ctrl.getEl() });
2713 }
2714 }
2715 }
2716 function fixWheelEvent(e) {
2717 e.preventDefault();
2718 if (e.type === 'mousewheel') {
2719 e.deltaY = -1 / 40 * e.wheelDelta;
2720 if (e.wheelDeltaX) {
2721 e.deltaX = -1 / 40 * e.wheelDeltaX;
2722 }
2723 } else {
2724 e.deltaX = 0;
2725 e.deltaY = e.detail;
2726 }
2727 e = eventCtrl.fire('wheel', e);
2728 }
2729 nativeEvents = eventCtrl._nativeEvents;
2730 if (nativeEvents) {
2731 parents = eventCtrl.parents().toArray();
2732 parents.unshift(eventCtrl);
2733 for (i = 0, l = parents.length; !eventRootCtrl && i < l; i++) {
2734 eventRootCtrl = parents[i]._eventsRoot;
2735 }
2736 if (!eventRootCtrl) {
2737 eventRootCtrl = parents[parents.length - 1] || eventCtrl;
2738 }
2739 eventCtrl._eventsRoot = eventRootCtrl;
2740 for (l = i, i = 0; i < l; i++) {
2741 parents[i]._eventsRoot = eventRootCtrl;
2742 }
2743 var eventRootDelegates = eventRootCtrl._delegates;
2744 if (!eventRootDelegates) {
2745 eventRootDelegates = eventRootCtrl._delegates = {};
2746 }
2747 for (name in nativeEvents) {
2748 if (!nativeEvents) {
2749 return false;
2750 }
2751 if (name === 'wheel' && !hasWheelEventSupport) {
2752 if (hasMouseWheelEventSupport) {
2753 global$9(eventCtrl.getEl()).on('mousewheel', fixWheelEvent);
2754 } else {
2755 global$9(eventCtrl.getEl()).on('DOMMouseScroll', fixWheelEvent);
2756 }
2757 continue;
2758 }
2759 if (name === 'mouseenter' || name === 'mouseleave') {
2760 if (!eventRootCtrl._hasMouseEnter) {
2761 global$9(eventRootCtrl.getEl()).on('mouseleave', mouseLeaveHandler).on('mouseover', mouseEnterHandler);
2762 eventRootCtrl._hasMouseEnter = 1;
2763 }
2764 } else if (!eventRootDelegates[name]) {
2765 global$9(eventRootCtrl.getEl()).on(name, delegate);
2766 eventRootDelegates[name] = true;
2767 }
2768 nativeEvents[name] = false;
2769 }
2770 }
2771 }
2772 var Control$1 = Control;
2773
2774 var hasTabstopData = function (elm) {
2775 return elm.getAttribute('data-mce-tabstop') ? true : false;
2776 };
2777 function KeyboardNavigation (settings) {
2778 var root = settings.root;
2779 var focusedElement, focusedControl;
2780 function isElement(node) {
2781 return node && node.nodeType === 1;
2782 }
2783 try {
2784 focusedElement = domGlobals.document.activeElement;
2785 } catch (ex) {
2786 focusedElement = domGlobals.document.body;
2787 }
2788 focusedControl = root.getParentCtrl(focusedElement);
2789 function getRole(elm) {
2790 elm = elm || focusedElement;
2791 if (isElement(elm)) {
2792 return elm.getAttribute('role');
2793 }
2794 return null;
2795 }
2796 function getParentRole(elm) {
2797 var role, parent = elm || focusedElement;
2798 while (parent = parent.parentNode) {
2799 if (role = getRole(parent)) {
2800 return role;
2801 }
2802 }
2803 }
2804 function getAriaProp(name) {
2805 var elm = focusedElement;
2806 if (isElement(elm)) {
2807 return elm.getAttribute('aria-' + name);
2808 }
2809 }
2810 function isTextInputElement(elm) {
2811 var tagName = elm.tagName.toUpperCase();
2812 return tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT';
2813 }
2814 function canFocus(elm) {
2815 if (isTextInputElement(elm) && !elm.hidden) {
2816 return true;
2817 }
2818 if (hasTabstopData(elm)) {
2819 return true;
2820 }
2821 if (/^(button|menuitem|checkbox|tab|menuitemcheckbox|option|gridcell|slider)$/.test(getRole(elm))) {
2822 return true;
2823 }
2824 return false;
2825 }
2826 function getFocusElements(elm) {
2827 var elements = [];
2828 function collect(elm) {
2829 if (elm.nodeType !== 1 || elm.style.display === 'none' || elm.disabled) {
2830 return;
2831 }
2832 if (canFocus(elm)) {
2833 elements.push(elm);
2834 }
2835 for (var i = 0; i < elm.childNodes.length; i++) {
2836 collect(elm.childNodes[i]);
2837 }
2838 }
2839 collect(elm || root.getEl());
2840 return elements;
2841 }
2842 function getNavigationRoot(targetControl) {
2843 var navigationRoot, controls;
2844 targetControl = targetControl || focusedControl;
2845 controls = targetControl.parents().toArray();
2846 controls.unshift(targetControl);
2847 for (var i = 0; i < controls.length; i++) {
2848 navigationRoot = controls[i];
2849 if (navigationRoot.settings.ariaRoot) {
2850 break;
2851 }
2852 }
2853 return navigationRoot;
2854 }
2855 function focusFirst(targetControl) {
2856 var navigationRoot = getNavigationRoot(targetControl);
2857 var focusElements = getFocusElements(navigationRoot.getEl());
2858 if (navigationRoot.settings.ariaRemember && 'lastAriaIndex' in navigationRoot) {
2859 moveFocusToIndex(navigationRoot.lastAriaIndex, focusElements);
2860 } else {
2861 moveFocusToIndex(0, focusElements);
2862 }
2863 }
2864 function moveFocusToIndex(idx, elements) {
2865 if (idx < 0) {
2866 idx = elements.length - 1;
2867 } else if (idx >= elements.length) {
2868 idx = 0;
2869 }
2870 if (elements[idx]) {
2871 elements[idx].focus();
2872 }
2873 return idx;
2874 }
2875 function moveFocus(dir, elements) {
2876 var idx = -1;
2877 var navigationRoot = getNavigationRoot();
2878 elements = elements || getFocusElements(navigationRoot.getEl());
2879 for (var i = 0; i < elements.length; i++) {
2880 if (elements[i] === focusedElement) {
2881 idx = i;
2882 }
2883 }
2884 idx += dir;
2885 navigationRoot.lastAriaIndex = moveFocusToIndex(idx, elements);
2886 }
2887 function left() {
2888 var parentRole = getParentRole();
2889 if (parentRole === 'tablist') {
2890 moveFocus(-1, getFocusElements(focusedElement.parentNode));
2891 } else if (focusedControl.parent().submenu) {
2892 cancel();
2893 } else {
2894 moveFocus(-1);
2895 }
2896 }
2897 function right() {
2898 var role = getRole(), parentRole = getParentRole();
2899 if (parentRole === 'tablist') {
2900 moveFocus(1, getFocusElements(focusedElement.parentNode));
2901 } else if (role === 'menuitem' && parentRole === 'menu' && getAriaProp('haspopup')) {
2902 enter();
2903 } else {
2904 moveFocus(1);
2905 }
2906 }
2907 function up() {
2908 moveFocus(-1);
2909 }
2910 function down() {
2911 var role = getRole(), parentRole = getParentRole();
2912 if (role === 'menuitem' && parentRole === 'menubar') {
2913 enter();
2914 } else if (role === 'button' && getAriaProp('haspopup')) {
2915 enter({ key: 'down' });
2916 } else {
2917 moveFocus(1);
2918 }
2919 }
2920 function tab(e) {
2921 var parentRole = getParentRole();
2922 if (parentRole === 'tablist') {
2923 var elm = getFocusElements(focusedControl.getEl('body'))[0];
2924 if (elm) {
2925 elm.focus();
2926 }
2927 } else {
2928 moveFocus(e.shiftKey ? -1 : 1);
2929 }
2930 }
2931 function cancel() {
2932 focusedControl.fire('cancel');
2933 }
2934 function enter(aria) {
2935 aria = aria || {};
2936 focusedControl.fire('click', {
2937 target: focusedElement,
2938 aria: aria
2939 });
2940 }
2941 root.on('keydown', function (e) {
2942 function handleNonTabOrEscEvent(e, handler) {
2943 if (isTextInputElement(focusedElement) || hasTabstopData(focusedElement)) {
2944 return;
2945 }
2946 if (getRole(focusedElement) === 'slider') {
2947 return;
2948 }
2949 if (handler(e) !== false) {
2950 e.preventDefault();
2951 }
2952 }
2953 if (e.isDefaultPrevented()) {
2954 return;
2955 }
2956 switch (e.keyCode) {
2957 case 37:
2958 handleNonTabOrEscEvent(e, left);
2959 break;
2960 case 39:
2961 handleNonTabOrEscEvent(e, right);
2962 break;
2963 case 38:
2964 handleNonTabOrEscEvent(e, up);
2965 break;
2966 case 40:
2967 handleNonTabOrEscEvent(e, down);
2968 break;
2969 case 27:
2970 cancel();
2971 break;
2972 case 14:
2973 case 13:
2974 case 32:
2975 handleNonTabOrEscEvent(e, enter);
2976 break;
2977 case 9:
2978 tab(e);
2979 e.preventDefault();
2980 break;
2981 }
2982 });
2983 root.on('focusin', function (e) {
2984 focusedElement = e.target;
2985 focusedControl = e.control;
2986 });
2987 return { focusFirst: focusFirst };
2988 }
2989
2990 var selectorCache = {};
2991 var Container = Control$1.extend({
2992 init: function (settings) {
2993 var self = this;
2994 self._super(settings);
2995 settings = self.settings;
2996 if (settings.fixed) {
2997 self.state.set('fixed', true);
2998 }
2999 self._items = new Collection$2();
3000 if (self.isRtl()) {
3001 self.classes.add('rtl');
3002 }
3003 self.bodyClasses = new ClassList(function () {
3004 if (self.state.get('rendered')) {
3005 self.getEl('body').className = this.toString();
3006 }
3007 });
3008 self.bodyClasses.prefix = self.classPrefix;
3009 self.classes.add('container');
3010 self.bodyClasses.add('container-body');
3011 if (settings.containerCls) {
3012 self.classes.add(settings.containerCls);
3013 }
3014 self._layout = global$4.create((settings.layout || '') + 'layout');
3015 if (self.settings.items) {
3016 self.add(self.settings.items);
3017 } else {
3018 self.add(self.render());
3019 }
3020 self._hasBody = true;
3021 },
3022 items: function () {
3023 return this._items;
3024 },
3025 find: function (selector) {
3026 selector = selectorCache[selector] = selectorCache[selector] || new Selector(selector);
3027 return selector.find(this);
3028 },
3029 add: function (items) {
3030 var self = this;
3031 self.items().add(self.create(items)).parent(self);
3032 return self;
3033 },
3034 focus: function (keyboard) {
3035 var self = this;
3036 var focusCtrl, keyboardNav, items;
3037 if (keyboard) {
3038 keyboardNav = self.keyboardNav || self.parents().eq(-1)[0].keyboardNav;
3039 if (keyboardNav) {
3040 keyboardNav.focusFirst(self);
3041 return;
3042 }
3043 }
3044 items = self.find('*');
3045 if (self.statusbar) {
3046 items.add(self.statusbar.items());
3047 }
3048 items.each(function (ctrl) {
3049 if (ctrl.settings.autofocus) {
3050 focusCtrl = null;
3051 return false;
3052 }
3053 if (ctrl.canFocus) {
3054 focusCtrl = focusCtrl || ctrl;
3055 }
3056 });
3057 if (focusCtrl) {
3058 focusCtrl.focus();
3059 }
3060 return self;
3061 },
3062 replace: function (oldItem, newItem) {
3063 var ctrlElm;
3064 var items = this.items();
3065 var i = items.length;
3066 while (i--) {
3067 if (items[i] === oldItem) {
3068 items[i] = newItem;
3069 break;
3070 }
3071 }
3072 if (i >= 0) {
3073 ctrlElm = newItem.getEl();
3074 if (ctrlElm) {
3075 ctrlElm.parentNode.removeChild(ctrlElm);
3076 }
3077 ctrlElm = oldItem.getEl();
3078 if (ctrlElm) {
3079 ctrlElm.parentNode.removeChild(ctrlElm);
3080 }
3081 }
3082 newItem.parent(this);
3083 },
3084 create: function (items) {
3085 var self = this;
3086 var settings;
3087 var ctrlItems = [];
3088 if (!global$2.isArray(items)) {
3089 items = [items];
3090 }
3091 global$2.each(items, function (item) {
3092 if (item) {
3093 if (!(item instanceof Control$1)) {
3094 if (typeof item === 'string') {
3095 item = { type: item };
3096 }
3097 settings = global$2.extend({}, self.settings.defaults, item);
3098 item.type = settings.type = settings.type || item.type || self.settings.defaultType || (settings.defaults ? settings.defaults.type : null);
3099 item = global$4.create(settings);
3100 }
3101 ctrlItems.push(item);
3102 }
3103 });
3104 return ctrlItems;
3105 },
3106 renderNew: function () {
3107 var self = this;
3108 self.items().each(function (ctrl, index) {
3109 var containerElm;
3110 ctrl.parent(self);
3111 if (!ctrl.state.get('rendered')) {
3112 containerElm = self.getEl('body');
3113 if (containerElm.hasChildNodes() && index <= containerElm.childNodes.length - 1) {
3114 global$9(containerElm.childNodes[index]).before(ctrl.renderHtml());
3115 } else {
3116 global$9(containerElm).append(ctrl.renderHtml());
3117 }
3118 ctrl.postRender();
3119 ReflowQueue.add(ctrl);
3120 }
3121 });
3122 self._layout.applyClasses(self.items().filter(':visible'));
3123 self._lastRect = null;
3124 return self;
3125 },
3126 append: function (items) {
3127 return this.add(items).renderNew();
3128 },
3129 prepend: function (items) {
3130 var self = this;
3131 self.items().set(self.create(items).concat(self.items().toArray()));
3132 return self.renderNew();
3133 },
3134 insert: function (items, index, before) {
3135 var self = this;
3136 var curItems, beforeItems, afterItems;
3137 items = self.create(items);
3138 curItems = self.items();
3139 if (!before && index < curItems.length - 1) {
3140 index += 1;
3141 }
3142 if (index >= 0 && index < curItems.length) {
3143 beforeItems = curItems.slice(0, index).toArray();
3144 afterItems = curItems.slice(index).toArray();
3145 curItems.set(beforeItems.concat(items, afterItems));
3146 }
3147 return self.renderNew();
3148 },
3149 fromJSON: function (data) {
3150 var self = this;
3151 for (var name in data) {
3152 self.find('#' + name).value(data[name]);
3153 }
3154 return self;
3155 },
3156 toJSON: function () {
3157 var self = this, data = {};
3158 self.find('*').each(function (ctrl) {
3159 var name = ctrl.name(), value = ctrl.value();
3160 if (name && typeof value !== 'undefined') {
3161 data[name] = value;
3162 }
3163 });
3164 return data;
3165 },
3166 renderHtml: function () {
3167 var self = this, layout = self._layout, role = this.settings.role;
3168 self.preRender();
3169 layout.preRender(self);
3170 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>';
3171 },
3172 postRender: function () {
3173 var self = this;
3174 var box;
3175 self.items().exec('postRender');
3176 self._super();
3177 self._layout.postRender(self);
3178 self.state.set('rendered', true);
3179 if (self.settings.style) {
3180 self.$el.css(self.settings.style);
3181 }
3182 if (self.settings.border) {
3183 box = self.borderBox;
3184 self.$el.css({
3185 'border-top-width': box.top,
3186 'border-right-width': box.right,
3187 'border-bottom-width': box.bottom,
3188 'border-left-width': box.left
3189 });
3190 }
3191 if (!self.parent()) {
3192 self.keyboardNav = KeyboardNavigation({ root: self });
3193 }
3194 return self;
3195 },
3196 initLayoutRect: function () {
3197 var self = this, layoutRect = self._super();
3198 self._layout.recalc(self);
3199 return layoutRect;
3200 },
3201 recalc: function () {
3202 var self = this;
3203 var rect = self._layoutRect;
3204 var lastRect = self._lastRect;
3205 if (!lastRect || lastRect.w !== rect.w || lastRect.h !== rect.h) {
3206 self._layout.recalc(self);
3207 rect = self.layoutRect();
3208 self._lastRect = {
3209 x: rect.x,
3210 y: rect.y,
3211 w: rect.w,
3212 h: rect.h
3213 };
3214 return true;
3215 }
3216 },
3217 reflow: function () {
3218 var i;
3219 ReflowQueue.remove(this);
3220 if (this.visible()) {
3221 Control$1.repaintControls = [];
3222 Control$1.repaintControls.map = {};
3223 this.recalc();
3224 i = Control$1.repaintControls.length;
3225 while (i--) {
3226 Control$1.repaintControls[i].repaint();
3227 }
3228 if (this.settings.layout !== 'flow' && this.settings.layout !== 'stack') {
3229 this.repaint();
3230 }
3231 Control$1.repaintControls = [];
3232 }
3233 return this;
3234 }
3235 });
3236
3237 function getDocumentSize(doc) {
3238 var documentElement, body, scrollWidth, clientWidth;
3239 var offsetWidth, scrollHeight, clientHeight, offsetHeight;
3240 var max = Math.max;
3241 documentElement = doc.documentElement;
3242 body = doc.body;
3243 scrollWidth = max(documentElement.scrollWidth, body.scrollWidth);
3244 clientWidth = max(documentElement.clientWidth, body.clientWidth);
3245 offsetWidth = max(documentElement.offsetWidth, body.offsetWidth);
3246 scrollHeight = max(documentElement.scrollHeight, body.scrollHeight);
3247 clientHeight = max(documentElement.clientHeight, body.clientHeight);
3248 offsetHeight = max(documentElement.offsetHeight, body.offsetHeight);
3249 return {
3250 width: scrollWidth < offsetWidth ? clientWidth : scrollWidth,
3251 height: scrollHeight < offsetHeight ? clientHeight : scrollHeight
3252 };
3253 }
3254 function updateWithTouchData(e) {
3255 var keys, i;
3256 if (e.changedTouches) {
3257 keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
3258 for (i = 0; i < keys.length; i++) {
3259 e[keys[i]] = e.changedTouches[0][keys[i]];
3260 }
3261 }
3262 }
3263 function DragHelper (id, settings) {
3264 var $eventOverlay;
3265 var doc = settings.document || domGlobals.document;
3266 var downButton;
3267 var start, stop, drag, startX, startY;
3268 settings = settings || {};
3269 var handleElement = doc.getElementById(settings.handle || id);
3270 start = function (e) {
3271 var docSize = getDocumentSize(doc);
3272 var handleElm, cursor;
3273 updateWithTouchData(e);
3274 e.preventDefault();
3275 downButton = e.button;
3276 handleElm = handleElement;
3277 startX = e.screenX;
3278 startY = e.screenY;
3279 if (domGlobals.window.getComputedStyle) {
3280 cursor = domGlobals.window.getComputedStyle(handleElm, null).getPropertyValue('cursor');
3281 } else {
3282 cursor = handleElm.runtimeStyle.cursor;
3283 }
3284 $eventOverlay = global$9('<div></div>').css({
3285 position: 'absolute',
3286 top: 0,
3287 left: 0,
3288 width: docSize.width,
3289 height: docSize.height,
3290 zIndex: 2147483647,
3291 opacity: 0.0001,
3292 cursor: cursor
3293 }).appendTo(doc.body);
3294 global$9(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop);
3295 settings.start(e);
3296 };
3297 drag = function (e) {
3298 updateWithTouchData(e);
3299 if (e.button !== downButton) {
3300 return stop(e);
3301 }
3302 e.deltaX = e.screenX - startX;
3303 e.deltaY = e.screenY - startY;
3304 e.preventDefault();
3305 settings.drag(e);
3306 };
3307 stop = function (e) {
3308 updateWithTouchData(e);
3309 global$9(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop);
3310 $eventOverlay.remove();
3311 if (settings.stop) {
3312 settings.stop(e);
3313 }
3314 };
3315 this.destroy = function () {
3316 global$9(handleElement).off();
3317 };
3318 global$9(handleElement).on('mousedown touchstart', start);
3319 }
3320
3321 var Scrollable = {
3322 init: function () {
3323 var self = this;
3324 self.on('repaint', self.renderScroll);
3325 },
3326 renderScroll: function () {
3327 var self = this, margin = 2;
3328 function repaintScroll() {
3329 var hasScrollH, hasScrollV, bodyElm;
3330 function repaintAxis(axisName, posName, sizeName, contentSizeName, hasScroll, ax) {
3331 var containerElm, scrollBarElm, scrollThumbElm;
3332 var containerSize, scrollSize, ratio, rect;
3333 var posNameLower, sizeNameLower;
3334 scrollBarElm = self.getEl('scroll' + axisName);
3335 if (scrollBarElm) {
3336 posNameLower = posName.toLowerCase();
3337 sizeNameLower = sizeName.toLowerCase();
3338 global$9(self.getEl('absend')).css(posNameLower, self.layoutRect()[contentSizeName] - 1);
3339 if (!hasScroll) {
3340 global$9(scrollBarElm).css('display', 'none');
3341 return;
3342 }
3343 global$9(scrollBarElm).css('display', 'block');
3344 containerElm = self.getEl('body');
3345 scrollThumbElm = self.getEl('scroll' + axisName + 't');
3346 containerSize = containerElm['client' + sizeName] - margin * 2;
3347 containerSize -= hasScrollH && hasScrollV ? scrollBarElm['client' + ax] : 0;
3348 scrollSize = containerElm['scroll' + sizeName];
3349 ratio = containerSize / scrollSize;
3350 rect = {};
3351 rect[posNameLower] = containerElm['offset' + posName] + margin;
3352 rect[sizeNameLower] = containerSize;
3353 global$9(scrollBarElm).css(rect);
3354 rect = {};
3355 rect[posNameLower] = containerElm['scroll' + posName] * ratio;
3356 rect[sizeNameLower] = containerSize * ratio;
3357 global$9(scrollThumbElm).css(rect);
3358 }
3359 }
3360 bodyElm = self.getEl('body');
3361 hasScrollH = bodyElm.scrollWidth > bodyElm.clientWidth;
3362 hasScrollV = bodyElm.scrollHeight > bodyElm.clientHeight;
3363 repaintAxis('h', 'Left', 'Width', 'contentW', hasScrollH, 'Height');
3364 repaintAxis('v', 'Top', 'Height', 'contentH', hasScrollV, 'Width');
3365 }
3366 function addScroll() {
3367 function addScrollAxis(axisName, posName, sizeName, deltaPosName, ax) {
3368 var scrollStart;
3369 var axisId = self._id + '-scroll' + axisName, prefix = self.classPrefix;
3370 global$9(self.getEl()).append('<div id="' + axisId + '" class="' + prefix + 'scrollbar ' + prefix + 'scrollbar-' + axisName + '">' + '<div id="' + axisId + 't" class="' + prefix + 'scrollbar-thumb"></div>' + '</div>');
3371 self.draghelper = new DragHelper(axisId + 't', {
3372 start: function () {
3373 scrollStart = self.getEl('body')['scroll' + posName];
3374 global$9('#' + axisId).addClass(prefix + 'active');
3375 },
3376 drag: function (e) {
3377 var ratio, hasScrollH, hasScrollV, containerSize;
3378 var layoutRect = self.layoutRect();
3379 hasScrollH = layoutRect.contentW > layoutRect.innerW;
3380 hasScrollV = layoutRect.contentH > layoutRect.innerH;
3381 containerSize = self.getEl('body')['client' + sizeName] - margin * 2;
3382 containerSize -= hasScrollH && hasScrollV ? self.getEl('scroll' + axisName)['client' + ax] : 0;
3383 ratio = containerSize / self.getEl('body')['scroll' + sizeName];
3384 self.getEl('body')['scroll' + posName] = scrollStart + e['delta' + deltaPosName] / ratio;
3385 },
3386 stop: function () {
3387 global$9('#' + axisId).removeClass(prefix + 'active');
3388 }
3389 });
3390 }
3391 self.classes.add('scroll');
3392 addScrollAxis('v', 'Top', 'Height', 'Y', 'Width');
3393 addScrollAxis('h', 'Left', 'Width', 'X', 'Height');
3394 }
3395 if (self.settings.autoScroll) {
3396 if (!self._hasScroll) {
3397 self._hasScroll = true;
3398 addScroll();
3399 self.on('wheel', function (e) {
3400 var bodyEl = self.getEl('body');
3401 bodyEl.scrollLeft += (e.deltaX || 0) * 10;
3402 bodyEl.scrollTop += e.deltaY * 10;
3403 repaintScroll();
3404 });
3405 global$9(self.getEl('body')).on('scroll', repaintScroll);
3406 }
3407 repaintScroll();
3408 }
3409 }
3410 };
3411
3412 var Panel = Container.extend({
3413 Defaults: {
3414 layout: 'fit',
3415 containerCls: 'panel'
3416 },
3417 Mixins: [Scrollable],
3418 renderHtml: function () {
3419 var self = this;
3420 var layout = self._layout;
3421 var innerHtml = self.settings.html;
3422 self.preRender();
3423 layout.preRender(self);
3424 if (typeof innerHtml === 'undefined') {
3425 innerHtml = '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>';
3426 } else {
3427 if (typeof innerHtml === 'function') {
3428 innerHtml = innerHtml.call(self);
3429 }
3430 self._hasBody = false;
3431 }
3432 return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1" role="group">' + (self._preBodyHtml || '') + innerHtml + '</div>';
3433 }
3434 });
3435
3436 var Resizable = {
3437 resizeToContent: function () {
3438 this._layoutRect.autoResize = true;
3439 this._lastRect = null;
3440 this.reflow();
3441 },
3442 resizeTo: function (w, h) {
3443 if (w <= 1 || h <= 1) {
3444 var rect = funcs.getWindowSize();
3445 w = w <= 1 ? w * rect.w : w;
3446 h = h <= 1 ? h * rect.h : h;
3447 }
3448 this._layoutRect.autoResize = false;
3449 return this.layoutRect({
3450 minW: w,
3451 minH: h,
3452 w: w,
3453 h: h
3454 }).reflow();
3455 },
3456 resizeBy: function (dw, dh) {
3457 var self = this, rect = self.layoutRect();
3458 return self.resizeTo(rect.w + dw, rect.h + dh);
3459 }
3460 };
3461
3462 var documentClickHandler, documentScrollHandler, windowResizeHandler;
3463 var visiblePanels = [];
3464 var zOrder = [];
3465 var hasModal;
3466 function isChildOf(ctrl, parent) {
3467 while (ctrl) {
3468 if (ctrl === parent) {
3469 return true;
3470 }
3471 ctrl = ctrl.parent();
3472 }
3473 }
3474 function skipOrHidePanels(e) {
3475 var i = visiblePanels.length;
3476 while (i--) {
3477 var panel = visiblePanels[i], clickCtrl = panel.getParentCtrl(e.target);
3478 if (panel.settings.autohide) {
3479 if (clickCtrl) {
3480 if (isChildOf(clickCtrl, panel) || panel.parent() === clickCtrl) {
3481 continue;
3482 }
3483 }
3484 e = panel.fire('autohide', { target: e.target });
3485 if (!e.isDefaultPrevented()) {
3486 panel.hide();
3487 }
3488 }
3489 }
3490 }
3491 function bindDocumentClickHandler() {
3492 if (!documentClickHandler) {
3493 documentClickHandler = function (e) {
3494 if (e.button === 2) {
3495 return;
3496 }
3497 skipOrHidePanels(e);
3498 };
3499 global$9(domGlobals.document).on('click touchstart', documentClickHandler);
3500 }
3501 }
3502 function bindDocumentScrollHandler() {
3503 if (!documentScrollHandler) {
3504 documentScrollHandler = function () {
3505 var i;
3506 i = visiblePanels.length;
3507 while (i--) {
3508 repositionPanel(visiblePanels[i]);
3509 }
3510 };
3511 global$9(domGlobals.window).on('scroll', documentScrollHandler);
3512 }
3513 }
3514 function bindWindowResizeHandler() {
3515 if (!windowResizeHandler) {
3516 var docElm_1 = domGlobals.document.documentElement;
3517 var clientWidth_1 = docElm_1.clientWidth, clientHeight_1 = docElm_1.clientHeight;
3518 windowResizeHandler = function () {
3519 if (!domGlobals.document.all || clientWidth_1 !== docElm_1.clientWidth || clientHeight_1 !== docElm_1.clientHeight) {
3520 clientWidth_1 = docElm_1.clientWidth;
3521 clientHeight_1 = docElm_1.clientHeight;
3522 FloatPanel.hideAll();
3523 }
3524 };
3525 global$9(domGlobals.window).on('resize', windowResizeHandler);
3526 }
3527 }
3528 function repositionPanel(panel) {
3529 var scrollY = funcs.getViewPort().y;
3530 function toggleFixedChildPanels(fixed, deltaY) {
3531 var parent;
3532 for (var i = 0; i < visiblePanels.length; i++) {
3533 if (visiblePanels[i] !== panel) {
3534 parent = visiblePanels[i].parent();
3535 while (parent && (parent = parent.parent())) {
3536 if (parent === panel) {
3537 visiblePanels[i].fixed(fixed).moveBy(0, deltaY).repaint();
3538 }
3539 }
3540 }
3541 }
3542 }
3543 if (panel.settings.autofix) {
3544 if (!panel.state.get('fixed')) {
3545 panel._autoFixY = panel.layoutRect().y;
3546 if (panel._autoFixY < scrollY) {
3547 panel.fixed(true).layoutRect({ y: 0 }).repaint();
3548 toggleFixedChildPanels(true, scrollY - panel._autoFixY);
3549 }
3550 } else {
3551 if (panel._autoFixY > scrollY) {
3552 panel.fixed(false).layoutRect({ y: panel._autoFixY }).repaint();
3553 toggleFixedChildPanels(false, panel._autoFixY - scrollY);
3554 }
3555 }
3556 }
3557 }
3558 function addRemove(add, ctrl) {
3559 var i, zIndex = FloatPanel.zIndex || 65535, topModal;
3560 if (add) {
3561 zOrder.push(ctrl);
3562 } else {
3563 i = zOrder.length;
3564 while (i--) {
3565 if (zOrder[i] === ctrl) {
3566 zOrder.splice(i, 1);
3567 }
3568 }
3569 }
3570 if (zOrder.length) {
3571 for (i = 0; i < zOrder.length; i++) {
3572 if (zOrder[i].modal) {
3573 zIndex++;
3574 topModal = zOrder[i];
3575 }
3576 zOrder[i].getEl().style.zIndex = zIndex;
3577 zOrder[i].zIndex = zIndex;
3578 zIndex++;
3579 }
3580 }
3581 var modalBlockEl = global$9('#' + ctrl.classPrefix + 'modal-block', ctrl.getContainerElm())[0];
3582 if (topModal) {
3583 global$9(modalBlockEl).css('z-index', topModal.zIndex - 1);
3584 } else if (modalBlockEl) {
3585 modalBlockEl.parentNode.removeChild(modalBlockEl);
3586 hasModal = false;
3587 }
3588 FloatPanel.currentZIndex = zIndex;
3589 }
3590 var FloatPanel = Panel.extend({
3591 Mixins: [
3592 Movable,
3593 Resizable
3594 ],
3595 init: function (settings) {
3596 var self = this;
3597 self._super(settings);
3598 self._eventsRoot = self;
3599 self.classes.add('floatpanel');
3600 if (settings.autohide) {
3601 bindDocumentClickHandler();
3602 bindWindowResizeHandler();
3603 visiblePanels.push(self);
3604 }
3605 if (settings.autofix) {
3606 bindDocumentScrollHandler();
3607 self.on('move', function () {
3608 repositionPanel(this);
3609 });
3610 }
3611 self.on('postrender show', function (e) {
3612 if (e.control === self) {
3613 var $modalBlockEl_1;
3614 var prefix_1 = self.classPrefix;
3615 if (self.modal && !hasModal) {
3616 $modalBlockEl_1 = global$9('#' + prefix_1 + 'modal-block', self.getContainerElm());
3617 if (!$modalBlockEl_1[0]) {
3618 $modalBlockEl_1 = global$9('<div id="' + prefix_1 + 'modal-block" class="' + prefix_1 + 'reset ' + prefix_1 + 'fade"></div>').appendTo(self.getContainerElm());
3619 }
3620 global$7.setTimeout(function () {
3621 $modalBlockEl_1.addClass(prefix_1 + 'in');
3622 global$9(self.getEl()).addClass(prefix_1 + 'in');
3623 });
3624 hasModal = true;
3625 }
3626 addRemove(true, self);
3627 }
3628 });
3629 self.on('show', function () {
3630 self.parents().each(function (ctrl) {
3631 if (ctrl.state.get('fixed')) {
3632 self.fixed(true);
3633 return false;
3634 }
3635 });
3636 });
3637 if (settings.popover) {
3638 self._preBodyHtml = '<div class="' + self.classPrefix + 'arrow"></div>';
3639 self.classes.add('popover').add('bottom').add(self.isRtl() ? 'end' : 'start');
3640 }
3641 self.aria('label', settings.ariaLabel);
3642 self.aria('labelledby', self._id);
3643 self.aria('describedby', self.describedBy || self._id + '-none');
3644 },
3645 fixed: function (state) {
3646 var self = this;
3647 if (self.state.get('fixed') !== state) {
3648 if (self.state.get('rendered')) {
3649 var viewport = funcs.getViewPort();
3650 if (state) {
3651 self.layoutRect().y -= viewport.y;
3652 } else {
3653 self.layoutRect().y += viewport.y;
3654 }
3655 }
3656 self.classes.toggle('fixed', state);
3657 self.state.set('fixed', state);
3658 }
3659 return self;
3660 },
3661 show: function () {
3662 var self = this;
3663 var i;
3664 var state = self._super();
3665 i = visiblePanels.length;
3666 while (i--) {
3667 if (visiblePanels[i] === self) {
3668 break;
3669 }
3670 }
3671 if (i === -1) {
3672 visiblePanels.push(self);
3673 }
3674 return state;
3675 },
3676 hide: function () {
3677 removeVisiblePanel(this);
3678 addRemove(false, this);
3679 return this._super();
3680 },
3681 hideAll: function () {
3682 FloatPanel.hideAll();
3683 },
3684 close: function () {
3685 var self = this;
3686 if (!self.fire('close').isDefaultPrevented()) {
3687 self.remove();
3688 addRemove(false, self);
3689 }
3690 return self;
3691 },
3692 remove: function () {
3693 removeVisiblePanel(this);
3694 this._super();
3695 },
3696 postRender: function () {
3697 var self = this;
3698 if (self.settings.bodyRole) {
3699 this.getEl('body').setAttribute('role', self.settings.bodyRole);
3700 }
3701 return self._super();
3702 }
3703 });
3704 FloatPanel.hideAll = function () {
3705 var i = visiblePanels.length;
3706 while (i--) {
3707 var panel = visiblePanels[i];
3708 if (panel && panel.settings.autohide) {
3709 panel.hide();
3710 visiblePanels.splice(i, 1);
3711 }
3712 }
3713 };
3714 function removeVisiblePanel(panel) {
3715 var i;
3716 i = visiblePanels.length;
3717 while (i--) {
3718 if (visiblePanels[i] === panel) {
3719 visiblePanels.splice(i, 1);
3720 }
3721 }
3722 i = zOrder.length;
3723 while (i--) {
3724 if (zOrder[i] === panel) {
3725 zOrder.splice(i, 1);
3726 }
3727 }
3728 }
3729
3730 var isFixed$1 = function (inlineToolbarContainer, editor) {
3731 return !!(inlineToolbarContainer && !editor.settings.ui_container);
3732 };
3733 var render$1 = function (editor, theme, args) {
3734 var panel, inlineToolbarContainer;
3735 var DOM = global$3.DOM;
3736 var fixedToolbarContainer = getFixedToolbarContainer(editor);
3737 if (fixedToolbarContainer) {
3738 inlineToolbarContainer = DOM.select(fixedToolbarContainer)[0];
3739 }
3740 var reposition = function () {
3741 if (panel && panel.moveRel && panel.visible() && !panel._fixed) {
3742 var scrollContainer = editor.selection.getScrollContainer(), body = editor.getBody();
3743 var deltaX = 0, deltaY = 0;
3744 if (scrollContainer) {
3745 var bodyPos = DOM.getPos(body), scrollContainerPos = DOM.getPos(scrollContainer);
3746 deltaX = Math.max(0, scrollContainerPos.x - bodyPos.x);
3747 deltaY = Math.max(0, scrollContainerPos.y - bodyPos.y);
3748 }
3749 panel.fixed(false).moveRel(body, editor.rtl ? [
3750 'tr-br',
3751 'br-tr'
3752 ] : [
3753 'tl-bl',
3754 'bl-tl',
3755 'tr-br'
3756 ]).moveBy(deltaX, deltaY);
3757 }
3758 };
3759 var show = function () {
3760 if (panel) {
3761 panel.show();
3762 reposition();
3763 DOM.addClass(editor.getBody(), 'mce-edit-focus');
3764 }
3765 };
3766 var hide = function () {
3767 if (panel) {
3768 panel.hide();
3769 FloatPanel.hideAll();
3770 DOM.removeClass(editor.getBody(), 'mce-edit-focus');
3771 }
3772 };
3773 var render = function () {
3774 if (panel) {
3775 if (!panel.visible()) {
3776 show();
3777 }
3778 return;
3779 }
3780 panel = theme.panel = global$4.create({
3781 type: inlineToolbarContainer ? 'panel' : 'floatpanel',
3782 role: 'application',
3783 classes: 'tinymce tinymce-inline',
3784 layout: 'flex',
3785 direction: 'column',
3786 align: 'stretch',
3787 autohide: false,
3788 autofix: true,
3789 fixed: isFixed$1(inlineToolbarContainer, editor),
3790 border: 1,
3791 items: [
3792 hasMenubar(editor) === false ? null : {
3793 type: 'menubar',
3794 border: '0 0 1 0',
3795 items: Menubar.createMenuButtons(editor)
3796 },
3797 Toolbar.createToolbars(editor, getToolbarSize(editor))
3798 ]
3799 });
3800 UiContainer.setUiContainer(editor, panel);
3801 Events.fireBeforeRenderUI(editor);
3802 if (inlineToolbarContainer) {
3803 panel.renderTo(inlineToolbarContainer).reflow();
3804 } else {
3805 panel.renderTo().reflow();
3806 }
3807 A11y.addKeys(editor, panel);
3808 show();
3809 ContextToolbars.addContextualToolbars(editor);
3810 editor.on('nodeChange', reposition);
3811 editor.on('ResizeWindow', reposition);
3812 editor.on('activate', show);
3813 editor.on('deactivate', hide);
3814 editor.nodeChanged();
3815 };
3816 editor.settings.content_editable = true;
3817 editor.on('focus', function () {
3818 if (isSkinDisabled(editor) === false && args.skinUiCss) {
3819 DOM.styleSheetLoader.load(args.skinUiCss, render, render);
3820 } else {
3821 render();
3822 }
3823 });
3824 editor.on('blur hide', hide);
3825 editor.on('remove', function () {
3826 if (panel) {
3827 panel.remove();
3828 panel = null;
3829 }
3830 });
3831 if (isSkinDisabled(editor) === false && args.skinUiCss) {
3832 DOM.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor));
3833 } else {
3834 SkinLoaded.fireSkinLoaded(editor)();
3835 }
3836 return {};
3837 };
3838 var Inline = { render: render$1 };
3839
3840 function Throbber (elm, inline) {
3841 var self = this;
3842 var state;
3843 var classPrefix = Control$1.classPrefix;
3844 var timer;
3845 self.show = function (time, callback) {
3846 function render() {
3847 if (state) {
3848 global$9(elm).append('<div class="' + classPrefix + 'throbber' + (inline ? ' ' + classPrefix + 'throbber-inline' : '') + '"></div>');
3849 if (callback) {
3850 callback();
3851 }
3852 }
3853 }
3854 self.hide();
3855 state = true;
3856 if (time) {
3857 timer = global$7.setTimeout(render, time);
3858 } else {
3859 render();
3860 }
3861 return self;
3862 };
3863 self.hide = function () {
3864 var child = elm.lastChild;
3865 global$7.clearTimeout(timer);
3866 if (child && child.className.indexOf('throbber') !== -1) {
3867 child.parentNode.removeChild(child);
3868 }
3869 state = false;
3870 return self;
3871 };
3872 }
3873
3874 var setup = function (editor, theme) {
3875 var throbber;
3876 editor.on('ProgressState', function (e) {
3877 throbber = throbber || new Throbber(theme.panel.getEl('body'));
3878 if (e.state) {
3879 throbber.show(e.time);
3880 } else {
3881 throbber.hide();
3882 }
3883 });
3884 };
3885 var ProgressState = { setup: setup };
3886
3887 var renderUI = function (editor, theme, args) {
3888 var skinUrl = getSkinUrl(editor);
3889 if (skinUrl) {
3890 args.skinUiCss = skinUrl + '/skin.min.css';
3891 editor.contentCSS.push(skinUrl + '/content' + (editor.inline ? '.inline' : '') + '.min.css');
3892 }
3893 ProgressState.setup(editor, theme);
3894 return isInline(editor) ? Inline.render(editor, theme, args) : Iframe.render(editor, theme, args);
3895 };
3896 var Render = { renderUI: renderUI };
3897
3898 var Tooltip = Control$1.extend({
3899 Mixins: [Movable],
3900 Defaults: { classes: 'widget tooltip tooltip-n' },
3901 renderHtml: function () {
3902 var self = this, prefix = self.classPrefix;
3903 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>';
3904 },
3905 bindStates: function () {
3906 var self = this;
3907 self.state.on('change:text', function (e) {
3908 self.getEl().lastChild.innerHTML = self.encode(e.value);
3909 });
3910 return self._super();
3911 },
3912 repaint: function () {
3913 var self = this;
3914 var style, rect;
3915 style = self.getEl().style;
3916 rect = self._layoutRect;
3917 style.left = rect.x + 'px';
3918 style.top = rect.y + 'px';
3919 style.zIndex = 65535 + 65535;
3920 }
3921 });
3922
3923 var Widget = Control$1.extend({
3924 init: function (settings) {
3925 var self = this;
3926 self._super(settings);
3927 settings = self.settings;
3928 self.canFocus = true;
3929 if (settings.tooltip && Widget.tooltips !== false) {
3930 self.on('mouseenter', function (e) {
3931 var tooltip = self.tooltip().moveTo(-65535);
3932 if (e.control === self) {
3933 var rel = tooltip.text(settings.tooltip).show().testMoveRel(self.getEl(), [
3934 'bc-tc',
3935 'bc-tl',
3936 'bc-tr'
3937 ]);
3938 tooltip.classes.toggle('tooltip-n', rel === 'bc-tc');
3939 tooltip.classes.toggle('tooltip-nw', rel === 'bc-tl');
3940 tooltip.classes.toggle('tooltip-ne', rel === 'bc-tr');
3941 tooltip.moveRel(self.getEl(), rel);
3942 } else {
3943 tooltip.hide();
3944 }
3945 });
3946 self.on('mouseleave mousedown click', function () {
3947 self.tooltip().remove();
3948 self._tooltip = null;
3949 });
3950 }
3951 self.aria('label', settings.ariaLabel || settings.tooltip);
3952 },
3953 tooltip: function () {
3954 if (!this._tooltip) {
3955 this._tooltip = new Tooltip({ type: 'tooltip' });
3956 UiContainer.inheritUiContainer(this, this._tooltip);
3957 this._tooltip.renderTo();
3958 }
3959 return this._tooltip;
3960 },
3961 postRender: function () {
3962 var self = this, settings = self.settings;
3963 self._super();
3964 if (!self.parent() && (settings.width || settings.height)) {
3965 self.initLayoutRect();
3966 self.repaint();
3967 }
3968 if (settings.autofocus) {
3969 self.focus();
3970 }
3971 },
3972 bindStates: function () {
3973 var self = this;
3974 function disable(state) {
3975 self.aria('disabled', state);
3976 self.classes.toggle('disabled', state);
3977 }
3978 function active(state) {
3979 self.aria('pressed', state);
3980 self.classes.toggle('active', state);
3981 }
3982 self.state.on('change:disabled', function (e) {
3983 disable(e.value);
3984 });
3985 self.state.on('change:active', function (e) {
3986 active(e.value);
3987 });
3988 if (self.state.get('disabled')) {
3989 disable(true);
3990 }
3991 if (self.state.get('active')) {
3992 active(true);
3993 }
3994 return self._super();
3995 },
3996 remove: function () {
3997 this._super();
3998 if (this._tooltip) {
3999 this._tooltip.remove();
4000 this._tooltip = null;
4001 }
4002 }
4003 });
4004
4005 var Progress = Widget.extend({
4006 Defaults: { value: 0 },
4007 init: function (settings) {
4008 var self = this;
4009 self._super(settings);
4010 self.classes.add('progress');
4011 if (!self.settings.filter) {
4012 self.settings.filter = function (value) {
4013 return Math.round(value);
4014 };
4015 }
4016 },
4017 renderHtml: function () {
4018 var self = this, id = self._id, prefix = this.classPrefix;
4019 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>';
4020 },
4021 postRender: function () {
4022 var self = this;
4023 self._super();
4024 self.value(self.settings.value);
4025 return self;
4026 },
4027 bindStates: function () {
4028 var self = this;
4029 function setValue(value) {
4030 value = self.settings.filter(value);
4031 self.getEl().lastChild.innerHTML = value + '%';
4032 self.getEl().firstChild.firstChild.style.width = value + '%';
4033 }
4034 self.state.on('change:value', function (e) {
4035 setValue(e.value);
4036 });
4037 setValue(self.state.get('value'));
4038 return self._super();
4039 }
4040 });
4041
4042 var updateLiveRegion = function (ctx, text) {
4043 ctx.getEl().lastChild.textContent = text + (ctx.progressBar ? ' ' + ctx.progressBar.value() + '%' : '');
4044 };
4045 var Notification = Control$1.extend({
4046 Mixins: [Movable],
4047 Defaults: { classes: 'widget notification' },
4048 init: function (settings) {
4049 var self = this;
4050 self._super(settings);
4051 self.maxWidth = settings.maxWidth;
4052 if (settings.text) {
4053 self.text(settings.text);
4054 }
4055 if (settings.icon) {
4056 self.icon = settings.icon;
4057 }
4058 if (settings.color) {
4059 self.color = settings.color;
4060 }
4061 if (settings.type) {
4062 self.classes.add('notification-' + settings.type);
4063 }
4064 if (settings.timeout && (settings.timeout < 0 || settings.timeout > 0) && !settings.closeButton) {
4065 self.closeButton = false;
4066 } else {
4067 self.classes.add('has-close');
4068 self.closeButton = true;
4069 }
4070 if (settings.progressBar) {
4071 self.progressBar = new Progress();
4072 }
4073 self.on('click', function (e) {
4074 if (e.target.className.indexOf(self.classPrefix + 'close') !== -1) {
4075 self.close();
4076 }
4077 });
4078 },
4079 renderHtml: function () {
4080 var self = this;
4081 var prefix = self.classPrefix;
4082 var icon = '', closeButton = '', progressBar = '', notificationStyle = '';
4083 if (self.icon) {
4084 icon = '<i class="' + prefix + 'ico' + ' ' + prefix + 'i-' + self.icon + '"></i>';
4085 }
4086 notificationStyle = ' style="max-width: ' + self.maxWidth + 'px;' + (self.color ? 'background-color: ' + self.color + ';"' : '"');
4087 if (self.closeButton) {
4088 closeButton = '<button type="button" class="' + prefix + 'close" aria-hidden="true">\xD7</button>';
4089 }
4090 if (self.progressBar) {
4091 progressBar = self.progressBar.renderHtml();
4092 }
4093 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>';
4094 },
4095 postRender: function () {
4096 var self = this;
4097 global$7.setTimeout(function () {
4098 self.$el.addClass(self.classPrefix + 'in');
4099 updateLiveRegion(self, self.state.get('text'));
4100 }, 100);
4101 return self._super();
4102 },
4103 bindStates: function () {
4104 var self = this;
4105 self.state.on('change:text', function (e) {
4106 self.getEl().firstChild.innerHTML = e.value;
4107 updateLiveRegion(self, e.value);
4108 });
4109 if (self.progressBar) {
4110 self.progressBar.bindStates();
4111 self.progressBar.state.on('change:value', function (e) {
4112 updateLiveRegion(self, self.state.get('text'));
4113 });
4114 }
4115 return self._super();
4116 },
4117 close: function () {
4118 var self = this;
4119 if (!self.fire('close').isDefaultPrevented()) {
4120 self.remove();
4121 }
4122 return self;
4123 },
4124 repaint: function () {
4125 var self = this;
4126 var style, rect;
4127 style = self.getEl().style;
4128 rect = self._layoutRect;
4129 style.left = rect.x + 'px';
4130 style.top = rect.y + 'px';
4131 style.zIndex = 65535 - 1;
4132 }
4133 });
4134
4135 function NotificationManagerImpl (editor) {
4136 var getEditorContainer = function (editor) {
4137 return editor.inline ? editor.getElement() : editor.getContentAreaContainer();
4138 };
4139 var getContainerWidth = function () {
4140 var container = getEditorContainer(editor);
4141 return funcs.getSize(container).width;
4142 };
4143 var prePositionNotifications = function (notifications) {
4144 each(notifications, function (notification) {
4145 notification.moveTo(0, 0);
4146 });
4147 };
4148 var positionNotifications = function (notifications) {
4149 if (notifications.length > 0) {
4150 var firstItem = notifications.slice(0, 1)[0];
4151 var container = getEditorContainer(editor);
4152 firstItem.moveRel(container, 'tc-tc');
4153 each(notifications, function (notification, index) {
4154 if (index > 0) {
4155 notification.moveRel(notifications[index - 1].getEl(), 'bc-tc');
4156 }
4157 });
4158 }
4159 };
4160 var reposition = function (notifications) {
4161 prePositionNotifications(notifications);
4162 positionNotifications(notifications);
4163 };
4164 var open = function (args, closeCallback) {
4165 var extendedArgs = global$2.extend(args, { maxWidth: getContainerWidth() });
4166 var notif = new Notification(extendedArgs);
4167 notif.args = extendedArgs;
4168 if (extendedArgs.timeout > 0) {
4169 notif.timer = setTimeout(function () {
4170 notif.close();
4171 closeCallback();
4172 }, extendedArgs.timeout);
4173 }
4174 notif.on('close', function () {
4175 closeCallback();
4176 });
4177 notif.renderTo();
4178 return notif;
4179 };
4180 var close = function (notification) {
4181 notification.close();
4182 };
4183 var getArgs = function (notification) {
4184 return notification.args;
4185 };
4186 return {
4187 open: open,
4188 close: close,
4189 reposition: reposition,
4190 getArgs: getArgs
4191 };
4192 }
4193
4194 var windows = [];
4195 var oldMetaValue = '';
4196 function toggleFullScreenState(state) {
4197 var noScaleMetaValue = 'width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0';
4198 var viewport = global$9('meta[name=viewport]')[0], contentValue;
4199 if (global$8.overrideViewPort === false) {
4200 return;
4201 }
4202 if (!viewport) {
4203 viewport = domGlobals.document.createElement('meta');
4204 viewport.setAttribute('name', 'viewport');
4205 domGlobals.document.getElementsByTagName('head')[0].appendChild(viewport);
4206 }
4207 contentValue = viewport.getAttribute('content');
4208 if (contentValue && typeof oldMetaValue !== 'undefined') {
4209 oldMetaValue = contentValue;
4210 }
4211 viewport.setAttribute('content', state ? noScaleMetaValue : oldMetaValue);
4212 }
4213 function toggleBodyFullScreenClasses(classPrefix, state) {
4214 if (checkFullscreenWindows() && state === false) {
4215 global$9([
4216 domGlobals.document.documentElement,
4217 domGlobals.document.body
4218 ]).removeClass(classPrefix + 'fullscreen');
4219 }
4220 }
4221 function checkFullscreenWindows() {
4222 for (var i = 0; i < windows.length; i++) {
4223 if (windows[i]._fullscreen) {
4224 return true;
4225 }
4226 }
4227 return false;
4228 }
4229 function handleWindowResize() {
4230 if (!global$8.desktop) {
4231 var lastSize_1 = {
4232 w: domGlobals.window.innerWidth,
4233 h: domGlobals.window.innerHeight
4234 };
4235 global$7.setInterval(function () {
4236 var w = domGlobals.window.innerWidth, h = domGlobals.window.innerHeight;
4237 if (lastSize_1.w !== w || lastSize_1.h !== h) {
4238 lastSize_1 = {
4239 w: w,
4240 h: h
4241 };
4242 global$9(domGlobals.window).trigger('resize');
4243 }
4244 }, 100);
4245 }
4246 function reposition() {
4247 var i;
4248 var rect = funcs.getWindowSize();
4249 var layoutRect;
4250 for (i = 0; i < windows.length; i++) {
4251 layoutRect = windows[i].layoutRect();
4252 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));
4253 }
4254 }
4255 global$9(domGlobals.window).on('resize', reposition);
4256 }
4257 var Window = FloatPanel.extend({
4258 modal: true,
4259 Defaults: {
4260 border: 1,
4261 layout: 'flex',
4262 containerCls: 'panel',
4263 role: 'dialog',
4264 callbacks: {
4265 submit: function () {
4266 this.fire('submit', { data: this.toJSON() });
4267 },
4268 close: function () {
4269 this.close();
4270 }
4271 }
4272 },
4273 init: function (settings) {
4274 var self = this;
4275 self._super(settings);
4276 if (self.isRtl()) {
4277 self.classes.add('rtl');
4278 }
4279 self.classes.add('window');
4280 self.bodyClasses.add('window-body');
4281 self.state.set('fixed', true);
4282 if (settings.buttons) {
4283 self.statusbar = new Panel({
4284 layout: 'flex',
4285 border: '1 0 0 0',
4286 spacing: 3,
4287 padding: 10,
4288 align: 'center',
4289 pack: self.isRtl() ? 'start' : 'end',
4290 defaults: { type: 'button' },
4291 items: settings.buttons
4292 });
4293 self.statusbar.classes.add('foot');
4294 self.statusbar.parent(self);
4295 }
4296 self.on('click', function (e) {
4297 var closeClass = self.classPrefix + 'close';
4298 if (funcs.hasClass(e.target, closeClass) || funcs.hasClass(e.target.parentNode, closeClass)) {
4299 self.close();
4300 }
4301 });
4302 self.on('cancel', function () {
4303 self.close();
4304 });
4305 self.on('move', function (e) {
4306 if (e.control === self) {
4307 FloatPanel.hideAll();
4308 }
4309 });
4310 self.aria('describedby', self.describedBy || self._id + '-none');
4311 self.aria('label', settings.title);
4312 self._fullscreen = false;
4313 },
4314 recalc: function () {
4315 var self = this;
4316 var statusbar = self.statusbar;
4317 var layoutRect, width, x, needsRecalc;
4318 if (self._fullscreen) {
4319 self.layoutRect(funcs.getWindowSize());
4320 self.layoutRect().contentH = self.layoutRect().innerH;
4321 }
4322 self._super();
4323 layoutRect = self.layoutRect();
4324 if (self.settings.title && !self._fullscreen) {
4325 width = layoutRect.headerW;
4326 if (width > layoutRect.w) {
4327 x = layoutRect.x - Math.max(0, width / 2);
4328 self.layoutRect({
4329 w: width,
4330 x: x
4331 });
4332 needsRecalc = true;
4333 }
4334 }
4335 if (statusbar) {
4336 statusbar.layoutRect({ w: self.layoutRect().innerW }).recalc();
4337 width = statusbar.layoutRect().minW + layoutRect.deltaW;
4338 if (width > layoutRect.w) {
4339 x = layoutRect.x - Math.max(0, width - layoutRect.w);
4340 self.layoutRect({
4341 w: width,
4342 x: x
4343 });
4344 needsRecalc = true;
4345 }
4346 }
4347 if (needsRecalc) {
4348 self.recalc();
4349 }
4350 },
4351 initLayoutRect: function () {
4352 var self = this;
4353 var layoutRect = self._super();
4354 var deltaH = 0, headEl;
4355 if (self.settings.title && !self._fullscreen) {
4356 headEl = self.getEl('head');
4357 var size = funcs.getSize(headEl);
4358 layoutRect.headerW = size.width;
4359 layoutRect.headerH = size.height;
4360 deltaH += layoutRect.headerH;
4361 }
4362 if (self.statusbar) {
4363 deltaH += self.statusbar.layoutRect().h;
4364 }
4365 layoutRect.deltaH += deltaH;
4366 layoutRect.minH += deltaH;
4367 layoutRect.h += deltaH;
4368 var rect = funcs.getWindowSize();
4369 layoutRect.x = self.settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2);
4370 layoutRect.y = self.settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2);
4371 return layoutRect;
4372 },
4373 renderHtml: function () {
4374 var self = this, layout = self._layout, id = self._id, prefix = self.classPrefix;
4375 var settings = self.settings;
4376 var headerHtml = '', footerHtml = '', html = settings.html;
4377 self.preRender();
4378 layout.preRender(self);
4379 if (settings.title) {
4380 headerHtml = '<div id="' + id + '-head" class="' + prefix + 'window-head">' + '<div id="' + id + '-title" class="' + prefix + 'title">' + self.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>';
4381 }
4382 if (settings.url) {
4383 html = '<iframe src="' + settings.url + '" tabindex="-1"></iframe>';
4384 }
4385 if (typeof html === 'undefined') {
4386 html = layout.renderHtml(self);
4387 }
4388 if (self.statusbar) {
4389 footerHtml = self.statusbar.renderHtml();
4390 }
4391 return '<div id="' + id + '" class="' + self.classes + '" hidefocus="1">' + '<div class="' + self.classPrefix + 'reset" role="application">' + headerHtml + '<div id="' + id + '-body" class="' + self.bodyClasses + '">' + html + '</div>' + footerHtml + '</div>' + '</div>';
4392 },
4393 fullscreen: function (state) {
4394 var self = this;
4395 var documentElement = domGlobals.document.documentElement;
4396 var slowRendering;
4397 var prefix = self.classPrefix;
4398 var layoutRect;
4399 if (state !== self._fullscreen) {
4400 global$9(domGlobals.window).on('resize', function () {
4401 var time;
4402 if (self._fullscreen) {
4403 if (!slowRendering) {
4404 time = new Date().getTime();
4405 var rect = funcs.getWindowSize();
4406 self.moveTo(0, 0).resizeTo(rect.w, rect.h);
4407 if (new Date().getTime() - time > 50) {
4408 slowRendering = true;
4409 }
4410 } else {
4411 if (!self._timer) {
4412 self._timer = global$7.setTimeout(function () {
4413 var rect = funcs.getWindowSize();
4414 self.moveTo(0, 0).resizeTo(rect.w, rect.h);
4415 self._timer = 0;
4416 }, 50);
4417 }
4418 }
4419 }
4420 });
4421 layoutRect = self.layoutRect();
4422 self._fullscreen = state;
4423 if (!state) {
4424 self.borderBox = BoxUtils.parseBox(self.settings.border);
4425 self.getEl('head').style.display = '';
4426 layoutRect.deltaH += layoutRect.headerH;
4427 global$9([
4428 documentElement,
4429 domGlobals.document.body
4430 ]).removeClass(prefix + 'fullscreen');
4431 self.classes.remove('fullscreen');
4432 self.moveTo(self._initial.x, self._initial.y).resizeTo(self._initial.w, self._initial.h);
4433 } else {
4434 self._initial = {
4435 x: layoutRect.x,
4436 y: layoutRect.y,
4437 w: layoutRect.w,
4438 h: layoutRect.h
4439 };
4440 self.borderBox = BoxUtils.parseBox('0');
4441 self.getEl('head').style.display = 'none';
4442 layoutRect.deltaH -= layoutRect.headerH + 2;
4443 global$9([
4444 documentElement,
4445 domGlobals.document.body
4446 ]).addClass(prefix + 'fullscreen');
4447 self.classes.add('fullscreen');
4448 var rect = funcs.getWindowSize();
4449 self.moveTo(0, 0).resizeTo(rect.w, rect.h);
4450 }
4451 }
4452 return self.reflow();
4453 },
4454 postRender: function () {
4455 var self = this;
4456 var startPos;
4457 setTimeout(function () {
4458 self.classes.add('in');
4459 self.fire('open');
4460 }, 0);
4461 self._super();
4462 if (self.statusbar) {
4463 self.statusbar.postRender();
4464 }
4465 self.focus();
4466 this.dragHelper = new DragHelper(self._id + '-dragh', {
4467 start: function () {
4468 startPos = {
4469 x: self.layoutRect().x,
4470 y: self.layoutRect().y
4471 };
4472 },
4473 drag: function (e) {
4474 self.moveTo(startPos.x + e.deltaX, startPos.y + e.deltaY);
4475 }
4476 });
4477 self.on('submit', function (e) {
4478 if (!e.isDefaultPrevented()) {
4479 self.close();
4480 }
4481 });
4482 windows.push(self);
4483 toggleFullScreenState(true);
4484 },
4485 submit: function () {
4486 return this.fire('submit', { data: this.toJSON() });
4487 },
4488 remove: function () {
4489 var self = this;
4490 var i;
4491 self.dragHelper.destroy();
4492 self._super();
4493 if (self.statusbar) {
4494 this.statusbar.remove();
4495 }
4496 toggleBodyFullScreenClasses(self.classPrefix, false);
4497 i = windows.length;
4498 while (i--) {
4499 if (windows[i] === self) {
4500 windows.splice(i, 1);
4501 }
4502 }
4503 toggleFullScreenState(windows.length > 0);
4504 },
4505 getContentWindow: function () {
4506 var ifr = this.getEl().getElementsByTagName('iframe')[0];
4507 return ifr ? ifr.contentWindow : null;
4508 }
4509 });
4510 handleWindowResize();
4511
4512 var MessageBox = Window.extend({
4513 init: function (settings) {
4514 settings = {
4515 border: 1,
4516 padding: 20,
4517 layout: 'flex',
4518 pack: 'center',
4519 align: 'center',
4520 containerCls: 'panel',
4521 autoScroll: true,
4522 buttons: {
4523 type: 'button',
4524 text: 'Ok',
4525 action: 'ok'
4526 },
4527 items: {
4528 type: 'label',
4529 multiline: true,
4530 maxWidth: 500,
4531 maxHeight: 200
4532 }
4533 };
4534 this._super(settings);
4535 },
4536 Statics: {
4537 OK: 1,
4538 OK_CANCEL: 2,
4539 YES_NO: 3,
4540 YES_NO_CANCEL: 4,
4541 msgBox: function (settings) {
4542 var buttons;
4543 var callback = settings.callback || function () {
4544 };
4545 function createButton(text, status, primary) {
4546 return {
4547 type: 'button',
4548 text: text,
4549 subtype: primary ? 'primary' : '',
4550 onClick: function (e) {
4551 e.control.parents()[1].close();
4552 callback(status);
4553 }
4554 };
4555 }
4556 switch (settings.buttons) {
4557 case MessageBox.OK_CANCEL:
4558 buttons = [
4559 createButton('Ok', true, true),
4560 createButton('Cancel', false)
4561 ];
4562 break;
4563 case MessageBox.YES_NO:
4564 case MessageBox.YES_NO_CANCEL:
4565 buttons = [
4566 createButton('Yes', 1, true),
4567 createButton('No', 0)
4568 ];
4569 if (settings.buttons === MessageBox.YES_NO_CANCEL) {
4570 buttons.push(createButton('Cancel', -1));
4571 }
4572 break;
4573 default:
4574 buttons = [createButton('Ok', true, true)];
4575 break;
4576 }
4577 return new Window({
4578 padding: 20,
4579 x: settings.x,
4580 y: settings.y,
4581 minWidth: 300,
4582 minHeight: 100,
4583 layout: 'flex',
4584 pack: 'center',
4585 align: 'center',
4586 buttons: buttons,
4587 title: settings.title,
4588 role: 'alertdialog',
4589 items: {
4590 type: 'label',
4591 multiline: true,
4592 maxWidth: 500,
4593 maxHeight: 200,
4594 text: settings.text
4595 },
4596 onPostRender: function () {
4597 this.aria('describedby', this.items()[0]._id);
4598 },
4599 onClose: settings.onClose,
4600 onCancel: function () {
4601 callback(false);
4602 }
4603 }).renderTo(domGlobals.document.body).reflow();
4604 },
4605 alert: function (settings, callback) {
4606 if (typeof settings === 'string') {
4607 settings = { text: settings };
4608 }
4609 settings.callback = callback;
4610 return MessageBox.msgBox(settings);
4611 },
4612 confirm: function (settings, callback) {
4613 if (typeof settings === 'string') {
4614 settings = { text: settings };
4615 }
4616 settings.callback = callback;
4617 settings.buttons = MessageBox.OK_CANCEL;
4618 return MessageBox.msgBox(settings);
4619 }
4620 }
4621 });
4622
4623 function WindowManagerImpl (editor) {
4624 var open = function (args, params, closeCallback) {
4625 var win;
4626 args.title = args.title || ' ';
4627 args.url = args.url || args.file;
4628 if (args.url) {
4629 args.width = parseInt(args.width || 320, 10);
4630 args.height = parseInt(args.height || 240, 10);
4631 }
4632 if (args.body) {
4633 args.items = {
4634 defaults: args.defaults,
4635 type: args.bodyType || 'form',
4636 items: args.body,
4637 data: args.data,
4638 callbacks: args.commands
4639 };
4640 }
4641 if (!args.url && !args.buttons) {
4642 args.buttons = [
4643 {
4644 text: 'Ok',
4645 subtype: 'primary',
4646 onclick: function () {
4647 win.find('form')[0].submit();
4648 }
4649 },
4650 {
4651 text: 'Cancel',
4652 onclick: function () {
4653 win.close();
4654 }
4655 }
4656 ];
4657 }
4658 win = new Window(args);
4659 win.on('close', function () {
4660 closeCallback(win);
4661 });
4662 if (args.data) {
4663 win.on('postRender', function () {
4664 this.find('*').each(function (ctrl) {
4665 var name = ctrl.name();
4666 if (name in args.data) {
4667 ctrl.value(args.data[name]);
4668 }
4669 });
4670 });
4671 }
4672 win.features = args || {};
4673 win.params = params || {};
4674 win = win.renderTo(domGlobals.document.body).reflow();
4675 return win;
4676 };
4677 var alert = function (message, choiceCallback, closeCallback) {
4678 var win;
4679 win = MessageBox.alert(message, function () {
4680 choiceCallback();
4681 });
4682 win.on('close', function () {
4683 closeCallback(win);
4684 });
4685 return win;
4686 };
4687 var confirm = function (message, choiceCallback, closeCallback) {
4688 var win;
4689 win = MessageBox.confirm(message, function (state) {
4690 choiceCallback(state);
4691 });
4692 win.on('close', function () {
4693 closeCallback(win);
4694 });
4695 return win;
4696 };
4697 var close = function (window) {
4698 window.close();
4699 };
4700 var getParams = function (window) {
4701 return window.params;
4702 };
4703 var setParams = function (window, params) {
4704 window.params = params;
4705 };
4706 return {
4707 open: open,
4708 alert: alert,
4709 confirm: confirm,
4710 close: close,
4711 getParams: getParams,
4712 setParams: setParams
4713 };
4714 }
4715
4716 var get = function (editor) {
4717 var renderUI = function (args) {
4718 return Render.renderUI(editor, this, args);
4719 };
4720 var resizeTo = function (w, h) {
4721 return Resize.resizeTo(editor, w, h);
4722 };
4723 var resizeBy = function (dw, dh) {
4724 return Resize.resizeBy(editor, dw, dh);
4725 };
4726 var getNotificationManagerImpl = function () {
4727 return NotificationManagerImpl(editor);
4728 };
4729 var getWindowManagerImpl = function () {
4730 return WindowManagerImpl();
4731 };
4732 return {
4733 renderUI: renderUI,
4734 resizeTo: resizeTo,
4735 resizeBy: resizeBy,
4736 getNotificationManagerImpl: getNotificationManagerImpl,
4737 getWindowManagerImpl: getWindowManagerImpl
4738 };
4739 };
4740 var ThemeApi = { get: get };
4741
4742 var Layout = global$a.extend({
4743 Defaults: {
4744 firstControlClass: 'first',
4745 lastControlClass: 'last'
4746 },
4747 init: function (settings) {
4748 this.settings = global$2.extend({}, this.Defaults, settings);
4749 },
4750 preRender: function (container) {
4751 container.bodyClasses.add(this.settings.containerClass);
4752 },
4753 applyClasses: function (items) {
4754 var self = this;
4755 var settings = self.settings;
4756 var firstClass, lastClass, firstItem, lastItem;
4757 firstClass = settings.firstControlClass;
4758 lastClass = settings.lastControlClass;
4759 items.each(function (item) {
4760 item.classes.remove(firstClass).remove(lastClass).add(settings.controlClass);
4761 if (item.visible()) {
4762 if (!firstItem) {
4763 firstItem = item;
4764 }
4765 lastItem = item;
4766 }
4767 });
4768 if (firstItem) {
4769 firstItem.classes.add(firstClass);
4770 }
4771 if (lastItem) {
4772 lastItem.classes.add(lastClass);
4773 }
4774 },
4775 renderHtml: function (container) {
4776 var self = this;
4777 var html = '';
4778 self.applyClasses(container.items());
4779 container.items().each(function (item) {
4780 html += item.renderHtml();
4781 });
4782 return html;
4783 },
4784 recalc: function () {
4785 },
4786 postRender: function () {
4787 },
4788 isNative: function () {
4789 return false;
4790 }
4791 });
4792
4793 var AbsoluteLayout = Layout.extend({
4794 Defaults: {
4795 containerClass: 'abs-layout',
4796 controlClass: 'abs-layout-item'
4797 },
4798 recalc: function (container) {
4799 container.items().filter(':visible').each(function (ctrl) {
4800 var settings = ctrl.settings;
4801 ctrl.layoutRect({
4802 x: settings.x,
4803 y: settings.y,
4804 w: settings.w,
4805 h: settings.h
4806 });
4807 if (ctrl.recalc) {
4808 ctrl.recalc();
4809 }
4810 });
4811 },
4812 renderHtml: function (container) {
4813 return '<div id="' + container._id + '-absend" class="' + container.classPrefix + 'abs-end"></div>' + this._super(container);
4814 }
4815 });
4816
4817 var Button = Widget.extend({
4818 Defaults: {
4819 classes: 'widget btn',
4820 role: 'button'
4821 },
4822 init: function (settings) {
4823 var self = this;
4824 var size;
4825 self._super(settings);
4826 settings = self.settings;
4827 size = self.settings.size;
4828 self.on('click mousedown', function (e) {
4829 e.preventDefault();
4830 });
4831 self.on('touchstart', function (e) {
4832 self.fire('click', e);
4833 e.preventDefault();
4834 });
4835 if (settings.subtype) {
4836 self.classes.add(settings.subtype);
4837 }
4838 if (size) {
4839 self.classes.add('btn-' + size);
4840 }
4841 if (settings.icon) {
4842 self.icon(settings.icon);
4843 }
4844 },
4845 icon: function (icon) {
4846 if (!arguments.length) {
4847 return this.state.get('icon');
4848 }
4849 this.state.set('icon', icon);
4850 return this;
4851 },
4852 repaint: function () {
4853 var btnElm = this.getEl().firstChild;
4854 var btnStyle;
4855 if (btnElm) {
4856 btnStyle = btnElm.style;
4857 btnStyle.width = btnStyle.height = '100%';
4858 }
4859 this._super();
4860 },
4861 renderHtml: function () {
4862 var self = this, id = self._id, prefix = self.classPrefix;
4863 var icon = self.state.get('icon'), image;
4864 var text = self.state.get('text');
4865 var textHtml = '';
4866 var ariaPressed;
4867 var settings = self.settings;
4868 image = settings.image;
4869 if (image) {
4870 icon = 'none';
4871 if (typeof image !== 'string') {
4872 image = domGlobals.window.getSelection ? image[0] : image[1];
4873 }
4874 image = ' style="background-image: url(\'' + image + '\')"';
4875 } else {
4876 image = '';
4877 }
4878 if (text) {
4879 self.classes.add('btn-has-text');
4880 textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
4881 }
4882 icon = icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
4883 ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
4884 return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1"' + ariaPressed + '>' + '<button id="' + id + '-button" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '</div>';
4885 },
4886 bindStates: function () {
4887 var self = this, $ = self.$, textCls = self.classPrefix + 'txt';
4888 function setButtonText(text) {
4889 var $span = $('span.' + textCls, self.getEl());
4890 if (text) {
4891 if (!$span[0]) {
4892 $('button:first', self.getEl()).append('<span class="' + textCls + '"></span>');
4893 $span = $('span.' + textCls, self.getEl());
4894 }
4895 $span.html(self.encode(text));
4896 } else {
4897 $span.remove();
4898 }
4899 self.classes.toggle('btn-has-text', !!text);
4900 }
4901 self.state.on('change:text', function (e) {
4902 setButtonText(e.value);
4903 });
4904 self.state.on('change:icon', function (e) {
4905 var icon = e.value;
4906 var prefix = self.classPrefix;
4907 self.settings.icon = icon;
4908 icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
4909 var btnElm = self.getEl().firstChild;
4910 var iconElm = btnElm.getElementsByTagName('i')[0];
4911 if (icon) {
4912 if (!iconElm || iconElm !== btnElm.firstChild) {
4913 iconElm = domGlobals.document.createElement('i');
4914 btnElm.insertBefore(iconElm, btnElm.firstChild);
4915 }
4916 iconElm.className = icon;
4917 } else if (iconElm) {
4918 btnElm.removeChild(iconElm);
4919 }
4920 setButtonText(self.state.get('text'));
4921 });
4922 return self._super();
4923 }
4924 });
4925
4926 var BrowseButton = Button.extend({
4927 init: function (settings) {
4928 var self = this;
4929 settings = global$2.extend({
4930 text: 'Browse...',
4931 multiple: false,
4932 accept: null
4933 }, settings);
4934 self._super(settings);
4935 self.classes.add('browsebutton');
4936 if (settings.multiple) {
4937 self.classes.add('multiple');
4938 }
4939 },
4940 postRender: function () {
4941 var self = this;
4942 var input = funcs.create('input', {
4943 type: 'file',
4944 id: self._id + '-browse',
4945 accept: self.settings.accept
4946 });
4947 self._super();
4948 global$9(input).on('change', function (e) {
4949 var files = e.target.files;
4950 self.value = function () {
4951 if (!files.length) {
4952 return null;
4953 } else if (self.settings.multiple) {
4954 return files;
4955 } else {
4956 return files[0];
4957 }
4958 };
4959 e.preventDefault();
4960 if (files.length) {
4961 self.fire('change', e);
4962 }
4963 });
4964 global$9(input).on('click', function (e) {
4965 e.stopPropagation();
4966 });
4967 global$9(self.getEl('button')).on('click touchstart', function (e) {
4968 e.stopPropagation();
4969 input.click();
4970 e.preventDefault();
4971 });
4972 self.getEl().appendChild(input);
4973 },
4974 remove: function () {
4975 global$9(this.getEl('button')).off();
4976 global$9(this.getEl('input')).off();
4977 this._super();
4978 }
4979 });
4980
4981 var ButtonGroup = Container.extend({
4982 Defaults: {
4983 defaultType: 'button',
4984 role: 'group'
4985 },
4986 renderHtml: function () {
4987 var self = this, layout = self._layout;
4988 self.classes.add('btn-group');
4989 self.preRender();
4990 layout.preRender(self);
4991 return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
4992 }
4993 });
4994
4995 var Checkbox = Widget.extend({
4996 Defaults: {
4997 classes: 'checkbox',
4998 role: 'checkbox',
4999 checked: false
5000 },
5001 init: function (settings) {
5002 var self = this;
5003 self._super(settings);
5004 self.on('click mousedown', function (e) {
5005 e.preventDefault();
5006 });
5007 self.on('click', function (e) {
5008 e.preventDefault();
5009 if (!self.disabled()) {
5010 self.checked(!self.checked());
5011 }
5012 });
5013 self.checked(self.settings.checked);
5014 },
5015 checked: function (state) {
5016 if (!arguments.length) {
5017 return this.state.get('checked');
5018 }
5019 this.state.set('checked', state);
5020 return this;
5021 },
5022 value: function (state) {
5023 if (!arguments.length) {
5024 return this.checked();
5025 }
5026 return this.checked(state);
5027 },
5028 renderHtml: function () {
5029 var self = this, id = self._id, prefix = self.classPrefix;
5030 return '<div id="' + id + '" class="' + self.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.encode(self.state.get('text')) + '</span>' + '</div>';
5031 },
5032 bindStates: function () {
5033 var self = this;
5034 function checked(state) {
5035 self.classes.toggle('checked', state);
5036 self.aria('checked', state);
5037 }
5038 self.state.on('change:text', function (e) {
5039 self.getEl('al').firstChild.data = self.translate(e.value);
5040 });
5041 self.state.on('change:checked change:value', function (e) {
5042 self.fire('change');
5043 checked(e.value);
5044 });
5045 self.state.on('change:icon', function (e) {
5046 var icon = e.value;
5047 var prefix = self.classPrefix;
5048 if (typeof icon === 'undefined') {
5049 return self.settings.icon;
5050 }
5051 self.settings.icon = icon;
5052 icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
5053 var btnElm = self.getEl().firstChild;
5054 var iconElm = btnElm.getElementsByTagName('i')[0];
5055 if (icon) {
5056 if (!iconElm || iconElm !== btnElm.firstChild) {
5057 iconElm = domGlobals.document.createElement('i');
5058 btnElm.insertBefore(iconElm, btnElm.firstChild);
5059 }
5060 iconElm.className = icon;
5061 } else if (iconElm) {
5062 btnElm.removeChild(iconElm);
5063 }
5064 });
5065 if (self.state.get('checked')) {
5066 checked(true);
5067 }
5068 return self._super();
5069 }
5070 });
5071
5072 var global$d = tinymce.util.Tools.resolve('tinymce.util.VK');
5073
5074 var ComboBox = Widget.extend({
5075 init: function (settings) {
5076 var self = this;
5077 self._super(settings);
5078 settings = self.settings;
5079 self.classes.add('combobox');
5080 self.subinput = true;
5081 self.ariaTarget = 'inp';
5082 settings.menu = settings.menu || settings.values;
5083 if (settings.menu) {
5084 settings.icon = 'caret';
5085 }
5086 self.on('click', function (e) {
5087 var elm = e.target;
5088 var root = self.getEl();
5089 if (!global$9.contains(root, elm) && elm !== root) {
5090 return;
5091 }
5092 while (elm && elm !== root) {
5093 if (elm.id && elm.id.indexOf('-open') !== -1) {
5094 self.fire('action');
5095 if (settings.menu) {
5096 self.showMenu();
5097 if (e.aria) {
5098 self.menu.items()[0].focus();
5099 }
5100 }
5101 }
5102 elm = elm.parentNode;
5103 }
5104 });
5105 self.on('keydown', function (e) {
5106 var rootControl;
5107 if (e.keyCode === 13 && e.target.nodeName === 'INPUT') {
5108 e.preventDefault();
5109 self.parents().reverse().each(function (ctrl) {
5110 if (ctrl.toJSON) {
5111 rootControl = ctrl;
5112 return false;
5113 }
5114 });
5115 self.fire('submit', { data: rootControl.toJSON() });
5116 }
5117 });
5118 self.on('keyup', function (e) {
5119 if (e.target.nodeName === 'INPUT') {
5120 var oldValue = self.state.get('value');
5121 var newValue = e.target.value;
5122 if (newValue !== oldValue) {
5123 self.state.set('value', newValue);
5124 self.fire('autocomplete', e);
5125 }
5126 }
5127 });
5128 self.on('mouseover', function (e) {
5129 var tooltip = self.tooltip().moveTo(-65535);
5130 if (self.statusLevel() && e.target.className.indexOf(self.classPrefix + 'status') !== -1) {
5131 var statusMessage = self.statusMessage() || 'Ok';
5132 var rel = tooltip.text(statusMessage).show().testMoveRel(e.target, [
5133 'bc-tc',
5134 'bc-tl',
5135 'bc-tr'
5136 ]);
5137 tooltip.classes.toggle('tooltip-n', rel === 'bc-tc');
5138 tooltip.classes.toggle('tooltip-nw', rel === 'bc-tl');
5139 tooltip.classes.toggle('tooltip-ne', rel === 'bc-tr');
5140 tooltip.moveRel(e.target, rel);
5141 }
5142 });
5143 },
5144 statusLevel: function (value) {
5145 if (arguments.length > 0) {
5146 this.state.set('statusLevel', value);
5147 }
5148 return this.state.get('statusLevel');
5149 },
5150 statusMessage: function (value) {
5151 if (arguments.length > 0) {
5152 this.state.set('statusMessage', value);
5153 }
5154 return this.state.get('statusMessage');
5155 },
5156 showMenu: function () {
5157 var self = this;
5158 var settings = self.settings;
5159 var menu;
5160 if (!self.menu) {
5161 menu = settings.menu || [];
5162 if (menu.length) {
5163 menu = {
5164 type: 'menu',
5165 items: menu
5166 };
5167 } else {
5168 menu.type = menu.type || 'menu';
5169 }
5170 self.menu = global$4.create(menu).parent(self).renderTo(self.getContainerElm());
5171 self.fire('createmenu');
5172 self.menu.reflow();
5173 self.menu.on('cancel', function (e) {
5174 if (e.control === self.menu) {
5175 self.focus();
5176 }
5177 });
5178 self.menu.on('show hide', function (e) {
5179 e.control.items().each(function (ctrl) {
5180 ctrl.active(ctrl.value() === self.value());
5181 });
5182 }).fire('show');
5183 self.menu.on('select', function (e) {
5184 self.value(e.control.value());
5185 });
5186 self.on('focusin', function (e) {
5187 if (e.target.tagName.toUpperCase() === 'INPUT') {
5188 self.menu.hide();
5189 }
5190 });
5191 self.aria('expanded', true);
5192 }
5193 self.menu.show();
5194 self.menu.layoutRect({ w: self.layoutRect().w });
5195 self.menu.moveRel(self.getEl(), self.isRtl() ? [
5196 'br-tr',
5197 'tr-br'
5198 ] : [
5199 'bl-tl',
5200 'tl-bl'
5201 ]);
5202 },
5203 focus: function () {
5204 this.getEl('inp').focus();
5205 },
5206 repaint: function () {
5207 var self = this, elm = self.getEl(), openElm = self.getEl('open'), rect = self.layoutRect();
5208 var width, lineHeight, innerPadding = 0;
5209 var inputElm = elm.firstChild;
5210 if (self.statusLevel() && self.statusLevel() !== 'none') {
5211 innerPadding = parseInt(funcs.getRuntimeStyle(inputElm, 'padding-right'), 10) - parseInt(funcs.getRuntimeStyle(inputElm, 'padding-left'), 10);
5212 }
5213 if (openElm) {
5214 width = rect.w - funcs.getSize(openElm).width - 10;
5215 } else {
5216 width = rect.w - 10;
5217 }
5218 var doc = domGlobals.document;
5219 if (doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
5220 lineHeight = self.layoutRect().h - 2 + 'px';
5221 }
5222 global$9(inputElm).css({
5223 width: width - innerPadding,
5224 lineHeight: lineHeight
5225 });
5226 self._super();
5227 return self;
5228 },
5229 postRender: function () {
5230 var self = this;
5231 global$9(this.getEl('inp')).on('change', function (e) {
5232 self.state.set('value', e.target.value);
5233 self.fire('change', e);
5234 });
5235 return self._super();
5236 },
5237 renderHtml: function () {
5238 var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix;
5239 var value = self.state.get('value') || '';
5240 var icon, text, openBtnHtml = '', extraAttrs = '', statusHtml = '';
5241 if ('spellcheck' in settings) {
5242 extraAttrs += ' spellcheck="' + settings.spellcheck + '"';
5243 }
5244 if (settings.maxLength) {
5245 extraAttrs += ' maxlength="' + settings.maxLength + '"';
5246 }
5247 if (settings.size) {
5248 extraAttrs += ' size="' + settings.size + '"';
5249 }
5250 if (settings.subtype) {
5251 extraAttrs += ' type="' + settings.subtype + '"';
5252 }
5253 statusHtml = '<i id="' + id + '-status" class="mce-status mce-ico" style="display: none"></i>';
5254 if (self.disabled()) {
5255 extraAttrs += ' disabled="disabled"';
5256 }
5257 icon = settings.icon;
5258 if (icon && icon !== 'caret') {
5259 icon = prefix + 'ico ' + prefix + 'i-' + settings.icon;
5260 }
5261 text = self.state.get('text');
5262 if (icon || text) {
5263 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>';
5264 self.classes.add('has-open');
5265 }
5266 return '<div id="' + id + '" class="' + self.classes + '">' + '<input id="' + id + '-inp" class="' + prefix + 'textbox" value="' + self.encode(value, false) + '" hidefocus="1"' + extraAttrs + ' placeholder="' + self.encode(settings.placeholder) + '" />' + statusHtml + openBtnHtml + '</div>';
5267 },
5268 value: function (value) {
5269 if (arguments.length) {
5270 this.state.set('value', value);
5271 return this;
5272 }
5273 if (this.state.get('rendered')) {
5274 this.state.set('value', this.getEl('inp').value);
5275 }
5276 return this.state.get('value');
5277 },
5278 showAutoComplete: function (items, term) {
5279 var self = this;
5280 if (items.length === 0) {
5281 self.hideMenu();
5282 return;
5283 }
5284 var insert = function (value, title) {
5285 return function () {
5286 self.fire('selectitem', {
5287 title: title,
5288 value: value
5289 });
5290 };
5291 };
5292 if (self.menu) {
5293 self.menu.items().remove();
5294 } else {
5295 self.menu = global$4.create({
5296 type: 'menu',
5297 classes: 'combobox-menu',
5298 layout: 'flow'
5299 }).parent(self).renderTo();
5300 }
5301 global$2.each(items, function (item) {
5302 self.menu.add({
5303 text: item.title,
5304 url: item.previewUrl,
5305 match: term,
5306 classes: 'menu-item-ellipsis',
5307 onclick: insert(item.value, item.title)
5308 });
5309 });
5310 self.menu.renderNew();
5311 self.hideMenu();
5312 self.menu.on('cancel', function (e) {
5313 if (e.control.parent() === self.menu) {
5314 e.stopPropagation();
5315 self.focus();
5316 self.hideMenu();
5317 }
5318 });
5319 self.menu.on('select', function () {
5320 self.focus();
5321 });
5322 var maxW = self.layoutRect().w;
5323 self.menu.layoutRect({
5324 w: maxW,
5325 minW: 0,
5326 maxW: maxW
5327 });
5328 self.menu.repaint();
5329 self.menu.reflow();
5330 self.menu.show();
5331 self.menu.moveRel(self.getEl(), self.isRtl() ? [
5332 'br-tr',
5333 'tr-br'
5334 ] : [
5335 'bl-tl',
5336 'tl-bl'
5337 ]);
5338 },
5339 hideMenu: function () {
5340 if (this.menu) {
5341 this.menu.hide();
5342 }
5343 },
5344 bindStates: function () {
5345 var self = this;
5346 self.state.on('change:value', function (e) {
5347 if (self.getEl('inp').value !== e.value) {
5348 self.getEl('inp').value = e.value;
5349 }
5350 });
5351 self.state.on('change:disabled', function (e) {
5352 self.getEl('inp').disabled = e.value;
5353 });
5354 self.state.on('change:statusLevel', function (e) {
5355 var statusIconElm = self.getEl('status');
5356 var prefix = self.classPrefix, value = e.value;
5357 funcs.css(statusIconElm, 'display', value === 'none' ? 'none' : '');
5358 funcs.toggleClass(statusIconElm, prefix + 'i-checkmark', value === 'ok');
5359 funcs.toggleClass(statusIconElm, prefix + 'i-warning', value === 'warn');
5360 funcs.toggleClass(statusIconElm, prefix + 'i-error', value === 'error');
5361 self.classes.toggle('has-status', value !== 'none');
5362 self.repaint();
5363 });
5364 funcs.on(self.getEl('status'), 'mouseleave', function () {
5365 self.tooltip().hide();
5366 });
5367 self.on('cancel', function (e) {
5368 if (self.menu && self.menu.visible()) {
5369 e.stopPropagation();
5370 self.hideMenu();
5371 }
5372 });
5373 var focusIdx = function (idx, menu) {
5374 if (menu && menu.items().length > 0) {
5375 menu.items().eq(idx)[0].focus();
5376 }
5377 };
5378 self.on('keydown', function (e) {
5379 var keyCode = e.keyCode;
5380 if (e.target.nodeName === 'INPUT') {
5381 if (keyCode === global$d.DOWN) {
5382 e.preventDefault();
5383 self.fire('autocomplete');
5384 focusIdx(0, self.menu);
5385 } else if (keyCode === global$d.UP) {
5386 e.preventDefault();
5387 focusIdx(-1, self.menu);
5388 }
5389 }
5390 });
5391 return self._super();
5392 },
5393 remove: function () {
5394 global$9(this.getEl('inp')).off();
5395 if (this.menu) {
5396 this.menu.remove();
5397 }
5398 this._super();
5399 }
5400 });
5401
5402 var ColorBox = ComboBox.extend({
5403 init: function (settings) {
5404 var self = this;
5405 settings.spellcheck = false;
5406 if (settings.onaction) {
5407 settings.icon = 'none';
5408 }
5409 self._super(settings);
5410 self.classes.add('colorbox');
5411 self.on('change keyup postrender', function () {
5412 self.repaintColor(self.value());
5413 });
5414 },
5415 repaintColor: function (value) {
5416 var openElm = this.getEl('open');
5417 var elm = openElm ? openElm.getElementsByTagName('i')[0] : null;
5418 if (elm) {
5419 try {
5420 elm.style.background = value;
5421 } catch (ex) {
5422 }
5423 }
5424 },
5425 bindStates: function () {
5426 var self = this;
5427 self.state.on('change:value', function (e) {
5428 if (self.state.get('rendered')) {
5429 self.repaintColor(e.value);
5430 }
5431 });
5432 return self._super();
5433 }
5434 });
5435
5436 var PanelButton = Button.extend({
5437 showPanel: function () {
5438 var self = this, settings = self.settings;
5439 self.classes.add('opened');
5440 if (!self.panel) {
5441 var panelSettings = settings.panel;
5442 if (panelSettings.type) {
5443 panelSettings = {
5444 layout: 'grid',
5445 items: panelSettings
5446 };
5447 }
5448 panelSettings.role = panelSettings.role || 'dialog';
5449 panelSettings.popover = true;
5450 panelSettings.autohide = true;
5451 panelSettings.ariaRoot = true;
5452 self.panel = new FloatPanel(panelSettings).on('hide', function () {
5453 self.classes.remove('opened');
5454 }).on('cancel', function (e) {
5455 e.stopPropagation();
5456 self.focus();
5457 self.hidePanel();
5458 }).parent(self).renderTo(self.getContainerElm());
5459 self.panel.fire('show');
5460 self.panel.reflow();
5461 } else {
5462 self.panel.show();
5463 }
5464 var rtlRels = [
5465 'bc-tc',
5466 'bc-tl',
5467 'bc-tr'
5468 ];
5469 var ltrRels = [
5470 'bc-tc',
5471 'bc-tr',
5472 'bc-tl',
5473 'tc-bc',
5474 'tc-br',
5475 'tc-bl'
5476 ];
5477 var rel = self.panel.testMoveRel(self.getEl(), settings.popoverAlign || (self.isRtl() ? rtlRels : ltrRels));
5478 self.panel.classes.toggle('start', rel.substr(-1) === 'l');
5479 self.panel.classes.toggle('end', rel.substr(-1) === 'r');
5480 var isTop = rel.substr(0, 1) === 't';
5481 self.panel.classes.toggle('bottom', !isTop);
5482 self.panel.classes.toggle('top', isTop);
5483 self.panel.moveRel(self.getEl(), rel);
5484 },
5485 hidePanel: function () {
5486 var self = this;
5487 if (self.panel) {
5488 self.panel.hide();
5489 }
5490 },
5491 postRender: function () {
5492 var self = this;
5493 self.aria('haspopup', true);
5494 self.on('click', function (e) {
5495 if (e.control === self) {
5496 if (self.panel && self.panel.visible()) {
5497 self.hidePanel();
5498 } else {
5499 self.showPanel();
5500 self.panel.focus(!!e.aria);
5501 }
5502 }
5503 });
5504 return self._super();
5505 },
5506 remove: function () {
5507 if (this.panel) {
5508 this.panel.remove();
5509 this.panel = null;
5510 }
5511 return this._super();
5512 }
5513 });
5514
5515 var DOM$3 = global$3.DOM;
5516 var ColorButton = PanelButton.extend({
5517 init: function (settings) {
5518 this._super(settings);
5519 this.classes.add('splitbtn');
5520 this.classes.add('colorbutton');
5521 },
5522 color: function (color) {
5523 if (color) {
5524 this._color = color;
5525 this.getEl('preview').style.backgroundColor = color;
5526 return this;
5527 }
5528 return this._color;
5529 },
5530 resetColor: function () {
5531 this._color = null;
5532 this.getEl('preview').style.backgroundColor = null;
5533 return this;
5534 },
5535 renderHtml: function () {
5536 var self = this, id = self._id, prefix = self.classPrefix, text = self.state.get('text');
5537 var icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
5538 var image = self.settings.image ? ' style="background-image: url(\'' + self.settings.image + '\')"' : '';
5539 var textHtml = '';
5540 if (text) {
5541 self.classes.add('btn-has-text');
5542 textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
5543 }
5544 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>';
5545 },
5546 postRender: function () {
5547 var self = this, onClickHandler = self.settings.onclick;
5548 self.on('click', function (e) {
5549 if (e.aria && e.aria.key === 'down') {
5550 return;
5551 }
5552 if (e.control === self && !DOM$3.getParent(e.target, '.' + self.classPrefix + 'open')) {
5553 e.stopImmediatePropagation();
5554 onClickHandler.call(self, e);
5555 }
5556 });
5557 delete self.settings.onclick;
5558 return self._super();
5559 }
5560 });
5561
5562 var global$e = tinymce.util.Tools.resolve('tinymce.util.Color');
5563
5564 var ColorPicker = Widget.extend({
5565 Defaults: { classes: 'widget colorpicker' },
5566 init: function (settings) {
5567 this._super(settings);
5568 },
5569 postRender: function () {
5570 var self = this;
5571 var color = self.color();
5572 var hsv, hueRootElm, huePointElm, svRootElm, svPointElm;
5573 hueRootElm = self.getEl('h');
5574 huePointElm = self.getEl('hp');
5575 svRootElm = self.getEl('sv');
5576 svPointElm = self.getEl('svp');
5577 function getPos(elm, event) {
5578 var pos = funcs.getPos(elm);
5579 var x, y;
5580 x = event.pageX - pos.x;
5581 y = event.pageY - pos.y;
5582 x = Math.max(0, Math.min(x / elm.clientWidth, 1));
5583 y = Math.max(0, Math.min(y / elm.clientHeight, 1));
5584 return {
5585 x: x,
5586 y: y
5587 };
5588 }
5589 function updateColor(hsv, hueUpdate) {
5590 var hue = (360 - hsv.h) / 360;
5591 funcs.css(huePointElm, { top: hue * 100 + '%' });
5592 if (!hueUpdate) {
5593 funcs.css(svPointElm, {
5594 left: hsv.s + '%',
5595 top: 100 - hsv.v + '%'
5596 });
5597 }
5598 svRootElm.style.background = global$e({
5599 s: 100,
5600 v: 100,
5601 h: hsv.h
5602 }).toHex();
5603 self.color().parse({
5604 s: hsv.s,
5605 v: hsv.v,
5606 h: hsv.h
5607 });
5608 }
5609 function updateSaturationAndValue(e) {
5610 var pos;
5611 pos = getPos(svRootElm, e);
5612 hsv.s = pos.x * 100;
5613 hsv.v = (1 - pos.y) * 100;
5614 updateColor(hsv);
5615 self.fire('change');
5616 }
5617 function updateHue(e) {
5618 var pos;
5619 pos = getPos(hueRootElm, e);
5620 hsv = color.toHsv();
5621 hsv.h = (1 - pos.y) * 360;
5622 updateColor(hsv, true);
5623 self.fire('change');
5624 }
5625 self._repaint = function () {
5626 hsv = color.toHsv();
5627 updateColor(hsv);
5628 };
5629 self._super();
5630 self._svdraghelper = new DragHelper(self._id + '-sv', {
5631 start: updateSaturationAndValue,
5632 drag: updateSaturationAndValue
5633 });
5634 self._hdraghelper = new DragHelper(self._id + '-h', {
5635 start: updateHue,
5636 drag: updateHue
5637 });
5638 self._repaint();
5639 },
5640 rgb: function () {
5641 return this.color().toRgb();
5642 },
5643 value: function (value) {
5644 var self = this;
5645 if (arguments.length) {
5646 self.color().parse(value);
5647 if (self._rendered) {
5648 self._repaint();
5649 }
5650 } else {
5651 return self.color().toHex();
5652 }
5653 },
5654 color: function () {
5655 if (!this._color) {
5656 this._color = global$e();
5657 }
5658 return this._color;
5659 },
5660 renderHtml: function () {
5661 var self = this;
5662 var id = self._id;
5663 var prefix = self.classPrefix;
5664 var hueHtml;
5665 var stops = '#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000';
5666 function getOldIeFallbackHtml() {
5667 var i, l, html = '', gradientPrefix, stopsList;
5668 gradientPrefix = 'filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=';
5669 stopsList = stops.split(',');
5670 for (i = 0, l = stopsList.length - 1; i < l; i++) {
5671 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>';
5672 }
5673 return html;
5674 }
5675 var gradientCssText = 'background: -ms-linear-gradient(top,' + stops + ');' + 'background: linear-gradient(to bottom,' + stops + ');';
5676 hueHtml = '<div id="' + id + '-h" class="' + prefix + 'colorpicker-h" style="' + gradientCssText + '">' + getOldIeFallbackHtml() + '<div id="' + id + '-hp" class="' + prefix + 'colorpicker-h-marker"></div>' + '</div>';
5677 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>';
5678 }
5679 });
5680
5681 var DropZone = Widget.extend({
5682 init: function (settings) {
5683 var self = this;
5684 settings = global$2.extend({
5685 height: 100,
5686 text: 'Drop an image here',
5687 multiple: false,
5688 accept: null
5689 }, settings);
5690 self._super(settings);
5691 self.classes.add('dropzone');
5692 if (settings.multiple) {
5693 self.classes.add('multiple');
5694 }
5695 },
5696 renderHtml: function () {
5697 var self = this;
5698 var attrs, elm;
5699 var cfg = self.settings;
5700 attrs = {
5701 id: self._id,
5702 hidefocus: '1'
5703 };
5704 elm = funcs.create('div', attrs, '<span>' + this.translate(cfg.text) + '</span>');
5705 if (cfg.height) {
5706 funcs.css(elm, 'height', cfg.height + 'px');
5707 }
5708 if (cfg.width) {
5709 funcs.css(elm, 'width', cfg.width + 'px');
5710 }
5711 elm.className = self.classes;
5712 return elm.outerHTML;
5713 },
5714 postRender: function () {
5715 var self = this;
5716 var toggleDragClass = function (e) {
5717 e.preventDefault();
5718 self.classes.toggle('dragenter');
5719 self.getEl().className = self.classes;
5720 };
5721 var filter = function (files) {
5722 var accept = self.settings.accept;
5723 if (typeof accept !== 'string') {
5724 return files;
5725 }
5726 var re = new RegExp('(' + accept.split(/\s*,\s*/).join('|') + ')$', 'i');
5727 return global$2.grep(files, function (file) {
5728 return re.test(file.name);
5729 });
5730 };
5731 self._super();
5732 self.$el.on('dragover', function (e) {
5733 e.preventDefault();
5734 });
5735 self.$el.on('dragenter', toggleDragClass);
5736 self.$el.on('dragleave', toggleDragClass);
5737 self.$el.on('drop', function (e) {
5738 e.preventDefault();
5739 if (self.state.get('disabled')) {
5740 return;
5741 }
5742 var files = filter(e.dataTransfer.files);
5743 self.value = function () {
5744 if (!files.length) {
5745 return null;
5746 } else if (self.settings.multiple) {
5747 return files;
5748 } else {
5749 return files[0];
5750 }
5751 };
5752 if (files.length) {
5753 self.fire('change', e);
5754 }
5755 });
5756 },
5757 remove: function () {
5758 this.$el.off();
5759 this._super();
5760 }
5761 });
5762
5763 var Path = Widget.extend({
5764 init: function (settings) {
5765 var self = this;
5766 if (!settings.delimiter) {
5767 settings.delimiter = '\xBB';
5768 }
5769 self._super(settings);
5770 self.classes.add('path');
5771 self.canFocus = true;
5772 self.on('click', function (e) {
5773 var index;
5774 var target = e.target;
5775 if (index = target.getAttribute('data-index')) {
5776 self.fire('select', {
5777 value: self.row()[index],
5778 index: index
5779 });
5780 }
5781 });
5782 self.row(self.settings.row);
5783 },
5784 focus: function () {
5785 var self = this;
5786 self.getEl().firstChild.focus();
5787 return self;
5788 },
5789 row: function (row) {
5790 if (!arguments.length) {
5791 return this.state.get('row');
5792 }
5793 this.state.set('row', row);
5794 return this;
5795 },
5796 renderHtml: function () {
5797 var self = this;
5798 return '<div id="' + self._id + '" class="' + self.classes + '">' + self._getDataPathHtml(self.state.get('row')) + '</div>';
5799 },
5800 bindStates: function () {
5801 var self = this;
5802 self.state.on('change:row', function (e) {
5803 self.innerHtml(self._getDataPathHtml(e.value));
5804 });
5805 return self._super();
5806 },
5807 _getDataPathHtml: function (data) {
5808 var self = this;
5809 var parts = data || [];
5810 var i, l, html = '';
5811 var prefix = self.classPrefix;
5812 for (i = 0, l = parts.length; i < l; i++) {
5813 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>';
5814 }
5815 if (!html) {
5816 html = '<div class="' + prefix + 'path-item">\xA0</div>';
5817 }
5818 return html;
5819 }
5820 });
5821
5822 var ElementPath = Path.extend({
5823 postRender: function () {
5824 var self = this, editor = self.settings.editor;
5825 function isHidden(elm) {
5826 if (elm.nodeType === 1) {
5827 if (elm.nodeName === 'BR' || !!elm.getAttribute('data-mce-bogus')) {
5828 return true;
5829 }
5830 if (elm.getAttribute('data-mce-type') === 'bookmark') {
5831 return true;
5832 }
5833 }
5834 return false;
5835 }
5836 if (editor.settings.elementpath !== false) {
5837 self.on('select', function (e) {
5838 editor.focus();
5839 editor.selection.select(this.row()[e.index].element);
5840 editor.nodeChanged();
5841 });
5842 editor.on('nodeChange', function (e) {
5843 var outParents = [];
5844 var parents = e.parents;
5845 var i = parents.length;
5846 while (i--) {
5847 if (parents[i].nodeType === 1 && !isHidden(parents[i])) {
5848 var args = editor.fire('ResolveName', {
5849 name: parents[i].nodeName.toLowerCase(),
5850 target: parents[i]
5851 });
5852 if (!args.isDefaultPrevented()) {
5853 outParents.push({
5854 name: args.name,
5855 element: parents[i]
5856 });
5857 }
5858 if (args.isPropagationStopped()) {
5859 break;
5860 }
5861 }
5862 }
5863 self.row(outParents);
5864 });
5865 }
5866 return self._super();
5867 }
5868 });
5869
5870 var FormItem = Container.extend({
5871 Defaults: {
5872 layout: 'flex',
5873 align: 'center',
5874 defaults: { flex: 1 }
5875 },
5876 renderHtml: function () {
5877 var self = this, layout = self._layout, prefix = self.classPrefix;
5878 self.classes.add('formitem');
5879 layout.preRender(self);
5880 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>';
5881 }
5882 });
5883
5884 var Form = Container.extend({
5885 Defaults: {
5886 containerCls: 'form',
5887 layout: 'flex',
5888 direction: 'column',
5889 align: 'stretch',
5890 flex: 1,
5891 padding: 15,
5892 labelGap: 30,
5893 spacing: 10,
5894 callbacks: {
5895 submit: function () {
5896 this.submit();
5897 }
5898 }
5899 },
5900 preRender: function () {
5901 var self = this, items = self.items();
5902 if (!self.settings.formItemDefaults) {
5903 self.settings.formItemDefaults = {
5904 layout: 'flex',
5905 autoResize: 'overflow',
5906 defaults: { flex: 1 }
5907 };
5908 }
5909 items.each(function (ctrl) {
5910 var formItem;
5911 var label = ctrl.settings.label;
5912 if (label) {
5913 formItem = new FormItem(global$2.extend({
5914 items: {
5915 type: 'label',
5916 id: ctrl._id + '-l',
5917 text: label,
5918 flex: 0,
5919 forId: ctrl._id,
5920 disabled: ctrl.disabled()
5921 }
5922 }, self.settings.formItemDefaults));
5923 formItem.type = 'formitem';
5924 ctrl.aria('labelledby', ctrl._id + '-l');
5925 if (typeof ctrl.settings.flex === 'undefined') {
5926 ctrl.settings.flex = 1;
5927 }
5928 self.replace(ctrl, formItem);
5929 formItem.add(ctrl);
5930 }
5931 });
5932 },
5933 submit: function () {
5934 return this.fire('submit', { data: this.toJSON() });
5935 },
5936 postRender: function () {
5937 var self = this;
5938 self._super();
5939 self.fromJSON(self.settings.data);
5940 },
5941 bindStates: function () {
5942 var self = this;
5943 self._super();
5944 function recalcLabels() {
5945 var maxLabelWidth = 0;
5946 var labels = [];
5947 var i, labelGap, items;
5948 if (self.settings.labelGapCalc === false) {
5949 return;
5950 }
5951 if (self.settings.labelGapCalc === 'children') {
5952 items = self.find('formitem');
5953 } else {
5954 items = self.items();
5955 }
5956 items.filter('formitem').each(function (item) {
5957 var labelCtrl = item.items()[0], labelWidth = labelCtrl.getEl().clientWidth;
5958 maxLabelWidth = labelWidth > maxLabelWidth ? labelWidth : maxLabelWidth;
5959 labels.push(labelCtrl);
5960 });
5961 labelGap = self.settings.labelGap || 0;
5962 i = labels.length;
5963 while (i--) {
5964 labels[i].settings.minWidth = maxLabelWidth + labelGap;
5965 }
5966 }
5967 self.on('show', recalcLabels);
5968 recalcLabels();
5969 }
5970 });
5971
5972 var FieldSet = Form.extend({
5973 Defaults: {
5974 containerCls: 'fieldset',
5975 layout: 'flex',
5976 direction: 'column',
5977 align: 'stretch',
5978 flex: 1,
5979 padding: '25 15 5 15',
5980 labelGap: 30,
5981 spacing: 10,
5982 border: 1
5983 },
5984 renderHtml: function () {
5985 var self = this, layout = self._layout, prefix = self.classPrefix;
5986 self.preRender();
5987 layout.preRender(self);
5988 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>';
5989 }
5990 });
5991
5992 var unique$1 = 0;
5993 var generate = function (prefix) {
5994 var date = new Date();
5995 var time = date.getTime();
5996 var random = Math.floor(Math.random() * 1000000000);
5997 unique$1++;
5998 return prefix + '_' + random + unique$1 + String(time);
5999 };
6000
6001 var fromHtml = function (html, scope) {
6002 var doc = scope || domGlobals.document;
6003 var div = doc.createElement('div');
6004 div.innerHTML = html;
6005 if (!div.hasChildNodes() || div.childNodes.length > 1) {
6006 domGlobals.console.error('HTML does not have a single root node', html);
6007 throw new Error('HTML must have a single root node');
6008 }
6009 return fromDom(div.childNodes[0]);
6010 };
6011 var fromTag = function (tag, scope) {
6012 var doc = scope || domGlobals.document;
6013 var node = doc.createElement(tag);
6014 return fromDom(node);
6015 };
6016 var fromText = function (text, scope) {
6017 var doc = scope || domGlobals.document;
6018 var node = doc.createTextNode(text);
6019 return fromDom(node);
6020 };
6021 var fromDom = function (node) {
6022 if (node === null || node === undefined) {
6023 throw new Error('Node cannot be null or undefined');
6024 }
6025 return { dom: constant(node) };
6026 };
6027 var fromPoint = function (docElm, x, y) {
6028 var doc = docElm.dom();
6029 return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
6030 };
6031 var Element = {
6032 fromHtml: fromHtml,
6033 fromTag: fromTag,
6034 fromText: fromText,
6035 fromDom: fromDom,
6036 fromPoint: fromPoint
6037 };
6038
6039 var cached = function (f) {
6040 var called = false;
6041 var r;
6042 return function () {
6043 var args = [];
6044 for (var _i = 0; _i < arguments.length; _i++) {
6045 args[_i] = arguments[_i];
6046 }
6047 if (!called) {
6048 called = true;
6049 r = f.apply(null, args);
6050 }
6051 return r;
6052 };
6053 };
6054
6055 var ATTRIBUTE = domGlobals.Node.ATTRIBUTE_NODE;
6056 var CDATA_SECTION = domGlobals.Node.CDATA_SECTION_NODE;
6057 var COMMENT = domGlobals.Node.COMMENT_NODE;
6058 var DOCUMENT = domGlobals.Node.DOCUMENT_NODE;
6059 var DOCUMENT_TYPE = domGlobals.Node.DOCUMENT_TYPE_NODE;
6060 var DOCUMENT_FRAGMENT = domGlobals.Node.DOCUMENT_FRAGMENT_NODE;
6061 var ELEMENT = domGlobals.Node.ELEMENT_NODE;
6062 var TEXT = domGlobals.Node.TEXT_NODE;
6063 var PROCESSING_INSTRUCTION = domGlobals.Node.PROCESSING_INSTRUCTION_NODE;
6064 var ENTITY_REFERENCE = domGlobals.Node.ENTITY_REFERENCE_NODE;
6065 var ENTITY = domGlobals.Node.ENTITY_NODE;
6066 var NOTATION = domGlobals.Node.NOTATION_NODE;
6067
6068 var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
6069
6070 var path = function (parts, scope) {
6071 var o = scope !== undefined && scope !== null ? scope : Global;
6072 for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
6073 o = o[parts[i]];
6074 }
6075 return o;
6076 };
6077 var resolve = function (p, scope) {
6078 var parts = p.split('.');
6079 return path(parts, scope);
6080 };
6081
6082 var unsafe = function (name, scope) {
6083 return resolve(name, scope);
6084 };
6085 var getOrDie = function (name, scope) {
6086 var actual = unsafe(name, scope);
6087 if (actual === undefined || actual === null) {
6088 throw new Error(name + ' not available on this browser');
6089 }
6090 return actual;
6091 };
6092 var Global$1 = { getOrDie: getOrDie };
6093
6094 var Immutable = function () {
6095 var fields = [];
6096 for (var _i = 0; _i < arguments.length; _i++) {
6097 fields[_i] = arguments[_i];
6098 }
6099 return function () {
6100 var values = [];
6101 for (var _i = 0; _i < arguments.length; _i++) {
6102 values[_i] = arguments[_i];
6103 }
6104 if (fields.length !== values.length) {
6105 throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
6106 }
6107 var struct = {};
6108 each(fields, function (name, i) {
6109 struct[name] = constant(values[i]);
6110 });
6111 return struct;
6112 };
6113 };
6114
6115 var node = function () {
6116 var f = Global$1.getOrDie('Node');
6117 return f;
6118 };
6119 var compareDocumentPosition = function (a, b, match) {
6120 return (a.compareDocumentPosition(b) & match) !== 0;
6121 };
6122 var documentPositionPreceding = function (a, b) {
6123 return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
6124 };
6125 var documentPositionContainedBy = function (a, b) {
6126 return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
6127 };
6128 var Node = {
6129 documentPositionPreceding: documentPositionPreceding,
6130 documentPositionContainedBy: documentPositionContainedBy
6131 };
6132
6133 var firstMatch = function (regexes, s) {
6134 for (var i = 0; i < regexes.length; i++) {
6135 var x = regexes[i];
6136 if (x.test(s)) {
6137 return x;
6138 }
6139 }
6140 return undefined;
6141 };
6142 var find$1 = function (regexes, agent) {
6143 var r = firstMatch(regexes, agent);
6144 if (!r) {
6145 return {
6146 major: 0,
6147 minor: 0
6148 };
6149 }
6150 var group = function (i) {
6151 return Number(agent.replace(r, '$' + i));
6152 };
6153 return nu(group(1), group(2));
6154 };
6155 var detect = function (versionRegexes, agent) {
6156 var cleanedAgent = String(agent).toLowerCase();
6157 if (versionRegexes.length === 0) {
6158 return unknown();
6159 }
6160 return find$1(versionRegexes, cleanedAgent);
6161 };
6162 var unknown = function () {
6163 return nu(0, 0);
6164 };
6165 var nu = function (major, minor) {
6166 return {
6167 major: major,
6168 minor: minor
6169 };
6170 };
6171 var Version = {
6172 nu: nu,
6173 detect: detect,
6174 unknown: unknown
6175 };
6176
6177 var edge = 'Edge';
6178 var chrome = 'Chrome';
6179 var ie = 'IE';
6180 var opera = 'Opera';
6181 var firefox = 'Firefox';
6182 var safari = 'Safari';
6183 var isBrowser = function (name, current) {
6184 return function () {
6185 return current === name;
6186 };
6187 };
6188 var unknown$1 = function () {
6189 return nu$1({
6190 current: undefined,
6191 version: Version.unknown()
6192 });
6193 };
6194 var nu$1 = function (info) {
6195 var current = info.current;
6196 var version = info.version;
6197 return {
6198 current: current,
6199 version: version,
6200 isEdge: isBrowser(edge, current),
6201 isChrome: isBrowser(chrome, current),
6202 isIE: isBrowser(ie, current),
6203 isOpera: isBrowser(opera, current),
6204 isFirefox: isBrowser(firefox, current),
6205 isSafari: isBrowser(safari, current)
6206 };
6207 };
6208 var Browser = {
6209 unknown: unknown$1,
6210 nu: nu$1,
6211 edge: constant(edge),
6212 chrome: constant(chrome),
6213 ie: constant(ie),
6214 opera: constant(opera),
6215 firefox: constant(firefox),
6216 safari: constant(safari)
6217 };
6218
6219 var windows$1 = 'Windows';
6220 var ios = 'iOS';
6221 var android = 'Android';
6222 var linux = 'Linux';
6223 var osx = 'OSX';
6224 var solaris = 'Solaris';
6225 var freebsd = 'FreeBSD';
6226 var isOS = function (name, current) {
6227 return function () {
6228 return current === name;
6229 };
6230 };
6231 var unknown$2 = function () {
6232 return nu$2({
6233 current: undefined,
6234 version: Version.unknown()
6235 });
6236 };
6237 var nu$2 = function (info) {
6238 var current = info.current;
6239 var version = info.version;
6240 return {
6241 current: current,
6242 version: version,
6243 isWindows: isOS(windows$1, current),
6244 isiOS: isOS(ios, current),
6245 isAndroid: isOS(android, current),
6246 isOSX: isOS(osx, current),
6247 isLinux: isOS(linux, current),
6248 isSolaris: isOS(solaris, current),
6249 isFreeBSD: isOS(freebsd, current)
6250 };
6251 };
6252 var OperatingSystem = {
6253 unknown: unknown$2,
6254 nu: nu$2,
6255 windows: constant(windows$1),
6256 ios: constant(ios),
6257 android: constant(android),
6258 linux: constant(linux),
6259 osx: constant(osx),
6260 solaris: constant(solaris),
6261 freebsd: constant(freebsd)
6262 };
6263
6264 var DeviceType = function (os, browser, userAgent) {
6265 var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
6266 var isiPhone = os.isiOS() && !isiPad;
6267 var isAndroid3 = os.isAndroid() && os.version.major === 3;
6268 var isAndroid4 = os.isAndroid() && os.version.major === 4;
6269 var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
6270 var isTouch = os.isiOS() || os.isAndroid();
6271 var isPhone = isTouch && !isTablet;
6272 var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
6273 return {
6274 isiPad: constant(isiPad),
6275 isiPhone: constant(isiPhone),
6276 isTablet: constant(isTablet),
6277 isPhone: constant(isPhone),
6278 isTouch: constant(isTouch),
6279 isAndroid: os.isAndroid,
6280 isiOS: os.isiOS,
6281 isWebView: constant(iOSwebview)
6282 };
6283 };
6284
6285 var detect$1 = function (candidates, userAgent) {
6286 var agent = String(userAgent).toLowerCase();
6287 return find(candidates, function (candidate) {
6288 return candidate.search(agent);
6289 });
6290 };
6291 var detectBrowser = function (browsers, userAgent) {
6292 return detect$1(browsers, userAgent).map(function (browser) {
6293 var version = Version.detect(browser.versionRegexes, userAgent);
6294 return {
6295 current: browser.name,
6296 version: version
6297 };
6298 });
6299 };
6300 var detectOs = function (oses, userAgent) {
6301 return detect$1(oses, userAgent).map(function (os) {
6302 var version = Version.detect(os.versionRegexes, userAgent);
6303 return {
6304 current: os.name,
6305 version: version
6306 };
6307 });
6308 };
6309 var UaString = {
6310 detectBrowser: detectBrowser,
6311 detectOs: detectOs
6312 };
6313
6314 var contains = function (str, substr) {
6315 return str.indexOf(substr) !== -1;
6316 };
6317
6318 var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
6319 var checkContains = function (target) {
6320 return function (uastring) {
6321 return contains(uastring, target);
6322 };
6323 };
6324 var browsers = [
6325 {
6326 name: 'Edge',
6327 versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
6328 search: function (uastring) {
6329 return contains(uastring, 'edge/') && contains(uastring, 'chrome') && contains(uastring, 'safari') && contains(uastring, 'applewebkit');
6330 }
6331 },
6332 {
6333 name: 'Chrome',
6334 versionRegexes: [
6335 /.*?chrome\/([0-9]+)\.([0-9]+).*/,
6336 normalVersionRegex
6337 ],
6338 search: function (uastring) {
6339 return contains(uastring, 'chrome') && !contains(uastring, 'chromeframe');
6340 }
6341 },
6342 {
6343 name: 'IE',
6344 versionRegexes: [
6345 /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
6346 /.*?rv:([0-9]+)\.([0-9]+).*/
6347 ],
6348 search: function (uastring) {
6349 return contains(uastring, 'msie') || contains(uastring, 'trident');
6350 }
6351 },
6352 {
6353 name: 'Opera',
6354 versionRegexes: [
6355 normalVersionRegex,
6356 /.*?opera\/([0-9]+)\.([0-9]+).*/
6357 ],
6358 search: checkContains('opera')
6359 },
6360 {
6361 name: 'Firefox',
6362 versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
6363 search: checkContains('firefox')
6364 },
6365 {
6366 name: 'Safari',
6367 versionRegexes: [
6368 normalVersionRegex,
6369 /.*?cpu os ([0-9]+)_([0-9]+).*/
6370 ],
6371 search: function (uastring) {
6372 return (contains(uastring, 'safari') || contains(uastring, 'mobile/')) && contains(uastring, 'applewebkit');
6373 }
6374 }
6375 ];
6376 var oses = [
6377 {
6378 name: 'Windows',
6379 search: checkContains('win'),
6380 versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
6381 },
6382 {
6383 name: 'iOS',
6384 search: function (uastring) {
6385 return contains(uastring, 'iphone') || contains(uastring, 'ipad');
6386 },
6387 versionRegexes: [
6388 /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
6389 /.*cpu os ([0-9]+)_([0-9]+).*/,
6390 /.*cpu iphone os ([0-9]+)_([0-9]+).*/
6391 ]
6392 },
6393 {
6394 name: 'Android',
6395 search: checkContains('android'),
6396 versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
6397 },
6398 {
6399 name: 'OSX',
6400 search: checkContains('os x'),
6401 versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
6402 },
6403 {
6404 name: 'Linux',
6405 search: checkContains('linux'),
6406 versionRegexes: []
6407 },
6408 {
6409 name: 'Solaris',
6410 search: checkContains('sunos'),
6411 versionRegexes: []
6412 },
6413 {
6414 name: 'FreeBSD',
6415 search: checkContains('freebsd'),
6416 versionRegexes: []
6417 }
6418 ];
6419 var PlatformInfo = {
6420 browsers: constant(browsers),
6421 oses: constant(oses)
6422 };
6423
6424 var detect$2 = function (userAgent) {
6425 var browsers = PlatformInfo.browsers();
6426 var oses = PlatformInfo.oses();
6427 var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu);
6428 var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
6429 var deviceType = DeviceType(os, browser, userAgent);
6430 return {
6431 browser: browser,
6432 os: os,
6433 deviceType: deviceType
6434 };
6435 };
6436 var PlatformDetection = { detect: detect$2 };
6437
6438 var detect$3 = cached(function () {
6439 var userAgent = domGlobals.navigator.userAgent;
6440 return PlatformDetection.detect(userAgent);
6441 });
6442 var PlatformDetection$1 = { detect: detect$3 };
6443
6444 var ELEMENT$1 = ELEMENT;
6445 var DOCUMENT$1 = DOCUMENT;
6446 var bypassSelector = function (dom) {
6447 return dom.nodeType !== ELEMENT$1 && dom.nodeType !== DOCUMENT$1 || dom.childElementCount === 0;
6448 };
6449 var all = function (selector, scope) {
6450 var base = scope === undefined ? domGlobals.document : scope.dom();
6451 return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), Element.fromDom);
6452 };
6453 var one = function (selector, scope) {
6454 var base = scope === undefined ? domGlobals.document : scope.dom();
6455 return bypassSelector(base) ? Option.none() : Option.from(base.querySelector(selector)).map(Element.fromDom);
6456 };
6457
6458 var regularContains = function (e1, e2) {
6459 var d1 = e1.dom();
6460 var d2 = e2.dom();
6461 return d1 === d2 ? false : d1.contains(d2);
6462 };
6463 var ieContains = function (e1, e2) {
6464 return Node.documentPositionContainedBy(e1.dom(), e2.dom());
6465 };
6466 var browser = PlatformDetection$1.detect().browser;
6467 var contains$1 = browser.isIE() ? ieContains : regularContains;
6468
6469 var spot = Immutable('element', 'offset');
6470
6471 var descendants = function (scope, selector) {
6472 return all(selector, scope);
6473 };
6474
6475 var trim = global$2.trim;
6476 var hasContentEditableState = function (value) {
6477 return function (node) {
6478 if (node && node.nodeType === 1) {
6479 if (node.contentEditable === value) {
6480 return true;
6481 }
6482 if (node.getAttribute('data-mce-contenteditable') === value) {
6483 return true;
6484 }
6485 }
6486 return false;
6487 };
6488 };
6489 var isContentEditableTrue = hasContentEditableState('true');
6490 var isContentEditableFalse = hasContentEditableState('false');
6491 var create = function (type, title, url, level, attach) {
6492 return {
6493 type: type,
6494 title: title,
6495 url: url,
6496 level: level,
6497 attach: attach
6498 };
6499 };
6500 var isChildOfContentEditableTrue = function (node) {
6501 while (node = node.parentNode) {
6502 var value = node.contentEditable;
6503 if (value && value !== 'inherit') {
6504 return isContentEditableTrue(node);
6505 }
6506 }
6507 return false;
6508 };
6509 var select = function (selector, root) {
6510 return map(descendants(Element.fromDom(root), selector), function (element) {
6511 return element.dom();
6512 });
6513 };
6514 var getElementText = function (elm) {
6515 return elm.innerText || elm.textContent;
6516 };
6517 var getOrGenerateId = function (elm) {
6518 return elm.id ? elm.id : generate('h');
6519 };
6520 var isAnchor = function (elm) {
6521 return elm && elm.nodeName === 'A' && (elm.id || elm.name);
6522 };
6523 var isValidAnchor = function (elm) {
6524 return isAnchor(elm) && isEditable(elm);
6525 };
6526 var isHeader = function (elm) {
6527 return elm && /^(H[1-6])$/.test(elm.nodeName);
6528 };
6529 var isEditable = function (elm) {
6530 return isChildOfContentEditableTrue(elm) && !isContentEditableFalse(elm);
6531 };
6532 var isValidHeader = function (elm) {
6533 return isHeader(elm) && isEditable(elm);
6534 };
6535 var getLevel = function (elm) {
6536 return isHeader(elm) ? parseInt(elm.nodeName.substr(1), 10) : 0;
6537 };
6538 var headerTarget = function (elm) {
6539 var headerId = getOrGenerateId(elm);
6540 var attach = function () {
6541 elm.id = headerId;
6542 };
6543 return create('header', getElementText(elm), '#' + headerId, getLevel(elm), attach);
6544 };
6545 var anchorTarget = function (elm) {
6546 var anchorId = elm.id || elm.name;
6547 var anchorText = getElementText(elm);
6548 return create('anchor', anchorText ? anchorText : '#' + anchorId, '#' + anchorId, 0, noop);
6549 };
6550 var getHeaderTargets = function (elms) {
6551 return map(filter(elms, isValidHeader), headerTarget);
6552 };
6553 var getAnchorTargets = function (elms) {
6554 return map(filter(elms, isValidAnchor), anchorTarget);
6555 };
6556 var getTargetElements = function (elm) {
6557 var elms = select('h1,h2,h3,h4,h5,h6,a:not([href])', elm);
6558 return elms;
6559 };
6560 var hasTitle = function (target) {
6561 return trim(target.title).length > 0;
6562 };
6563 var find$2 = function (elm) {
6564 var elms = getTargetElements(elm);
6565 return filter(getHeaderTargets(elms).concat(getAnchorTargets(elms)), hasTitle);
6566 };
6567 var LinkTargets = { find: find$2 };
6568
6569 var getActiveEditor = function () {
6570 return window.tinymce ? window.tinymce.activeEditor : global$1.activeEditor;
6571 };
6572 var history = {};
6573 var HISTORY_LENGTH = 5;
6574 var clearHistory = function () {
6575 history = {};
6576 };
6577 var toMenuItem = function (target) {
6578 return {
6579 title: target.title,
6580 value: {
6581 title: { raw: target.title },
6582 url: target.url,
6583 attach: target.attach
6584 }
6585 };
6586 };
6587 var toMenuItems = function (targets) {
6588 return global$2.map(targets, toMenuItem);
6589 };
6590 var staticMenuItem = function (title, url) {
6591 return {
6592 title: title,
6593 value: {
6594 title: title,
6595 url: url,
6596 attach: noop
6597 }
6598 };
6599 };
6600 var isUniqueUrl = function (url, targets) {
6601 var foundTarget = exists(targets, function (target) {
6602 return target.url === url;
6603 });
6604 return !foundTarget;
6605 };
6606 var getSetting = function (editorSettings, name, defaultValue) {
6607 var value = name in editorSettings ? editorSettings[name] : defaultValue;
6608 return value === false ? null : value;
6609 };
6610 var createMenuItems = function (term, targets, fileType, editorSettings) {
6611 var separator = { title: '-' };
6612 var fromHistoryMenuItems = function (history) {
6613 var historyItems = history.hasOwnProperty(fileType) ? history[fileType] : [];
6614 var uniqueHistory = filter(historyItems, function (url) {
6615 return isUniqueUrl(url, targets);
6616 });
6617 return global$2.map(uniqueHistory, function (url) {
6618 return {
6619 title: url,
6620 value: {
6621 title: url,
6622 url: url,
6623 attach: noop
6624 }
6625 };
6626 });
6627 };
6628 var fromMenuItems = function (type) {
6629 var filteredTargets = filter(targets, function (target) {
6630 return target.type === type;
6631 });
6632 return toMenuItems(filteredTargets);
6633 };
6634 var anchorMenuItems = function () {
6635 var anchorMenuItems = fromMenuItems('anchor');
6636 var topAnchor = getSetting(editorSettings, 'anchor_top', '#top');
6637 var bottomAchor = getSetting(editorSettings, 'anchor_bottom', '#bottom');
6638 if (topAnchor !== null) {
6639 anchorMenuItems.unshift(staticMenuItem('<top>', topAnchor));
6640 }
6641 if (bottomAchor !== null) {
6642 anchorMenuItems.push(staticMenuItem('<bottom>', bottomAchor));
6643 }
6644 return anchorMenuItems;
6645 };
6646 var join = function (items) {
6647 return foldl(items, function (a, b) {
6648 var bothEmpty = a.length === 0 || b.length === 0;
6649 return bothEmpty ? a.concat(b) : a.concat(separator, b);
6650 }, []);
6651 };
6652 if (editorSettings.typeahead_urls === false) {
6653 return [];
6654 }
6655 return fileType === 'file' ? join([
6656 filterByQuery(term, fromHistoryMenuItems(history)),
6657 filterByQuery(term, fromMenuItems('header')),
6658 filterByQuery(term, anchorMenuItems())
6659 ]) : filterByQuery(term, fromHistoryMenuItems(history));
6660 };
6661 var addToHistory = function (url, fileType) {
6662 var items = history[fileType];
6663 if (!/^https?/.test(url)) {
6664 return;
6665 }
6666 if (items) {
6667 if (indexOf(items, url).isNone()) {
6668 history[fileType] = items.slice(0, HISTORY_LENGTH).concat(url);
6669 }
6670 } else {
6671 history[fileType] = [url];
6672 }
6673 };
6674 var filterByQuery = function (term, menuItems) {
6675 var lowerCaseTerm = term.toLowerCase();
6676 var result = global$2.grep(menuItems, function (item) {
6677 return item.title.toLowerCase().indexOf(lowerCaseTerm) !== -1;
6678 });
6679 return result.length === 1 && result[0].title === term ? [] : result;
6680 };
6681 var getTitle = function (linkDetails) {
6682 var title = linkDetails.title;
6683 return title.raw ? title.raw : title;
6684 };
6685 var setupAutoCompleteHandler = function (ctrl, editorSettings, bodyElm, fileType) {
6686 var autocomplete = function (term) {
6687 var linkTargets = LinkTargets.find(bodyElm);
6688 var menuItems = createMenuItems(term, linkTargets, fileType, editorSettings);
6689 ctrl.showAutoComplete(menuItems, term);
6690 };
6691 ctrl.on('autocomplete', function () {
6692 autocomplete(ctrl.value());
6693 });
6694 ctrl.on('selectitem', function (e) {
6695 var linkDetails = e.value;
6696 ctrl.value(linkDetails.url);
6697 var title = getTitle(linkDetails);
6698 if (fileType === 'image') {
6699 ctrl.fire('change', {
6700 meta: {
6701 alt: title,
6702 attach: linkDetails.attach
6703 }
6704 });
6705 } else {
6706 ctrl.fire('change', {
6707 meta: {
6708 text: title,
6709 attach: linkDetails.attach
6710 }
6711 });
6712 }
6713 ctrl.focus();
6714 });
6715 ctrl.on('click', function (e) {
6716 if (ctrl.value().length === 0 && e.target.nodeName === 'INPUT') {
6717 autocomplete('');
6718 }
6719 });
6720 ctrl.on('PostRender', function () {
6721 ctrl.getRoot().on('submit', function (e) {
6722 if (!e.isDefaultPrevented()) {
6723 addToHistory(ctrl.value(), fileType);
6724 }
6725 });
6726 });
6727 };
6728 var statusToUiState = function (result) {
6729 var status = result.status, message = result.message;
6730 if (status === 'valid') {
6731 return {
6732 status: 'ok',
6733 message: message
6734 };
6735 } else if (status === 'unknown') {
6736 return {
6737 status: 'warn',
6738 message: message
6739 };
6740 } else if (status === 'invalid') {
6741 return {
6742 status: 'warn',
6743 message: message
6744 };
6745 } else {
6746 return {
6747 status: 'none',
6748 message: ''
6749 };
6750 }
6751 };
6752 var setupLinkValidatorHandler = function (ctrl, editorSettings, fileType) {
6753 var validatorHandler = editorSettings.filepicker_validator_handler;
6754 if (validatorHandler) {
6755 var validateUrl_1 = function (url) {
6756 if (url.length === 0) {
6757 ctrl.statusLevel('none');
6758 return;
6759 }
6760 validatorHandler({
6761 url: url,
6762 type: fileType
6763 }, function (result) {
6764 var uiState = statusToUiState(result);
6765 ctrl.statusMessage(uiState.message);
6766 ctrl.statusLevel(uiState.status);
6767 });
6768 };
6769 ctrl.state.on('change:value', function (e) {
6770 validateUrl_1(e.value);
6771 });
6772 }
6773 };
6774 var FilePicker = ComboBox.extend({
6775 Statics: { clearHistory: clearHistory },
6776 init: function (settings) {
6777 var self = this, editor = getActiveEditor(), editorSettings = editor.settings;
6778 var actionCallback, fileBrowserCallback, fileBrowserCallbackTypes;
6779 var fileType = settings.filetype;
6780 settings.spellcheck = false;
6781 fileBrowserCallbackTypes = editorSettings.file_picker_types || editorSettings.file_browser_callback_types;
6782 if (fileBrowserCallbackTypes) {
6783 fileBrowserCallbackTypes = global$2.makeMap(fileBrowserCallbackTypes, /[, ]/);
6784 }
6785 if (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType]) {
6786 fileBrowserCallback = editorSettings.file_picker_callback;
6787 if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
6788 actionCallback = function () {
6789 var meta = self.fire('beforecall').meta;
6790 meta = global$2.extend({ filetype: fileType }, meta);
6791 fileBrowserCallback.call(editor, function (value, meta) {
6792 self.value(value).fire('change', { meta: meta });
6793 }, self.value(), meta);
6794 };
6795 } else {
6796 fileBrowserCallback = editorSettings.file_browser_callback;
6797 if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
6798 actionCallback = function () {
6799 fileBrowserCallback(self.getEl('inp').id, self.value(), fileType, window);
6800 };
6801 }
6802 }
6803 }
6804 if (actionCallback) {
6805 settings.icon = 'browse';
6806 settings.onaction = actionCallback;
6807 }
6808 self._super(settings);
6809 self.classes.add('filepicker');
6810 setupAutoCompleteHandler(self, editorSettings, editor.getBody(), fileType);
6811 setupLinkValidatorHandler(self, editorSettings, fileType);
6812 }
6813 });
6814
6815 var FitLayout = AbsoluteLayout.extend({
6816 recalc: function (container) {
6817 var contLayoutRect = container.layoutRect(), paddingBox = container.paddingBox;
6818 container.items().filter(':visible').each(function (ctrl) {
6819 ctrl.layoutRect({
6820 x: paddingBox.left,
6821 y: paddingBox.top,
6822 w: contLayoutRect.innerW - paddingBox.right - paddingBox.left,
6823 h: contLayoutRect.innerH - paddingBox.top - paddingBox.bottom
6824 });
6825 if (ctrl.recalc) {
6826 ctrl.recalc();
6827 }
6828 });
6829 }
6830 });
6831
6832 var FlexLayout = AbsoluteLayout.extend({
6833 recalc: function (container) {
6834 var i, l, items, contLayoutRect, contPaddingBox, contSettings, align, pack, spacing, totalFlex, availableSpace, direction;
6835 var ctrl, ctrlLayoutRect, ctrlSettings, flex;
6836 var maxSizeItems = [];
6837 var size, maxSize, ratio, rect, pos, maxAlignEndPos;
6838 var sizeName, minSizeName, posName, maxSizeName, beforeName, innerSizeName, deltaSizeName, contentSizeName;
6839 var alignAxisName, alignInnerSizeName, alignSizeName, alignMinSizeName, alignBeforeName, alignAfterName;
6840 var alignDeltaSizeName, alignContentSizeName;
6841 var max = Math.max, min = Math.min;
6842 items = container.items().filter(':visible');
6843 contLayoutRect = container.layoutRect();
6844 contPaddingBox = container.paddingBox;
6845 contSettings = container.settings;
6846 direction = container.isRtl() ? contSettings.direction || 'row-reversed' : contSettings.direction;
6847 align = contSettings.align;
6848 pack = container.isRtl() ? contSettings.pack || 'end' : contSettings.pack;
6849 spacing = contSettings.spacing || 0;
6850 if (direction === 'row-reversed' || direction === 'column-reverse') {
6851 items = items.set(items.toArray().reverse());
6852 direction = direction.split('-')[0];
6853 }
6854 if (direction === 'column') {
6855 posName = 'y';
6856 sizeName = 'h';
6857 minSizeName = 'minH';
6858 maxSizeName = 'maxH';
6859 innerSizeName = 'innerH';
6860 beforeName = 'top';
6861 deltaSizeName = 'deltaH';
6862 contentSizeName = 'contentH';
6863 alignBeforeName = 'left';
6864 alignSizeName = 'w';
6865 alignAxisName = 'x';
6866 alignInnerSizeName = 'innerW';
6867 alignMinSizeName = 'minW';
6868 alignAfterName = 'right';
6869 alignDeltaSizeName = 'deltaW';
6870 alignContentSizeName = 'contentW';
6871 } else {
6872 posName = 'x';
6873 sizeName = 'w';
6874 minSizeName = 'minW';
6875 maxSizeName = 'maxW';
6876 innerSizeName = 'innerW';
6877 beforeName = 'left';
6878 deltaSizeName = 'deltaW';
6879 contentSizeName = 'contentW';
6880 alignBeforeName = 'top';
6881 alignSizeName = 'h';
6882 alignAxisName = 'y';
6883 alignInnerSizeName = 'innerH';
6884 alignMinSizeName = 'minH';
6885 alignAfterName = 'bottom';
6886 alignDeltaSizeName = 'deltaH';
6887 alignContentSizeName = 'contentH';
6888 }
6889 availableSpace = contLayoutRect[innerSizeName] - contPaddingBox[beforeName] - contPaddingBox[beforeName];
6890 maxAlignEndPos = totalFlex = 0;
6891 for (i = 0, l = items.length; i < l; i++) {
6892 ctrl = items[i];
6893 ctrlLayoutRect = ctrl.layoutRect();
6894 ctrlSettings = ctrl.settings;
6895 flex = ctrlSettings.flex;
6896 availableSpace -= i < l - 1 ? spacing : 0;
6897 if (flex > 0) {
6898 totalFlex += flex;
6899 if (ctrlLayoutRect[maxSizeName]) {
6900 maxSizeItems.push(ctrl);
6901 }
6902 ctrlLayoutRect.flex = flex;
6903 }
6904 availableSpace -= ctrlLayoutRect[minSizeName];
6905 size = contPaddingBox[alignBeforeName] + ctrlLayoutRect[alignMinSizeName] + contPaddingBox[alignAfterName];
6906 if (size > maxAlignEndPos) {
6907 maxAlignEndPos = size;
6908 }
6909 }
6910 rect = {};
6911 if (availableSpace < 0) {
6912 rect[minSizeName] = contLayoutRect[minSizeName] - availableSpace + contLayoutRect[deltaSizeName];
6913 } else {
6914 rect[minSizeName] = contLayoutRect[innerSizeName] - availableSpace + contLayoutRect[deltaSizeName];
6915 }
6916 rect[alignMinSizeName] = maxAlignEndPos + contLayoutRect[alignDeltaSizeName];
6917 rect[contentSizeName] = contLayoutRect[innerSizeName] - availableSpace;
6918 rect[alignContentSizeName] = maxAlignEndPos;
6919 rect.minW = min(rect.minW, contLayoutRect.maxW);
6920 rect.minH = min(rect.minH, contLayoutRect.maxH);
6921 rect.minW = max(rect.minW, contLayoutRect.startMinWidth);
6922 rect.minH = max(rect.minH, contLayoutRect.startMinHeight);
6923 if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
6924 rect.w = rect.minW;
6925 rect.h = rect.minH;
6926 container.layoutRect(rect);
6927 this.recalc(container);
6928 if (container._lastRect === null) {
6929 var parentCtrl = container.parent();
6930 if (parentCtrl) {
6931 parentCtrl._lastRect = null;
6932 parentCtrl.recalc();
6933 }
6934 }
6935 return;
6936 }
6937 ratio = availableSpace / totalFlex;
6938 for (i = 0, l = maxSizeItems.length; i < l; i++) {
6939 ctrl = maxSizeItems[i];
6940 ctrlLayoutRect = ctrl.layoutRect();
6941 maxSize = ctrlLayoutRect[maxSizeName];
6942 size = ctrlLayoutRect[minSizeName] + ctrlLayoutRect.flex * ratio;
6943 if (size > maxSize) {
6944 availableSpace -= ctrlLayoutRect[maxSizeName] - ctrlLayoutRect[minSizeName];
6945 totalFlex -= ctrlLayoutRect.flex;
6946 ctrlLayoutRect.flex = 0;
6947 ctrlLayoutRect.maxFlexSize = maxSize;
6948 } else {
6949 ctrlLayoutRect.maxFlexSize = 0;
6950 }
6951 }
6952 ratio = availableSpace / totalFlex;
6953 pos = contPaddingBox[beforeName];
6954 rect = {};
6955 if (totalFlex === 0) {
6956 if (pack === 'end') {
6957 pos = availableSpace + contPaddingBox[beforeName];
6958 } else if (pack === 'center') {
6959 pos = Math.round(contLayoutRect[innerSizeName] / 2 - (contLayoutRect[innerSizeName] - availableSpace) / 2) + contPaddingBox[beforeName];
6960 if (pos < 0) {
6961 pos = contPaddingBox[beforeName];
6962 }
6963 } else if (pack === 'justify') {
6964 pos = contPaddingBox[beforeName];
6965 spacing = Math.floor(availableSpace / (items.length - 1));
6966 }
6967 }
6968 rect[alignAxisName] = contPaddingBox[alignBeforeName];
6969 for (i = 0, l = items.length; i < l; i++) {
6970 ctrl = items[i];
6971 ctrlLayoutRect = ctrl.layoutRect();
6972 size = ctrlLayoutRect.maxFlexSize || ctrlLayoutRect[minSizeName];
6973 if (align === 'center') {
6974 rect[alignAxisName] = Math.round(contLayoutRect[alignInnerSizeName] / 2 - ctrlLayoutRect[alignSizeName] / 2);
6975 } else if (align === 'stretch') {
6976 rect[alignSizeName] = max(ctrlLayoutRect[alignMinSizeName] || 0, contLayoutRect[alignInnerSizeName] - contPaddingBox[alignBeforeName] - contPaddingBox[alignAfterName]);
6977 rect[alignAxisName] = contPaddingBox[alignBeforeName];
6978 } else if (align === 'end') {
6979 rect[alignAxisName] = contLayoutRect[alignInnerSizeName] - ctrlLayoutRect[alignSizeName] - contPaddingBox.top;
6980 }
6981 if (ctrlLayoutRect.flex > 0) {
6982 size += ctrlLayoutRect.flex * ratio;
6983 }
6984 rect[sizeName] = size;
6985 rect[posName] = pos;
6986 ctrl.layoutRect(rect);
6987 if (ctrl.recalc) {
6988 ctrl.recalc();
6989 }
6990 pos += size + spacing;
6991 }
6992 }
6993 });
6994
6995 var FlowLayout = Layout.extend({
6996 Defaults: {
6997 containerClass: 'flow-layout',
6998 controlClass: 'flow-layout-item',
6999 endClass: 'break'
7000 },
7001 recalc: function (container) {
7002 container.items().filter(':visible').each(function (ctrl) {
7003 if (ctrl.recalc) {
7004 ctrl.recalc();
7005 }
7006 });
7007 },
7008 isNative: function () {
7009 return true;
7010 }
7011 });
7012
7013 var descendant = function (scope, selector) {
7014 return one(selector, scope);
7015 };
7016
7017 var toggleFormat = function (editor, fmt) {
7018 return function () {
7019 editor.execCommand('mceToggleFormat', false, fmt);
7020 };
7021 };
7022 var addFormatChangedListener = function (editor, name, changed) {
7023 var handler = function (state) {
7024 changed(state, name);
7025 };
7026 if (editor.formatter) {
7027 editor.formatter.formatChanged(name, handler);
7028 } else {
7029 editor.on('init', function () {
7030 editor.formatter.formatChanged(name, handler);
7031 });
7032 }
7033 };
7034 var postRenderFormatToggle = function (editor, name) {
7035 return function (e) {
7036 addFormatChangedListener(editor, name, function (state) {
7037 e.control.active(state);
7038 });
7039 };
7040 };
7041
7042 var register = function (editor) {
7043 var alignFormats = [
7044 'alignleft',
7045 'aligncenter',
7046 'alignright',
7047 'alignjustify'
7048 ];
7049 var defaultAlign = 'alignleft';
7050 var alignMenuItems = [
7051 {
7052 text: 'Left',
7053 icon: 'alignleft',
7054 onclick: toggleFormat(editor, 'alignleft')
7055 },
7056 {
7057 text: 'Center',
7058 icon: 'aligncenter',
7059 onclick: toggleFormat(editor, 'aligncenter')
7060 },
7061 {
7062 text: 'Right',
7063 icon: 'alignright',
7064 onclick: toggleFormat(editor, 'alignright')
7065 },
7066 {
7067 text: 'Justify',
7068 icon: 'alignjustify',
7069 onclick: toggleFormat(editor, 'alignjustify')
7070 }
7071 ];
7072 editor.addMenuItem('align', {
7073 text: 'Align',
7074 menu: alignMenuItems
7075 });
7076 editor.addButton('align', {
7077 type: 'menubutton',
7078 icon: defaultAlign,
7079 menu: alignMenuItems,
7080 onShowMenu: function (e) {
7081 var menu = e.control.menu;
7082 global$2.each(alignFormats, function (formatName, idx) {
7083 menu.items().eq(idx).each(function (item) {
7084 return item.active(editor.formatter.match(formatName));
7085 });
7086 });
7087 },
7088 onPostRender: function (e) {
7089 var ctrl = e.control;
7090 global$2.each(alignFormats, function (formatName, idx) {
7091 addFormatChangedListener(editor, formatName, function (state) {
7092 ctrl.icon(defaultAlign);
7093 if (state) {
7094 ctrl.icon(formatName);
7095 }
7096 });
7097 });
7098 }
7099 });
7100 global$2.each({
7101 alignleft: [
7102 'Align left',
7103 'JustifyLeft'
7104 ],
7105 aligncenter: [
7106 'Align center',
7107 'JustifyCenter'
7108 ],
7109 alignright: [
7110 'Align right',
7111 'JustifyRight'
7112 ],
7113 alignjustify: [
7114 'Justify',
7115 'JustifyFull'
7116 ],
7117 alignnone: [
7118 'No alignment',
7119 'JustifyNone'
7120 ]
7121 }, function (item, name) {
7122 editor.addButton(name, {
7123 active: false,
7124 tooltip: item[0],
7125 cmd: item[1],
7126 onPostRender: postRenderFormatToggle(editor, name)
7127 });
7128 });
7129 };
7130 var Align = { register: register };
7131
7132 var getFirstFont = function (fontFamily) {
7133 return fontFamily ? fontFamily.split(',')[0] : '';
7134 };
7135 var findMatchingValue = function (items, fontFamily) {
7136 var font = fontFamily ? fontFamily.toLowerCase() : '';
7137 var value;
7138 global$2.each(items, function (item) {
7139 if (item.value.toLowerCase() === font) {
7140 value = item.value;
7141 }
7142 });
7143 global$2.each(items, function (item) {
7144 if (!value && getFirstFont(item.value).toLowerCase() === getFirstFont(font).toLowerCase()) {
7145 value = item.value;
7146 }
7147 });
7148 return value;
7149 };
7150 var createFontNameListBoxChangeHandler = function (editor, items) {
7151 return function () {
7152 var self = this;
7153 self.state.set('value', null);
7154 editor.on('init nodeChange', function (e) {
7155 var fontFamily = editor.queryCommandValue('FontName');
7156 var match = findMatchingValue(items, fontFamily);
7157 self.value(match ? match : null);
7158 if (!match && fontFamily) {
7159 self.text(getFirstFont(fontFamily));
7160 }
7161 });
7162 };
7163 };
7164 var createFormats = function (formats) {
7165 formats = formats.replace(/;$/, '').split(';');
7166 var i = formats.length;
7167 while (i--) {
7168 formats[i] = formats[i].split('=');
7169 }
7170 return formats;
7171 };
7172 var getFontItems = function (editor) {
7173 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';
7174 var fonts = createFormats(editor.settings.font_formats || defaultFontsFormats);
7175 return global$2.map(fonts, function (font) {
7176 return {
7177 text: { raw: font[0] },
7178 value: font[1],
7179 textStyle: font[1].indexOf('dings') === -1 ? 'font-family:' + font[1] : ''
7180 };
7181 });
7182 };
7183 var registerButtons = function (editor) {
7184 editor.addButton('fontselect', function () {
7185 var items = getFontItems(editor);
7186 return {
7187 type: 'listbox',
7188 text: 'Font Family',
7189 tooltip: 'Font Family',
7190 values: items,
7191 fixedWidth: true,
7192 onPostRender: createFontNameListBoxChangeHandler(editor, items),
7193 onselect: function (e) {
7194 if (e.control.settings.value) {
7195 editor.execCommand('FontName', false, e.control.settings.value);
7196 }
7197 }
7198 };
7199 });
7200 };
7201 var register$1 = function (editor) {
7202 registerButtons(editor);
7203 };
7204 var FontSelect = { register: register$1 };
7205
7206 var round = function (number, precision) {
7207 var factor = Math.pow(10, precision);
7208 return Math.round(number * factor) / factor;
7209 };
7210 var toPt = function (fontSize, precision) {
7211 if (/[0-9.]+px$/.test(fontSize)) {
7212 return round(parseInt(fontSize, 10) * 72 / 96, precision || 0) + 'pt';
7213 }
7214 return fontSize;
7215 };
7216 var findMatchingValue$1 = function (items, pt, px) {
7217 var value;
7218 global$2.each(items, function (item) {
7219 if (item.value === px) {
7220 value = px;
7221 } else if (item.value === pt) {
7222 value = pt;
7223 }
7224 });
7225 return value;
7226 };
7227 var createFontSizeListBoxChangeHandler = function (editor, items) {
7228 return function () {
7229 var self = this;
7230 editor.on('init nodeChange', function (e) {
7231 var px, pt, precision, match;
7232 px = editor.queryCommandValue('FontSize');
7233 if (px) {
7234 for (precision = 3; !match && precision >= 0; precision--) {
7235 pt = toPt(px, precision);
7236 match = findMatchingValue$1(items, pt, px);
7237 }
7238 }
7239 self.value(match ? match : null);
7240 if (!match) {
7241 self.text(pt);
7242 }
7243 });
7244 };
7245 };
7246 var getFontSizeItems = function (editor) {
7247 var defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt';
7248 var fontsizeFormats = editor.settings.fontsize_formats || defaultFontsizeFormats;
7249 return global$2.map(fontsizeFormats.split(' '), function (item) {
7250 var text = item, value = item;
7251 var values = item.split('=');
7252 if (values.length > 1) {
7253 text = values[0];
7254 value = values[1];
7255 }
7256 return {
7257 text: text,
7258 value: value
7259 };
7260 });
7261 };
7262 var registerButtons$1 = function (editor) {
7263 editor.addButton('fontsizeselect', function () {
7264 var items = getFontSizeItems(editor);
7265 return {
7266 type: 'listbox',
7267 text: 'Font Sizes',
7268 tooltip: 'Font Sizes',
7269 values: items,
7270 fixedWidth: true,
7271 onPostRender: createFontSizeListBoxChangeHandler(editor, items),
7272 onclick: function (e) {
7273 if (e.control.settings.value) {
7274 editor.execCommand('FontSize', false, e.control.settings.value);
7275 }
7276 }
7277 };
7278 });
7279 };
7280 var register$2 = function (editor) {
7281 registerButtons$1(editor);
7282 };
7283 var FontSizeSelect = { register: register$2 };
7284
7285 var hideMenuObjects = function (editor, menu) {
7286 var count = menu.length;
7287 global$2.each(menu, function (item) {
7288 if (item.menu) {
7289 item.hidden = hideMenuObjects(editor, item.menu) === 0;
7290 }
7291 var formatName = item.format;
7292 if (formatName) {
7293 item.hidden = !editor.formatter.canApply(formatName);
7294 }
7295 if (item.hidden) {
7296 count--;
7297 }
7298 });
7299 return count;
7300 };
7301 var hideFormatMenuItems = function (editor, menu) {
7302 var count = menu.items().length;
7303 menu.items().each(function (item) {
7304 if (item.menu) {
7305 item.visible(hideFormatMenuItems(editor, item.menu) > 0);
7306 }
7307 if (!item.menu && item.settings.menu) {
7308 item.visible(hideMenuObjects(editor, item.settings.menu) > 0);
7309 }
7310 var formatName = item.settings.format;
7311 if (formatName) {
7312 item.visible(editor.formatter.canApply(formatName));
7313 }
7314 if (!item.visible()) {
7315 count--;
7316 }
7317 });
7318 return count;
7319 };
7320 var createFormatMenu = function (editor) {
7321 var count = 0;
7322 var newFormats = [];
7323 var defaultStyleFormats = [
7324 {
7325 title: 'Headings',
7326 items: [
7327 {
7328 title: 'Heading 1',
7329 format: 'h1'
7330 },
7331 {
7332 title: 'Heading 2',
7333 format: 'h2'
7334 },
7335 {
7336 title: 'Heading 3',
7337 format: 'h3'
7338 },
7339 {
7340 title: 'Heading 4',
7341 format: 'h4'
7342 },
7343 {
7344 title: 'Heading 5',
7345 format: 'h5'
7346 },
7347 {
7348 title: 'Heading 6',
7349 format: 'h6'
7350 }
7351 ]
7352 },
7353 {
7354 title: 'Inline',
7355 items: [
7356 {
7357 title: 'Bold',
7358 icon: 'bold',
7359 format: 'bold'
7360 },
7361 {
7362 title: 'Italic',
7363 icon: 'italic',
7364 format: 'italic'
7365 },
7366 {
7367 title: 'Underline',
7368 icon: 'underline',
7369 format: 'underline'
7370 },
7371 {
7372 title: 'Strikethrough',
7373 icon: 'strikethrough',
7374 format: 'strikethrough'
7375 },
7376 {
7377 title: 'Superscript',
7378 icon: 'superscript',
7379 format: 'superscript'
7380 },
7381 {
7382 title: 'Subscript',
7383 icon: 'subscript',
7384 format: 'subscript'
7385 },
7386 {
7387 title: 'Code',
7388 icon: 'code',
7389 format: 'code'
7390 }
7391 ]
7392 },
7393 {
7394 title: 'Blocks',
7395 items: [
7396 {
7397 title: 'Paragraph',
7398 format: 'p'
7399 },
7400 {
7401 title: 'Blockquote',
7402 format: 'blockquote'
7403 },
7404 {
7405 title: 'Div',
7406 format: 'div'
7407 },
7408 {
7409 title: 'Pre',
7410 format: 'pre'
7411 }
7412 ]
7413 },
7414 {
7415 title: 'Alignment',
7416 items: [
7417 {
7418 title: 'Left',
7419 icon: 'alignleft',
7420 format: 'alignleft'
7421 },
7422 {
7423 title: 'Center',
7424 icon: 'aligncenter',
7425 format: 'aligncenter'
7426 },
7427 {
7428 title: 'Right',
7429 icon: 'alignright',
7430 format: 'alignright'
7431 },
7432 {
7433 title: 'Justify',
7434 icon: 'alignjustify',
7435 format: 'alignjustify'
7436 }
7437 ]
7438 }
7439 ];
7440 var createMenu = function (formats) {
7441 var menu = [];
7442 if (!formats) {
7443 return;
7444 }
7445 global$2.each(formats, function (format) {
7446 var menuItem = {
7447 text: format.title,
7448 icon: format.icon
7449 };
7450 if (format.items) {
7451 menuItem.menu = createMenu(format.items);
7452 } else {
7453 var formatName = format.format || 'custom' + count++;
7454 if (!format.format) {
7455 format.name = formatName;
7456 newFormats.push(format);
7457 }
7458 menuItem.format = formatName;
7459 menuItem.cmd = format.cmd;
7460 }
7461 menu.push(menuItem);
7462 });
7463 return menu;
7464 };
7465 var createStylesMenu = function () {
7466 var menu;
7467 if (editor.settings.style_formats_merge) {
7468 if (editor.settings.style_formats) {
7469 menu = createMenu(defaultStyleFormats.concat(editor.settings.style_formats));
7470 } else {
7471 menu = createMenu(defaultStyleFormats);
7472 }
7473 } else {
7474 menu = createMenu(editor.settings.style_formats || defaultStyleFormats);
7475 }
7476 return menu;
7477 };
7478 editor.on('init', function () {
7479 global$2.each(newFormats, function (format) {
7480 editor.formatter.register(format.name, format);
7481 });
7482 });
7483 return {
7484 type: 'menu',
7485 items: createStylesMenu(),
7486 onPostRender: function (e) {
7487 editor.fire('renderFormatsMenu', { control: e.control });
7488 },
7489 itemDefaults: {
7490 preview: true,
7491 textStyle: function () {
7492 if (this.settings.format) {
7493 return editor.formatter.getCssText(this.settings.format);
7494 }
7495 },
7496 onPostRender: function () {
7497 var self = this;
7498 self.parent().on('show', function () {
7499 var formatName, command;
7500 formatName = self.settings.format;
7501 if (formatName) {
7502 self.disabled(!editor.formatter.canApply(formatName));
7503 self.active(editor.formatter.match(formatName));
7504 }
7505 command = self.settings.cmd;
7506 if (command) {
7507 self.active(editor.queryCommandState(command));
7508 }
7509 });
7510 },
7511 onclick: function () {
7512 if (this.settings.format) {
7513 toggleFormat(editor, this.settings.format)();
7514 }
7515 if (this.settings.cmd) {
7516 editor.execCommand(this.settings.cmd);
7517 }
7518 }
7519 }
7520 };
7521 };
7522 var registerMenuItems = function (editor, formatMenu) {
7523 editor.addMenuItem('formats', {
7524 text: 'Formats',
7525 menu: formatMenu
7526 });
7527 };
7528 var registerButtons$2 = function (editor, formatMenu) {
7529 editor.addButton('styleselect', {
7530 type: 'menubutton',
7531 text: 'Formats',
7532 menu: formatMenu,
7533 onShowMenu: function () {
7534 if (editor.settings.style_formats_autohide) {
7535 hideFormatMenuItems(editor, this.menu);
7536 }
7537 }
7538 });
7539 };
7540 var register$3 = function (editor) {
7541 var formatMenu = createFormatMenu(editor);
7542 registerMenuItems(editor, formatMenu);
7543 registerButtons$2(editor, formatMenu);
7544 };
7545 var Formats = { register: register$3 };
7546
7547 var defaultBlocks = 'Paragraph=p;' + 'Heading 1=h1;' + 'Heading 2=h2;' + 'Heading 3=h3;' + 'Heading 4=h4;' + 'Heading 5=h5;' + 'Heading 6=h6;' + 'Preformatted=pre';
7548 var createFormats$1 = function (formats) {
7549 formats = formats.replace(/;$/, '').split(';');
7550 var i = formats.length;
7551 while (i--) {
7552 formats[i] = formats[i].split('=');
7553 }
7554 return formats;
7555 };
7556 var createListBoxChangeHandler = function (editor, items, formatName) {
7557 return function () {
7558 var self = this;
7559 editor.on('nodeChange', function (e) {
7560 var formatter = editor.formatter;
7561 var value = null;
7562 global$2.each(e.parents, function (node) {
7563 global$2.each(items, function (item) {
7564 if (formatName) {
7565 if (formatter.matchNode(node, formatName, { value: item.value })) {
7566 value = item.value;
7567 }
7568 } else {
7569 if (formatter.matchNode(node, item.value)) {
7570 value = item.value;
7571 }
7572 }
7573 if (value) {
7574 return false;
7575 }
7576 });
7577 if (value) {
7578 return false;
7579 }
7580 });
7581 self.value(value);
7582 });
7583 };
7584 };
7585 var lazyFormatSelectBoxItems = function (editor, blocks) {
7586 return function () {
7587 var items = [];
7588 global$2.each(blocks, function (block) {
7589 items.push({
7590 text: block[0],
7591 value: block[1],
7592 textStyle: function () {
7593 return editor.formatter.getCssText(block[1]);
7594 }
7595 });
7596 });
7597 return {
7598 type: 'listbox',
7599 text: blocks[0][0],
7600 values: items,
7601 fixedWidth: true,
7602 onselect: function (e) {
7603 if (e.control) {
7604 var fmt = e.control.value();
7605 toggleFormat(editor, fmt)();
7606 }
7607 },
7608 onPostRender: createListBoxChangeHandler(editor, items)
7609 };
7610 };
7611 };
7612 var buildMenuItems = function (editor, blocks) {
7613 return global$2.map(blocks, function (block) {
7614 return {
7615 text: block[0],
7616 onclick: toggleFormat(editor, block[1]),
7617 textStyle: function () {
7618 return editor.formatter.getCssText(block[1]);
7619 }
7620 };
7621 });
7622 };
7623 var register$4 = function (editor) {
7624 var blocks = createFormats$1(editor.settings.block_formats || defaultBlocks);
7625 editor.addMenuItem('blockformats', {
7626 text: 'Blocks',
7627 menu: buildMenuItems(editor, blocks)
7628 });
7629 editor.addButton('formatselect', lazyFormatSelectBoxItems(editor, blocks));
7630 };
7631 var FormatSelect = { register: register$4 };
7632
7633 var createCustomMenuItems = function (editor, names) {
7634 var items, nameList;
7635 if (typeof names === 'string') {
7636 nameList = names.split(' ');
7637 } else if (global$2.isArray(names)) {
7638 return flatten(global$2.map(names, function (names) {
7639 return createCustomMenuItems(editor, names);
7640 }));
7641 }
7642 items = global$2.grep(nameList, function (name) {
7643 return name === '|' || name in editor.menuItems;
7644 });
7645 return global$2.map(items, function (name) {
7646 return name === '|' ? { text: '-' } : editor.menuItems[name];
7647 });
7648 };
7649 var isSeparator$1 = function (menuItem) {
7650 return menuItem && menuItem.text === '-';
7651 };
7652 var trimMenuItems = function (menuItems) {
7653 var menuItems2 = filter(menuItems, function (menuItem, i) {
7654 return !isSeparator$1(menuItem) || !isSeparator$1(menuItems[i - 1]);
7655 });
7656 return filter(menuItems2, function (menuItem, i) {
7657 return !isSeparator$1(menuItem) || i > 0 && i < menuItems2.length - 1;
7658 });
7659 };
7660 var createContextMenuItems = function (editor, context) {
7661 var outputMenuItems = [{ text: '-' }];
7662 var menuItems = global$2.grep(editor.menuItems, function (menuItem) {
7663 return menuItem.context === context;
7664 });
7665 global$2.each(menuItems, function (menuItem) {
7666 if (menuItem.separator === 'before') {
7667 outputMenuItems.push({ text: '|' });
7668 }
7669 if (menuItem.prependToContext) {
7670 outputMenuItems.unshift(menuItem);
7671 } else {
7672 outputMenuItems.push(menuItem);
7673 }
7674 if (menuItem.separator === 'after') {
7675 outputMenuItems.push({ text: '|' });
7676 }
7677 });
7678 return outputMenuItems;
7679 };
7680 var createInsertMenu = function (editor) {
7681 var insertButtonItems = editor.settings.insert_button_items;
7682 if (insertButtonItems) {
7683 return trimMenuItems(createCustomMenuItems(editor, insertButtonItems));
7684 } else {
7685 return trimMenuItems(createContextMenuItems(editor, 'insert'));
7686 }
7687 };
7688 var registerButtons$3 = function (editor) {
7689 editor.addButton('insert', {
7690 type: 'menubutton',
7691 icon: 'insert',
7692 menu: [],
7693 oncreatemenu: function () {
7694 this.menu.add(createInsertMenu(editor));
7695 this.menu.renderNew();
7696 }
7697 });
7698 };
7699 var register$5 = function (editor) {
7700 registerButtons$3(editor);
7701 };
7702 var InsertButton = { register: register$5 };
7703
7704 var registerFormatButtons = function (editor) {
7705 global$2.each({
7706 bold: 'Bold',
7707 italic: 'Italic',
7708 underline: 'Underline',
7709 strikethrough: 'Strikethrough',
7710 subscript: 'Subscript',
7711 superscript: 'Superscript'
7712 }, function (text, name) {
7713 editor.addButton(name, {
7714 active: false,
7715 tooltip: text,
7716 onPostRender: postRenderFormatToggle(editor, name),
7717 onclick: toggleFormat(editor, name)
7718 });
7719 });
7720 };
7721 var registerCommandButtons = function (editor) {
7722 global$2.each({
7723 outdent: [
7724 'Decrease indent',
7725 'Outdent'
7726 ],
7727 indent: [
7728 'Increase indent',
7729 'Indent'
7730 ],
7731 cut: [
7732 'Cut',
7733 'Cut'
7734 ],
7735 copy: [
7736 'Copy',
7737 'Copy'
7738 ],
7739 paste: [
7740 'Paste',
7741 'Paste'
7742 ],
7743 help: [
7744 'Help',
7745 'mceHelp'
7746 ],
7747 selectall: [
7748 'Select all',
7749 'SelectAll'
7750 ],
7751 visualaid: [
7752 'Visual aids',
7753 'mceToggleVisualAid'
7754 ],
7755 newdocument: [
7756 'New document',
7757 'mceNewDocument'
7758 ],
7759 removeformat: [
7760 'Clear formatting',
7761 'RemoveFormat'
7762 ],
7763 remove: [
7764 'Remove',
7765 'Delete'
7766 ]
7767 }, function (item, name) {
7768 editor.addButton(name, {
7769 tooltip: item[0],
7770 cmd: item[1]
7771 });
7772 });
7773 };
7774 var registerCommandToggleButtons = function (editor) {
7775 global$2.each({
7776 blockquote: [
7777 'Blockquote',
7778 'mceBlockQuote'
7779 ],
7780 subscript: [
7781 'Subscript',
7782 'Subscript'
7783 ],
7784 superscript: [
7785 'Superscript',
7786 'Superscript'
7787 ]
7788 }, function (item, name) {
7789 editor.addButton(name, {
7790 active: false,
7791 tooltip: item[0],
7792 cmd: item[1],
7793 onPostRender: postRenderFormatToggle(editor, name)
7794 });
7795 });
7796 };
7797 var registerButtons$4 = function (editor) {
7798 registerFormatButtons(editor);
7799 registerCommandButtons(editor);
7800 registerCommandToggleButtons(editor);
7801 };
7802 var registerMenuItems$1 = function (editor) {
7803 global$2.each({
7804 bold: [
7805 'Bold',
7806 'Bold',
7807 'Meta+B'
7808 ],
7809 italic: [
7810 'Italic',
7811 'Italic',
7812 'Meta+I'
7813 ],
7814 underline: [
7815 'Underline',
7816 'Underline',
7817 'Meta+U'
7818 ],
7819 strikethrough: [
7820 'Strikethrough',
7821 'Strikethrough'
7822 ],
7823 subscript: [
7824 'Subscript',
7825 'Subscript'
7826 ],
7827 superscript: [
7828 'Superscript',
7829 'Superscript'
7830 ],
7831 removeformat: [
7832 'Clear formatting',
7833 'RemoveFormat'
7834 ],
7835 newdocument: [
7836 'New document',
7837 'mceNewDocument'
7838 ],
7839 cut: [
7840 'Cut',
7841 'Cut',
7842 'Meta+X'
7843 ],
7844 copy: [
7845 'Copy',
7846 'Copy',
7847 'Meta+C'
7848 ],
7849 paste: [
7850 'Paste',
7851 'Paste',
7852 'Meta+V'
7853 ],
7854 selectall: [
7855 'Select all',
7856 'SelectAll',
7857 'Meta+A'
7858 ]
7859 }, function (item, name) {
7860 editor.addMenuItem(name, {
7861 text: item[0],
7862 icon: name,
7863 shortcut: item[2],
7864 cmd: item[1]
7865 });
7866 });
7867 editor.addMenuItem('codeformat', {
7868 text: 'Code',
7869 icon: 'code',
7870 onclick: toggleFormat(editor, 'code')
7871 });
7872 };
7873 var register$6 = function (editor) {
7874 registerButtons$4(editor);
7875 registerMenuItems$1(editor);
7876 };
7877 var SimpleControls = { register: register$6 };
7878
7879 var toggleUndoRedoState = function (editor, type) {
7880 return function () {
7881 var self = this;
7882 var checkState = function () {
7883 var typeFn = type === 'redo' ? 'hasRedo' : 'hasUndo';
7884 return editor.undoManager ? editor.undoManager[typeFn]() : false;
7885 };
7886 self.disabled(!checkState());
7887 editor.on('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', function () {
7888 self.disabled(editor.readonly || !checkState());
7889 });
7890 };
7891 };
7892 var registerMenuItems$2 = function (editor) {
7893 editor.addMenuItem('undo', {
7894 text: 'Undo',
7895 icon: 'undo',
7896 shortcut: 'Meta+Z',
7897 onPostRender: toggleUndoRedoState(editor, 'undo'),
7898 cmd: 'undo'
7899 });
7900 editor.addMenuItem('redo', {
7901 text: 'Redo',
7902 icon: 'redo',
7903 shortcut: 'Meta+Y',
7904 onPostRender: toggleUndoRedoState(editor, 'redo'),
7905 cmd: 'redo'
7906 });
7907 };
7908 var registerButtons$5 = function (editor) {
7909 editor.addButton('undo', {
7910 tooltip: 'Undo',
7911 onPostRender: toggleUndoRedoState(editor, 'undo'),
7912 cmd: 'undo'
7913 });
7914 editor.addButton('redo', {
7915 tooltip: 'Redo',
7916 onPostRender: toggleUndoRedoState(editor, 'redo'),
7917 cmd: 'redo'
7918 });
7919 };
7920 var register$7 = function (editor) {
7921 registerMenuItems$2(editor);
7922 registerButtons$5(editor);
7923 };
7924 var UndoRedo = { register: register$7 };
7925
7926 var toggleVisualAidState = function (editor) {
7927 return function () {
7928 var self = this;
7929 editor.on('VisualAid', function (e) {
7930 self.active(e.hasVisual);
7931 });
7932 self.active(editor.hasVisual);
7933 };
7934 };
7935 var registerMenuItems$3 = function (editor) {
7936 editor.addMenuItem('visualaid', {
7937 text: 'Visual aids',
7938 selectable: true,
7939 onPostRender: toggleVisualAidState(editor),
7940 cmd: 'mceToggleVisualAid'
7941 });
7942 };
7943 var register$8 = function (editor) {
7944 registerMenuItems$3(editor);
7945 };
7946 var VisualAid = { register: register$8 };
7947
7948 var setupEnvironment = function () {
7949 Widget.tooltips = !global$8.iOS;
7950 Control$1.translate = function (text) {
7951 return global$1.translate(text);
7952 };
7953 };
7954 var setupUiContainer = function (editor) {
7955 if (editor.settings.ui_container) {
7956 global$8.container = descendant(Element.fromDom(domGlobals.document.body), editor.settings.ui_container).fold(constant(null), function (elm) {
7957 return elm.dom();
7958 });
7959 }
7960 };
7961 var setupRtlMode = function (editor) {
7962 if (editor.rtl) {
7963 Control$1.rtl = true;
7964 }
7965 };
7966 var setupHideFloatPanels = function (editor) {
7967 editor.on('mousedown progressstate', function () {
7968 FloatPanel.hideAll();
7969 });
7970 };
7971 var setup$1 = function (editor) {
7972 setupRtlMode(editor);
7973 setupHideFloatPanels(editor);
7974 setupUiContainer(editor);
7975 setupEnvironment();
7976 FormatSelect.register(editor);
7977 Align.register(editor);
7978 SimpleControls.register(editor);
7979 UndoRedo.register(editor);
7980 FontSizeSelect.register(editor);
7981 FontSelect.register(editor);
7982 Formats.register(editor);
7983 VisualAid.register(editor);
7984 InsertButton.register(editor);
7985 };
7986 var FormatControls = { setup: setup$1 };
7987
7988 var GridLayout = AbsoluteLayout.extend({
7989 recalc: function (container) {
7990 var settings, rows, cols, items, contLayoutRect, width, height, rect, ctrlLayoutRect, ctrl, x, y, posX, posY, ctrlSettings, contPaddingBox, align, spacingH, spacingV, alignH, alignV, maxX, maxY;
7991 var colWidths = [];
7992 var rowHeights = [];
7993 var ctrlMinWidth, ctrlMinHeight, availableWidth, availableHeight, reverseRows, idx;
7994 settings = container.settings;
7995 items = container.items().filter(':visible');
7996 contLayoutRect = container.layoutRect();
7997 cols = settings.columns || Math.ceil(Math.sqrt(items.length));
7998 rows = Math.ceil(items.length / cols);
7999 spacingH = settings.spacingH || settings.spacing || 0;
8000 spacingV = settings.spacingV || settings.spacing || 0;
8001 alignH = settings.alignH || settings.align;
8002 alignV = settings.alignV || settings.align;
8003 contPaddingBox = container.paddingBox;
8004 reverseRows = 'reverseRows' in settings ? settings.reverseRows : container.isRtl();
8005 if (alignH && typeof alignH === 'string') {
8006 alignH = [alignH];
8007 }
8008 if (alignV && typeof alignV === 'string') {
8009 alignV = [alignV];
8010 }
8011 for (x = 0; x < cols; x++) {
8012 colWidths.push(0);
8013 }
8014 for (y = 0; y < rows; y++) {
8015 rowHeights.push(0);
8016 }
8017 for (y = 0; y < rows; y++) {
8018 for (x = 0; x < cols; x++) {
8019 ctrl = items[y * cols + x];
8020 if (!ctrl) {
8021 break;
8022 }
8023 ctrlLayoutRect = ctrl.layoutRect();
8024 ctrlMinWidth = ctrlLayoutRect.minW;
8025 ctrlMinHeight = ctrlLayoutRect.minH;
8026 colWidths[x] = ctrlMinWidth > colWidths[x] ? ctrlMinWidth : colWidths[x];
8027 rowHeights[y] = ctrlMinHeight > rowHeights[y] ? ctrlMinHeight : rowHeights[y];
8028 }
8029 }
8030 availableWidth = contLayoutRect.innerW - contPaddingBox.left - contPaddingBox.right;
8031 for (maxX = 0, x = 0; x < cols; x++) {
8032 maxX += colWidths[x] + (x > 0 ? spacingH : 0);
8033 availableWidth -= (x > 0 ? spacingH : 0) + colWidths[x];
8034 }
8035 availableHeight = contLayoutRect.innerH - contPaddingBox.top - contPaddingBox.bottom;
8036 for (maxY = 0, y = 0; y < rows; y++) {
8037 maxY += rowHeights[y] + (y > 0 ? spacingV : 0);
8038 availableHeight -= (y > 0 ? spacingV : 0) + rowHeights[y];
8039 }
8040 maxX += contPaddingBox.left + contPaddingBox.right;
8041 maxY += contPaddingBox.top + contPaddingBox.bottom;
8042 rect = {};
8043 rect.minW = maxX + (contLayoutRect.w - contLayoutRect.innerW);
8044 rect.minH = maxY + (contLayoutRect.h - contLayoutRect.innerH);
8045 rect.contentW = rect.minW - contLayoutRect.deltaW;
8046 rect.contentH = rect.minH - contLayoutRect.deltaH;
8047 rect.minW = Math.min(rect.minW, contLayoutRect.maxW);
8048 rect.minH = Math.min(rect.minH, contLayoutRect.maxH);
8049 rect.minW = Math.max(rect.minW, contLayoutRect.startMinWidth);
8050 rect.minH = Math.max(rect.minH, contLayoutRect.startMinHeight);
8051 if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
8052 rect.w = rect.minW;
8053 rect.h = rect.minH;
8054 container.layoutRect(rect);
8055 this.recalc(container);
8056 if (container._lastRect === null) {
8057 var parentCtrl = container.parent();
8058 if (parentCtrl) {
8059 parentCtrl._lastRect = null;
8060 parentCtrl.recalc();
8061 }
8062 }
8063 return;
8064 }
8065 if (contLayoutRect.autoResize) {
8066 rect = container.layoutRect(rect);
8067 rect.contentW = rect.minW - contLayoutRect.deltaW;
8068 rect.contentH = rect.minH - contLayoutRect.deltaH;
8069 }
8070 var flexV;
8071 if (settings.packV === 'start') {
8072 flexV = 0;
8073 } else {
8074 flexV = availableHeight > 0 ? Math.floor(availableHeight / rows) : 0;
8075 }
8076 var totalFlex = 0;
8077 var flexWidths = settings.flexWidths;
8078 if (flexWidths) {
8079 for (x = 0; x < flexWidths.length; x++) {
8080 totalFlex += flexWidths[x];
8081 }
8082 } else {
8083 totalFlex = cols;
8084 }
8085 var ratio = availableWidth / totalFlex;
8086 for (x = 0; x < cols; x++) {
8087 colWidths[x] += flexWidths ? flexWidths[x] * ratio : ratio;
8088 }
8089 posY = contPaddingBox.top;
8090 for (y = 0; y < rows; y++) {
8091 posX = contPaddingBox.left;
8092 height = rowHeights[y] + flexV;
8093 for (x = 0; x < cols; x++) {
8094 if (reverseRows) {
8095 idx = y * cols + cols - 1 - x;
8096 } else {
8097 idx = y * cols + x;
8098 }
8099 ctrl = items[idx];
8100 if (!ctrl) {
8101 break;
8102 }
8103 ctrlSettings = ctrl.settings;
8104 ctrlLayoutRect = ctrl.layoutRect();
8105 width = Math.max(colWidths[x], ctrlLayoutRect.startMinWidth);
8106 ctrlLayoutRect.x = posX;
8107 ctrlLayoutRect.y = posY;
8108 align = ctrlSettings.alignH || (alignH ? alignH[x] || alignH[0] : null);
8109 if (align === 'center') {
8110 ctrlLayoutRect.x = posX + width / 2 - ctrlLayoutRect.w / 2;
8111 } else if (align === 'right') {
8112 ctrlLayoutRect.x = posX + width - ctrlLayoutRect.w;
8113 } else if (align === 'stretch') {
8114 ctrlLayoutRect.w = width;
8115 }
8116 align = ctrlSettings.alignV || (alignV ? alignV[x] || alignV[0] : null);
8117 if (align === 'center') {
8118 ctrlLayoutRect.y = posY + height / 2 - ctrlLayoutRect.h / 2;
8119 } else if (align === 'bottom') {
8120 ctrlLayoutRect.y = posY + height - ctrlLayoutRect.h;
8121 } else if (align === 'stretch') {
8122 ctrlLayoutRect.h = height;
8123 }
8124 ctrl.layoutRect(ctrlLayoutRect);
8125 posX += width + spacingH;
8126 if (ctrl.recalc) {
8127 ctrl.recalc();
8128 }
8129 }
8130 posY += height + spacingV;
8131 }
8132 }
8133 });
8134
8135 var Iframe$1 = Widget.extend({
8136 renderHtml: function () {
8137 var self = this;
8138 self.classes.add('iframe');
8139 self.canFocus = false;
8140 return '<iframe id="' + self._id + '" class="' + self.classes + '" tabindex="-1" src="' + (self.settings.url || 'javascript:\'\'') + '" frameborder="0"></iframe>';
8141 },
8142 src: function (src) {
8143 this.getEl().src = src;
8144 },
8145 html: function (html, callback) {
8146 var self = this, body = this.getEl().contentWindow.document.body;
8147 if (!body) {
8148 global$7.setTimeout(function () {
8149 self.html(html);
8150 });
8151 } else {
8152 body.innerHTML = html;
8153 if (callback) {
8154 callback();
8155 }
8156 }
8157 return this;
8158 }
8159 });
8160
8161 var InfoBox = Widget.extend({
8162 init: function (settings) {
8163 var self = this;
8164 self._super(settings);
8165 self.classes.add('widget').add('infobox');
8166 self.canFocus = false;
8167 },
8168 severity: function (level) {
8169 this.classes.remove('error');
8170 this.classes.remove('warning');
8171 this.classes.remove('success');
8172 this.classes.add(level);
8173 },
8174 help: function (state) {
8175 this.state.set('help', state);
8176 },
8177 renderHtml: function () {
8178 var self = this, prefix = self.classPrefix;
8179 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>';
8180 },
8181 bindStates: function () {
8182 var self = this;
8183 self.state.on('change:text', function (e) {
8184 self.getEl('body').firstChild.data = self.encode(e.value);
8185 if (self.state.get('rendered')) {
8186 self.updateLayoutRect();
8187 }
8188 });
8189 self.state.on('change:help', function (e) {
8190 self.classes.toggle('has-help', e.value);
8191 if (self.state.get('rendered')) {
8192 self.updateLayoutRect();
8193 }
8194 });
8195 return self._super();
8196 }
8197 });
8198
8199 var Label = Widget.extend({
8200 init: function (settings) {
8201 var self = this;
8202 self._super(settings);
8203 self.classes.add('widget').add('label');
8204 self.canFocus = false;
8205 if (settings.multiline) {
8206 self.classes.add('autoscroll');
8207 }
8208 if (settings.strong) {
8209 self.classes.add('strong');
8210 }
8211 },
8212 initLayoutRect: function () {
8213 var self = this, layoutRect = self._super();
8214 if (self.settings.multiline) {
8215 var size = funcs.getSize(self.getEl());
8216 if (size.width > layoutRect.maxW) {
8217 layoutRect.minW = layoutRect.maxW;
8218 self.classes.add('multiline');
8219 }
8220 self.getEl().style.width = layoutRect.minW + 'px';
8221 layoutRect.startMinH = layoutRect.h = layoutRect.minH = Math.min(layoutRect.maxH, funcs.getSize(self.getEl()).height);
8222 }
8223 return layoutRect;
8224 },
8225 repaint: function () {
8226 var self = this;
8227 if (!self.settings.multiline) {
8228 self.getEl().style.lineHeight = self.layoutRect().h + 'px';
8229 }
8230 return self._super();
8231 },
8232 severity: function (level) {
8233 this.classes.remove('error');
8234 this.classes.remove('warning');
8235 this.classes.remove('success');
8236 this.classes.add(level);
8237 },
8238 renderHtml: function () {
8239 var self = this;
8240 var targetCtrl, forName, forId = self.settings.forId;
8241 var text = self.settings.html ? self.settings.html : self.encode(self.state.get('text'));
8242 if (!forId && (forName = self.settings.forName)) {
8243 targetCtrl = self.getRoot().find('#' + forName)[0];
8244 if (targetCtrl) {
8245 forId = targetCtrl._id;
8246 }
8247 }
8248 if (forId) {
8249 return '<label id="' + self._id + '" class="' + self.classes + '"' + (forId ? ' for="' + forId + '"' : '') + '>' + text + '</label>';
8250 }
8251 return '<span id="' + self._id + '" class="' + self.classes + '">' + text + '</span>';
8252 },
8253 bindStates: function () {
8254 var self = this;
8255 self.state.on('change:text', function (e) {
8256 self.innerHtml(self.encode(e.value));
8257 if (self.state.get('rendered')) {
8258 self.updateLayoutRect();
8259 }
8260 });
8261 return self._super();
8262 }
8263 });
8264
8265 var Toolbar$1 = Container.extend({
8266 Defaults: {
8267 role: 'toolbar',
8268 layout: 'flow'
8269 },
8270 init: function (settings) {
8271 var self = this;
8272 self._super(settings);
8273 self.classes.add('toolbar');
8274 },
8275 postRender: function () {
8276 var self = this;
8277 self.items().each(function (ctrl) {
8278 ctrl.classes.add('toolbar-item');
8279 });
8280 return self._super();
8281 }
8282 });
8283
8284 var MenuBar = Toolbar$1.extend({
8285 Defaults: {
8286 role: 'menubar',
8287 containerCls: 'menubar',
8288 ariaRoot: true,
8289 defaults: { type: 'menubutton' }
8290 }
8291 });
8292
8293 function isChildOf$1(node, parent) {
8294 while (node) {
8295 if (parent === node) {
8296 return true;
8297 }
8298 node = node.parentNode;
8299 }
8300 return false;
8301 }
8302 var MenuButton = Button.extend({
8303 init: function (settings) {
8304 var self = this;
8305 self._renderOpen = true;
8306 self._super(settings);
8307 settings = self.settings;
8308 self.classes.add('menubtn');
8309 if (settings.fixedWidth) {
8310 self.classes.add('fixed-width');
8311 }
8312 self.aria('haspopup', true);
8313 self.state.set('menu', settings.menu || self.render());
8314 },
8315 showMenu: function (toggle) {
8316 var self = this;
8317 var menu;
8318 if (self.menu && self.menu.visible() && toggle !== false) {
8319 return self.hideMenu();
8320 }
8321 if (!self.menu) {
8322 menu = self.state.get('menu') || [];
8323 self.classes.add('opened');
8324 if (menu.length) {
8325 menu = {
8326 type: 'menu',
8327 animate: true,
8328 items: menu
8329 };
8330 } else {
8331 menu.type = menu.type || 'menu';
8332 menu.animate = true;
8333 }
8334 if (!menu.renderTo) {
8335 self.menu = global$4.create(menu).parent(self).renderTo();
8336 } else {
8337 self.menu = menu.parent(self).show().renderTo();
8338 }
8339 self.fire('createmenu');
8340 self.menu.reflow();
8341 self.menu.on('cancel', function (e) {
8342 if (e.control.parent() === self.menu) {
8343 e.stopPropagation();
8344 self.focus();
8345 self.hideMenu();
8346 }
8347 });
8348 self.menu.on('select', function () {
8349 self.focus();
8350 });
8351 self.menu.on('show hide', function (e) {
8352 if (e.type === 'hide' && e.control.parent() === self) {
8353 self.classes.remove('opened-under');
8354 }
8355 if (e.control === self.menu) {
8356 self.activeMenu(e.type === 'show');
8357 self.classes.toggle('opened', e.type === 'show');
8358 }
8359 self.aria('expanded', e.type === 'show');
8360 }).fire('show');
8361 }
8362 self.menu.show();
8363 self.menu.layoutRect({ w: self.layoutRect().w });
8364 self.menu.repaint();
8365 self.menu.moveRel(self.getEl(), self.isRtl() ? [
8366 'br-tr',
8367 'tr-br'
8368 ] : [
8369 'bl-tl',
8370 'tl-bl'
8371 ]);
8372 var menuLayoutRect = self.menu.layoutRect();
8373 var selfBottom = self.$el.offset().top + self.layoutRect().h;
8374 if (selfBottom > menuLayoutRect.y && selfBottom < menuLayoutRect.y + menuLayoutRect.h) {
8375 self.classes.add('opened-under');
8376 }
8377 self.fire('showmenu');
8378 },
8379 hideMenu: function () {
8380 var self = this;
8381 if (self.menu) {
8382 self.menu.items().each(function (item) {
8383 if (item.hideMenu) {
8384 item.hideMenu();
8385 }
8386 });
8387 self.menu.hide();
8388 }
8389 },
8390 activeMenu: function (state) {
8391 this.classes.toggle('active', state);
8392 },
8393 renderHtml: function () {
8394 var self = this, id = self._id, prefix = self.classPrefix;
8395 var icon = self.settings.icon, image;
8396 var text = self.state.get('text');
8397 var textHtml = '';
8398 image = self.settings.image;
8399 if (image) {
8400 icon = 'none';
8401 if (typeof image !== 'string') {
8402 image = domGlobals.window.getSelection ? image[0] : image[1];
8403 }
8404 image = ' style="background-image: url(\'' + image + '\')"';
8405 } else {
8406 image = '';
8407 }
8408 if (text) {
8409 self.classes.add('btn-has-text');
8410 textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
8411 }
8412 icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
8413 self.aria('role', self.parent() instanceof MenuBar ? 'menuitem' : 'button');
8414 return '<div id="' + id + '" class="' + self.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>';
8415 },
8416 postRender: function () {
8417 var self = this;
8418 self.on('click', function (e) {
8419 if (e.control === self && isChildOf$1(e.target, self.getEl())) {
8420 self.focus();
8421 self.showMenu(!e.aria);
8422 if (e.aria) {
8423 self.menu.items().filter(':visible')[0].focus();
8424 }
8425 }
8426 });
8427 self.on('mouseenter', function (e) {
8428 var overCtrl = e.control;
8429 var parent = self.parent();
8430 var hasVisibleSiblingMenu;
8431 if (overCtrl && parent && overCtrl instanceof MenuButton && overCtrl.parent() === parent) {
8432 parent.items().filter('MenuButton').each(function (ctrl) {
8433 if (ctrl.hideMenu && ctrl !== overCtrl) {
8434 if (ctrl.menu && ctrl.menu.visible()) {
8435 hasVisibleSiblingMenu = true;
8436 }
8437 ctrl.hideMenu();
8438 }
8439 });
8440 if (hasVisibleSiblingMenu) {
8441 overCtrl.focus();
8442 overCtrl.showMenu();
8443 }
8444 }
8445 });
8446 return self._super();
8447 },
8448 bindStates: function () {
8449 var self = this;
8450 self.state.on('change:menu', function () {
8451 if (self.menu) {
8452 self.menu.remove();
8453 }
8454 self.menu = null;
8455 });
8456 return self._super();
8457 },
8458 remove: function () {
8459 this._super();
8460 if (this.menu) {
8461 this.menu.remove();
8462 }
8463 }
8464 });
8465
8466 var Menu = FloatPanel.extend({
8467 Defaults: {
8468 defaultType: 'menuitem',
8469 border: 1,
8470 layout: 'stack',
8471 role: 'application',
8472 bodyRole: 'menu',
8473 ariaRoot: true
8474 },
8475 init: function (settings) {
8476 var self = this;
8477 settings.autohide = true;
8478 settings.constrainToViewport = true;
8479 if (typeof settings.items === 'function') {
8480 settings.itemsFactory = settings.items;
8481 settings.items = [];
8482 }
8483 if (settings.itemDefaults) {
8484 var items = settings.items;
8485 var i = items.length;
8486 while (i--) {
8487 items[i] = global$2.extend({}, settings.itemDefaults, items[i]);
8488 }
8489 }
8490 self._super(settings);
8491 self.classes.add('menu');
8492 if (settings.animate && global$8.ie !== 11) {
8493 self.classes.add('animate');
8494 }
8495 },
8496 repaint: function () {
8497 this.classes.toggle('menu-align', true);
8498 this._super();
8499 this.getEl().style.height = '';
8500 this.getEl('body').style.height = '';
8501 return this;
8502 },
8503 cancel: function () {
8504 var self = this;
8505 self.hideAll();
8506 self.fire('select');
8507 },
8508 load: function () {
8509 var self = this;
8510 var time, factory;
8511 function hideThrobber() {
8512 if (self.throbber) {
8513 self.throbber.hide();
8514 self.throbber = null;
8515 }
8516 }
8517 factory = self.settings.itemsFactory;
8518 if (!factory) {
8519 return;
8520 }
8521 if (!self.throbber) {
8522 self.throbber = new Throbber(self.getEl('body'), true);
8523 if (self.items().length === 0) {
8524 self.throbber.show();
8525 self.fire('loading');
8526 } else {
8527 self.throbber.show(100, function () {
8528 self.items().remove();
8529 self.fire('loading');
8530 });
8531 }
8532 self.on('hide close', hideThrobber);
8533 }
8534 self.requestTime = time = new Date().getTime();
8535 self.settings.itemsFactory(function (items) {
8536 if (items.length === 0) {
8537 self.hide();
8538 return;
8539 }
8540 if (self.requestTime !== time) {
8541 return;
8542 }
8543 self.getEl().style.width = '';
8544 self.getEl('body').style.width = '';
8545 hideThrobber();
8546 self.items().remove();
8547 self.getEl('body').innerHTML = '';
8548 self.add(items);
8549 self.renderNew();
8550 self.fire('loaded');
8551 });
8552 },
8553 hideAll: function () {
8554 var self = this;
8555 this.find('menuitem').exec('hideMenu');
8556 return self._super();
8557 },
8558 preRender: function () {
8559 var self = this;
8560 self.items().each(function (ctrl) {
8561 var settings = ctrl.settings;
8562 if (settings.icon || settings.image || settings.selectable) {
8563 self._hasIcons = true;
8564 return false;
8565 }
8566 });
8567 if (self.settings.itemsFactory) {
8568 self.on('postrender', function () {
8569 if (self.settings.itemsFactory) {
8570 self.load();
8571 }
8572 });
8573 }
8574 self.on('show hide', function (e) {
8575 if (e.control === self) {
8576 if (e.type === 'show') {
8577 global$7.setTimeout(function () {
8578 self.classes.add('in');
8579 }, 0);
8580 } else {
8581 self.classes.remove('in');
8582 }
8583 }
8584 });
8585 return self._super();
8586 }
8587 });
8588
8589 var ListBox = MenuButton.extend({
8590 init: function (settings) {
8591 var self = this;
8592 var values, selected, selectedText, lastItemCtrl;
8593 function setSelected(menuValues) {
8594 for (var i = 0; i < menuValues.length; i++) {
8595 selected = menuValues[i].selected || settings.value === menuValues[i].value;
8596 if (selected) {
8597 selectedText = selectedText || menuValues[i].text;
8598 self.state.set('value', menuValues[i].value);
8599 return true;
8600 }
8601 if (menuValues[i].menu) {
8602 if (setSelected(menuValues[i].menu)) {
8603 return true;
8604 }
8605 }
8606 }
8607 }
8608 self._super(settings);
8609 settings = self.settings;
8610 self._values = values = settings.values;
8611 if (values) {
8612 if (typeof settings.value !== 'undefined') {
8613 setSelected(values);
8614 }
8615 if (!selected && values.length > 0) {
8616 selectedText = values[0].text;
8617 self.state.set('value', values[0].value);
8618 }
8619 self.state.set('menu', values);
8620 }
8621 self.state.set('text', settings.text || selectedText);
8622 self.classes.add('listbox');
8623 self.on('select', function (e) {
8624 var ctrl = e.control;
8625 if (lastItemCtrl) {
8626 e.lastControl = lastItemCtrl;
8627 }
8628 if (settings.multiple) {
8629 ctrl.active(!ctrl.active());
8630 } else {
8631 self.value(e.control.value());
8632 }
8633 lastItemCtrl = ctrl;
8634 });
8635 },
8636 value: function (value) {
8637 if (arguments.length === 0) {
8638 return this.state.get('value');
8639 }
8640 if (typeof value === 'undefined') {
8641 return this;
8642 }
8643 function valueExists(values) {
8644 return exists(values, function (a) {
8645 return a.menu ? valueExists(a.menu) : a.value === value;
8646 });
8647 }
8648 if (this.settings.values) {
8649 if (valueExists(this.settings.values)) {
8650 this.state.set('value', value);
8651 } else if (value === null) {
8652 this.state.set('value', null);
8653 }
8654 } else {
8655 this.state.set('value', value);
8656 }
8657 return this;
8658 },
8659 bindStates: function () {
8660 var self = this;
8661 function activateMenuItemsByValue(menu, value) {
8662 if (menu instanceof Menu) {
8663 menu.items().each(function (ctrl) {
8664 if (!ctrl.hasMenus()) {
8665 ctrl.active(ctrl.value() === value);
8666 }
8667 });
8668 }
8669 }
8670 function getSelectedItem(menuValues, value) {
8671 var selectedItem;
8672 if (!menuValues) {
8673 return;
8674 }
8675 for (var i = 0; i < menuValues.length; i++) {
8676 if (menuValues[i].value === value) {
8677 return menuValues[i];
8678 }
8679 if (menuValues[i].menu) {
8680 selectedItem = getSelectedItem(menuValues[i].menu, value);
8681 if (selectedItem) {
8682 return selectedItem;
8683 }
8684 }
8685 }
8686 }
8687 self.on('show', function (e) {
8688 activateMenuItemsByValue(e.control, self.value());
8689 });
8690 self.state.on('change:value', function (e) {
8691 var selectedItem = getSelectedItem(self.state.get('menu'), e.value);
8692 if (selectedItem) {
8693 self.text(selectedItem.text);
8694 } else {
8695 self.text(self.settings.text);
8696 }
8697 });
8698 return self._super();
8699 }
8700 });
8701
8702 var toggleTextStyle = function (ctrl, state) {
8703 var textStyle = ctrl._textStyle;
8704 if (textStyle) {
8705 var textElm = ctrl.getEl('text');
8706 textElm.setAttribute('style', textStyle);
8707 if (state) {
8708 textElm.style.color = '';
8709 textElm.style.backgroundColor = '';
8710 }
8711 }
8712 };
8713 var MenuItem = Widget.extend({
8714 Defaults: {
8715 border: 0,
8716 role: 'menuitem'
8717 },
8718 init: function (settings) {
8719 var self = this;
8720 var text;
8721 self._super(settings);
8722 settings = self.settings;
8723 self.classes.add('menu-item');
8724 if (settings.menu) {
8725 self.classes.add('menu-item-expand');
8726 }
8727 if (settings.preview) {
8728 self.classes.add('menu-item-preview');
8729 }
8730 text = self.state.get('text');
8731 if (text === '-' || text === '|') {
8732 self.classes.add('menu-item-sep');
8733 self.aria('role', 'separator');
8734 self.state.set('text', '-');
8735 }
8736 if (settings.selectable) {
8737 self.aria('role', 'menuitemcheckbox');
8738 self.classes.add('menu-item-checkbox');
8739 settings.icon = 'selected';
8740 }
8741 if (!settings.preview && !settings.selectable) {
8742 self.classes.add('menu-item-normal');
8743 }
8744 self.on('mousedown', function (e) {
8745 e.preventDefault();
8746 });
8747 if (settings.menu && !settings.ariaHideMenu) {
8748 self.aria('haspopup', true);
8749 }
8750 },
8751 hasMenus: function () {
8752 return !!this.settings.menu;
8753 },
8754 showMenu: function () {
8755 var self = this;
8756 var settings = self.settings;
8757 var menu;
8758 var parent = self.parent();
8759 parent.items().each(function (ctrl) {
8760 if (ctrl !== self) {
8761 ctrl.hideMenu();
8762 }
8763 });
8764 if (settings.menu) {
8765 menu = self.menu;
8766 if (!menu) {
8767 menu = settings.menu;
8768 if (menu.length) {
8769 menu = {
8770 type: 'menu',
8771 items: menu
8772 };
8773 } else {
8774 menu.type = menu.type || 'menu';
8775 }
8776 if (parent.settings.itemDefaults) {
8777 menu.itemDefaults = parent.settings.itemDefaults;
8778 }
8779 menu = self.menu = global$4.create(menu).parent(self).renderTo();
8780 menu.reflow();
8781 menu.on('cancel', function (e) {
8782 e.stopPropagation();
8783 self.focus();
8784 menu.hide();
8785 });
8786 menu.on('show hide', function (e) {
8787 if (e.control.items) {
8788 e.control.items().each(function (ctrl) {
8789 ctrl.active(ctrl.settings.selected);
8790 });
8791 }
8792 }).fire('show');
8793 menu.on('hide', function (e) {
8794 if (e.control === menu) {
8795 self.classes.remove('selected');
8796 }
8797 });
8798 menu.submenu = true;
8799 } else {
8800 menu.show();
8801 }
8802 menu._parentMenu = parent;
8803 menu.classes.add('menu-sub');
8804 var rel = menu.testMoveRel(self.getEl(), self.isRtl() ? [
8805 'tl-tr',
8806 'bl-br',
8807 'tr-tl',
8808 'br-bl'
8809 ] : [
8810 'tr-tl',
8811 'br-bl',
8812 'tl-tr',
8813 'bl-br'
8814 ]);
8815 menu.moveRel(self.getEl(), rel);
8816 menu.rel = rel;
8817 rel = 'menu-sub-' + rel;
8818 menu.classes.remove(menu._lastRel).add(rel);
8819 menu._lastRel = rel;
8820 self.classes.add('selected');
8821 self.aria('expanded', true);
8822 }
8823 },
8824 hideMenu: function () {
8825 var self = this;
8826 if (self.menu) {
8827 self.menu.items().each(function (item) {
8828 if (item.hideMenu) {
8829 item.hideMenu();
8830 }
8831 });
8832 self.menu.hide();
8833 self.aria('expanded', false);
8834 }
8835 return self;
8836 },
8837 renderHtml: function () {
8838 var self = this;
8839 var id = self._id;
8840 var settings = self.settings;
8841 var prefix = self.classPrefix;
8842 var text = self.state.get('text');
8843 var icon = self.settings.icon, image = '', shortcut = settings.shortcut;
8844 var url = self.encode(settings.url), iconHtml = '';
8845 function convertShortcut(shortcut) {
8846 var i, value, replace = {};
8847 if (global$8.mac) {
8848 replace = {
8849 alt: '⌥',
8850 ctrl: '⌘',
8851 shift: '⇧',
8852 meta: '⌘'
8853 };
8854 } else {
8855 replace = { meta: 'Ctrl' };
8856 }
8857 shortcut = shortcut.split('+');
8858 for (i = 0; i < shortcut.length; i++) {
8859 value = replace[shortcut[i].toLowerCase()];
8860 if (value) {
8861 shortcut[i] = value;
8862 }
8863 }
8864 return shortcut.join('+');
8865 }
8866 function escapeRegExp(str) {
8867 return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
8868 }
8869 function markMatches(text) {
8870 var match = settings.match || '';
8871 return match ? text.replace(new RegExp(escapeRegExp(match), 'gi'), function (match) {
8872 return '!mce~match[' + match + ']mce~match!';
8873 }) : text;
8874 }
8875 function boldMatches(text) {
8876 return text.replace(new RegExp(escapeRegExp('!mce~match['), 'g'), '<b>').replace(new RegExp(escapeRegExp(']mce~match!'), 'g'), '</b>');
8877 }
8878 if (icon) {
8879 self.parent().classes.add('menu-has-icons');
8880 }
8881 if (settings.image) {
8882 image = ' style="background-image: url(\'' + settings.image + '\')"';
8883 }
8884 if (shortcut) {
8885 shortcut = convertShortcut(shortcut);
8886 }
8887 icon = prefix + 'ico ' + prefix + 'i-' + (self.settings.icon || 'none');
8888 iconHtml = text !== '-' ? '<i class="' + icon + '"' + image + '></i>\xA0' : '';
8889 text = boldMatches(self.encode(markMatches(text)));
8890 url = boldMatches(self.encode(markMatches(url)));
8891 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>';
8892 },
8893 postRender: function () {
8894 var self = this, settings = self.settings;
8895 var textStyle = settings.textStyle;
8896 if (typeof textStyle === 'function') {
8897 textStyle = textStyle.call(this);
8898 }
8899 if (textStyle) {
8900 var textElm = self.getEl('text');
8901 if (textElm) {
8902 textElm.setAttribute('style', textStyle);
8903 self._textStyle = textStyle;
8904 }
8905 }
8906 self.on('mouseenter click', function (e) {
8907 if (e.control === self) {
8908 if (!settings.menu && e.type === 'click') {
8909 self.fire('select');
8910 global$7.requestAnimationFrame(function () {
8911 self.parent().hideAll();
8912 });
8913 } else {
8914 self.showMenu();
8915 if (e.aria) {
8916 self.menu.focus(true);
8917 }
8918 }
8919 }
8920 });
8921 self._super();
8922 return self;
8923 },
8924 hover: function () {
8925 var self = this;
8926 self.parent().items().each(function (ctrl) {
8927 ctrl.classes.remove('selected');
8928 });
8929 self.classes.toggle('selected', true);
8930 return self;
8931 },
8932 active: function (state) {
8933 toggleTextStyle(this, state);
8934 if (typeof state !== 'undefined') {
8935 this.aria('checked', state);
8936 }
8937 return this._super(state);
8938 },
8939 remove: function () {
8940 this._super();
8941 if (this.menu) {
8942 this.menu.remove();
8943 }
8944 }
8945 });
8946
8947 var Radio = Checkbox.extend({
8948 Defaults: {
8949 classes: 'radio',
8950 role: 'radio'
8951 }
8952 });
8953
8954 var ResizeHandle = Widget.extend({
8955 renderHtml: function () {
8956 var self = this, prefix = self.classPrefix;
8957 self.classes.add('resizehandle');
8958 if (self.settings.direction === 'both') {
8959 self.classes.add('resizehandle-both');
8960 }
8961 self.canFocus = false;
8962 return '<div id="' + self._id + '" class="' + self.classes + '">' + '<i class="' + prefix + 'ico ' + prefix + 'i-resize"></i>' + '</div>';
8963 },
8964 postRender: function () {
8965 var self = this;
8966 self._super();
8967 self.resizeDragHelper = new DragHelper(this._id, {
8968 start: function () {
8969 self.fire('ResizeStart');
8970 },
8971 drag: function (e) {
8972 if (self.settings.direction !== 'both') {
8973 e.deltaX = 0;
8974 }
8975 self.fire('Resize', e);
8976 },
8977 stop: function () {
8978 self.fire('ResizeEnd');
8979 }
8980 });
8981 },
8982 remove: function () {
8983 if (this.resizeDragHelper) {
8984 this.resizeDragHelper.destroy();
8985 }
8986 return this._super();
8987 }
8988 });
8989
8990 function createOptions(options) {
8991 var strOptions = '';
8992 if (options) {
8993 for (var i = 0; i < options.length; i++) {
8994 strOptions += '<option value="' + options[i] + '">' + options[i] + '</option>';
8995 }
8996 }
8997 return strOptions;
8998 }
8999 var SelectBox = Widget.extend({
9000 Defaults: {
9001 classes: 'selectbox',
9002 role: 'selectbox',
9003 options: []
9004 },
9005 init: function (settings) {
9006 var self = this;
9007 self._super(settings);
9008 if (self.settings.size) {
9009 self.size = self.settings.size;
9010 }
9011 if (self.settings.options) {
9012 self._options = self.settings.options;
9013 }
9014 self.on('keydown', function (e) {
9015 var rootControl;
9016 if (e.keyCode === 13) {
9017 e.preventDefault();
9018 self.parents().reverse().each(function (ctrl) {
9019 if (ctrl.toJSON) {
9020 rootControl = ctrl;
9021 return false;
9022 }
9023 });
9024 self.fire('submit', { data: rootControl.toJSON() });
9025 }
9026 });
9027 },
9028 options: function (state) {
9029 if (!arguments.length) {
9030 return this.state.get('options');
9031 }
9032 this.state.set('options', state);
9033 return this;
9034 },
9035 renderHtml: function () {
9036 var self = this;
9037 var options, size = '';
9038 options = createOptions(self._options);
9039 if (self.size) {
9040 size = ' size = "' + self.size + '"';
9041 }
9042 return '<select id="' + self._id + '" class="' + self.classes + '"' + size + '>' + options + '</select>';
9043 },
9044 bindStates: function () {
9045 var self = this;
9046 self.state.on('change:options', function (e) {
9047 self.getEl().innerHTML = createOptions(e.value);
9048 });
9049 return self._super();
9050 }
9051 });
9052
9053 function constrain(value, minVal, maxVal) {
9054 if (value < minVal) {
9055 value = minVal;
9056 }
9057 if (value > maxVal) {
9058 value = maxVal;
9059 }
9060 return value;
9061 }
9062 function setAriaProp(el, name, value) {
9063 el.setAttribute('aria-' + name, value);
9064 }
9065 function updateSliderHandle(ctrl, value) {
9066 var maxHandlePos, shortSizeName, sizeName, stylePosName, styleValue, handleEl;
9067 if (ctrl.settings.orientation === 'v') {
9068 stylePosName = 'top';
9069 sizeName = 'height';
9070 shortSizeName = 'h';
9071 } else {
9072 stylePosName = 'left';
9073 sizeName = 'width';
9074 shortSizeName = 'w';
9075 }
9076 handleEl = ctrl.getEl('handle');
9077 maxHandlePos = (ctrl.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
9078 styleValue = maxHandlePos * ((value - ctrl._minValue) / (ctrl._maxValue - ctrl._minValue)) + 'px';
9079 handleEl.style[stylePosName] = styleValue;
9080 handleEl.style.height = ctrl.layoutRect().h + 'px';
9081 setAriaProp(handleEl, 'valuenow', value);
9082 setAriaProp(handleEl, 'valuetext', '' + ctrl.settings.previewFilter(value));
9083 setAriaProp(handleEl, 'valuemin', ctrl._minValue);
9084 setAriaProp(handleEl, 'valuemax', ctrl._maxValue);
9085 }
9086 var Slider = Widget.extend({
9087 init: function (settings) {
9088 var self = this;
9089 if (!settings.previewFilter) {
9090 settings.previewFilter = function (value) {
9091 return Math.round(value * 100) / 100;
9092 };
9093 }
9094 self._super(settings);
9095 self.classes.add('slider');
9096 if (settings.orientation === 'v') {
9097 self.classes.add('vertical');
9098 }
9099 self._minValue = isNumber(settings.minValue) ? settings.minValue : 0;
9100 self._maxValue = isNumber(settings.maxValue) ? settings.maxValue : 100;
9101 self._initValue = self.state.get('value');
9102 },
9103 renderHtml: function () {
9104 var self = this, id = self._id, prefix = self.classPrefix;
9105 return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-handle" class="' + prefix + 'slider-handle" role="slider" tabindex="-1"></div>' + '</div>';
9106 },
9107 reset: function () {
9108 this.value(this._initValue).repaint();
9109 },
9110 postRender: function () {
9111 var self = this;
9112 var minValue, maxValue, screenCordName, stylePosName, sizeName, shortSizeName;
9113 function toFraction(min, max, val) {
9114 return (val + min) / (max - min);
9115 }
9116 function fromFraction(min, max, val) {
9117 return val * (max - min) - min;
9118 }
9119 function handleKeyboard(minValue, maxValue) {
9120 function alter(delta) {
9121 var value;
9122 value = self.value();
9123 value = fromFraction(minValue, maxValue, toFraction(minValue, maxValue, value) + delta * 0.05);
9124 value = constrain(value, minValue, maxValue);
9125 self.value(value);
9126 self.fire('dragstart', { value: value });
9127 self.fire('drag', { value: value });
9128 self.fire('dragend', { value: value });
9129 }
9130 self.on('keydown', function (e) {
9131 switch (e.keyCode) {
9132 case 37:
9133 case 38:
9134 alter(-1);
9135 break;
9136 case 39:
9137 case 40:
9138 alter(1);
9139 break;
9140 }
9141 });
9142 }
9143 function handleDrag(minValue, maxValue, handleEl) {
9144 var startPos, startHandlePos, maxHandlePos, handlePos, value;
9145 self._dragHelper = new DragHelper(self._id, {
9146 handle: self._id + '-handle',
9147 start: function (e) {
9148 startPos = e[screenCordName];
9149 startHandlePos = parseInt(self.getEl('handle').style[stylePosName], 10);
9150 maxHandlePos = (self.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
9151 self.fire('dragstart', { value: value });
9152 },
9153 drag: function (e) {
9154 var delta = e[screenCordName] - startPos;
9155 handlePos = constrain(startHandlePos + delta, 0, maxHandlePos);
9156 handleEl.style[stylePosName] = handlePos + 'px';
9157 value = minValue + handlePos / maxHandlePos * (maxValue - minValue);
9158 self.value(value);
9159 self.tooltip().text('' + self.settings.previewFilter(value)).show().moveRel(handleEl, 'bc tc');
9160 self.fire('drag', { value: value });
9161 },
9162 stop: function () {
9163 self.tooltip().hide();
9164 self.fire('dragend', { value: value });
9165 }
9166 });
9167 }
9168 minValue = self._minValue;
9169 maxValue = self._maxValue;
9170 if (self.settings.orientation === 'v') {
9171 screenCordName = 'screenY';
9172 stylePosName = 'top';
9173 sizeName = 'height';
9174 shortSizeName = 'h';
9175 } else {
9176 screenCordName = 'screenX';
9177 stylePosName = 'left';
9178 sizeName = 'width';
9179 shortSizeName = 'w';
9180 }
9181 self._super();
9182 handleKeyboard(minValue, maxValue);
9183 handleDrag(minValue, maxValue, self.getEl('handle'));
9184 },
9185 repaint: function () {
9186 this._super();
9187 updateSliderHandle(this, this.value());
9188 },
9189 bindStates: function () {
9190 var self = this;
9191 self.state.on('change:value', function (e) {
9192 updateSliderHandle(self, e.value);
9193 });
9194 return self._super();
9195 }
9196 });
9197
9198 var Spacer = Widget.extend({
9199 renderHtml: function () {
9200 var self = this;
9201 self.classes.add('spacer');
9202 self.canFocus = false;
9203 return '<div id="' + self._id + '" class="' + self.classes + '"></div>';
9204 }
9205 });
9206
9207 var SplitButton = MenuButton.extend({
9208 Defaults: {
9209 classes: 'widget btn splitbtn',
9210 role: 'button'
9211 },
9212 repaint: function () {
9213 var self = this;
9214 var elm = self.getEl();
9215 var rect = self.layoutRect();
9216 var mainButtonElm, menuButtonElm;
9217 self._super();
9218 mainButtonElm = elm.firstChild;
9219 menuButtonElm = elm.lastChild;
9220 global$9(mainButtonElm).css({
9221 width: rect.w - funcs.getSize(menuButtonElm).width,
9222 height: rect.h - 2
9223 });
9224 global$9(menuButtonElm).css({ height: rect.h - 2 });
9225 return self;
9226 },
9227 activeMenu: function (state) {
9228 var self = this;
9229 global$9(self.getEl().lastChild).toggleClass(self.classPrefix + 'active', state);
9230 },
9231 renderHtml: function () {
9232 var self = this;
9233 var id = self._id;
9234 var prefix = self.classPrefix;
9235 var image;
9236 var icon = self.state.get('icon');
9237 var text = self.state.get('text');
9238 var settings = self.settings;
9239 var textHtml = '', ariaPressed;
9240 image = settings.image;
9241 if (image) {
9242 icon = 'none';
9243 if (typeof image !== 'string') {
9244 image = domGlobals.window.getSelection ? image[0] : image[1];
9245 }
9246 image = ' style="background-image: url(\'' + image + '\')"';
9247 } else {
9248 image = '';
9249 }
9250 icon = settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
9251 if (text) {
9252 self.classes.add('btn-has-text');
9253 textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
9254 }
9255 ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
9256 return '<div id="' + id + '" class="' + self.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._menuBtnText ? (icon ? '\xA0' : '') + self._menuBtnText : '') + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
9257 },
9258 postRender: function () {
9259 var self = this, onClickHandler = self.settings.onclick;
9260 self.on('click', function (e) {
9261 var node = e.target;
9262 if (e.control === this) {
9263 while (node) {
9264 if (e.aria && e.aria.key !== 'down' || node.nodeName === 'BUTTON' && node.className.indexOf('open') === -1) {
9265 e.stopImmediatePropagation();
9266 if (onClickHandler) {
9267 onClickHandler.call(this, e);
9268 }
9269 return;
9270 }
9271 node = node.parentNode;
9272 }
9273 }
9274 });
9275 delete self.settings.onclick;
9276 return self._super();
9277 }
9278 });
9279
9280 var StackLayout = FlowLayout.extend({
9281 Defaults: {
9282 containerClass: 'stack-layout',
9283 controlClass: 'stack-layout-item',
9284 endClass: 'break'
9285 },
9286 isNative: function () {
9287 return true;
9288 }
9289 });
9290
9291 var TabPanel = Panel.extend({
9292 Defaults: {
9293 layout: 'absolute',
9294 defaults: { type: 'panel' }
9295 },
9296 activateTab: function (idx) {
9297 var activeTabElm;
9298 if (this.activeTabId) {
9299 activeTabElm = this.getEl(this.activeTabId);
9300 global$9(activeTabElm).removeClass(this.classPrefix + 'active');
9301 activeTabElm.setAttribute('aria-selected', 'false');
9302 }
9303 this.activeTabId = 't' + idx;
9304 activeTabElm = this.getEl('t' + idx);
9305 activeTabElm.setAttribute('aria-selected', 'true');
9306 global$9(activeTabElm).addClass(this.classPrefix + 'active');
9307 this.items()[idx].show().fire('showtab');
9308 this.reflow();
9309 this.items().each(function (item, i) {
9310 if (idx !== i) {
9311 item.hide();
9312 }
9313 });
9314 },
9315 renderHtml: function () {
9316 var self = this;
9317 var layout = self._layout;
9318 var tabsHtml = '';
9319 var prefix = self.classPrefix;
9320 self.preRender();
9321 layout.preRender(self);
9322 self.items().each(function (ctrl, i) {
9323 var id = self._id + '-t' + i;
9324 ctrl.aria('role', 'tabpanel');
9325 ctrl.aria('labelledby', id);
9326 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>';
9327 });
9328 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>';
9329 },
9330 postRender: function () {
9331 var self = this;
9332 self._super();
9333 self.settings.activeTab = self.settings.activeTab || 0;
9334 self.activateTab(self.settings.activeTab);
9335 this.on('click', function (e) {
9336 var targetParent = e.target.parentNode;
9337 if (targetParent && targetParent.id === self._id + '-head') {
9338 var i = targetParent.childNodes.length;
9339 while (i--) {
9340 if (targetParent.childNodes[i] === e.target) {
9341 self.activateTab(i);
9342 }
9343 }
9344 }
9345 });
9346 },
9347 initLayoutRect: function () {
9348 var self = this;
9349 var rect, minW, minH;
9350 minW = funcs.getSize(self.getEl('head')).width;
9351 minW = minW < 0 ? 0 : minW;
9352 minH = 0;
9353 self.items().each(function (item) {
9354 minW = Math.max(minW, item.layoutRect().minW);
9355 minH = Math.max(minH, item.layoutRect().minH);
9356 });
9357 self.items().each(function (ctrl) {
9358 ctrl.settings.x = 0;
9359 ctrl.settings.y = 0;
9360 ctrl.settings.w = minW;
9361 ctrl.settings.h = minH;
9362 ctrl.layoutRect({
9363 x: 0,
9364 y: 0,
9365 w: minW,
9366 h: minH
9367 });
9368 });
9369 var headH = funcs.getSize(self.getEl('head')).height;
9370 self.settings.minWidth = minW;
9371 self.settings.minHeight = minH + headH;
9372 rect = self._super();
9373 rect.deltaH += headH;
9374 rect.innerH = rect.h - rect.deltaH;
9375 return rect;
9376 }
9377 });
9378
9379 var TextBox = Widget.extend({
9380 init: function (settings) {
9381 var self = this;
9382 self._super(settings);
9383 self.classes.add('textbox');
9384 if (settings.multiline) {
9385 self.classes.add('multiline');
9386 } else {
9387 self.on('keydown', function (e) {
9388 var rootControl;
9389 if (e.keyCode === 13) {
9390 e.preventDefault();
9391 self.parents().reverse().each(function (ctrl) {
9392 if (ctrl.toJSON) {
9393 rootControl = ctrl;
9394 return false;
9395 }
9396 });
9397 self.fire('submit', { data: rootControl.toJSON() });
9398 }
9399 });
9400 self.on('keyup', function (e) {
9401 self.state.set('value', e.target.value);
9402 });
9403 }
9404 },
9405 repaint: function () {
9406 var self = this;
9407 var style, rect, borderBox, borderW, borderH = 0, lastRepaintRect;
9408 style = self.getEl().style;
9409 rect = self._layoutRect;
9410 lastRepaintRect = self._lastRepaintRect || {};
9411 var doc = domGlobals.document;
9412 if (!self.settings.multiline && doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
9413 style.lineHeight = rect.h - borderH + 'px';
9414 }
9415 borderBox = self.borderBox;
9416 borderW = borderBox.left + borderBox.right + 8;
9417 borderH = borderBox.top + borderBox.bottom + (self.settings.multiline ? 8 : 0);
9418 if (rect.x !== lastRepaintRect.x) {
9419 style.left = rect.x + 'px';
9420 lastRepaintRect.x = rect.x;
9421 }
9422 if (rect.y !== lastRepaintRect.y) {
9423 style.top = rect.y + 'px';
9424 lastRepaintRect.y = rect.y;
9425 }
9426 if (rect.w !== lastRepaintRect.w) {
9427 style.width = rect.w - borderW + 'px';
9428 lastRepaintRect.w = rect.w;
9429 }
9430 if (rect.h !== lastRepaintRect.h) {
9431 style.height = rect.h - borderH + 'px';
9432 lastRepaintRect.h = rect.h;
9433 }
9434 self._lastRepaintRect = lastRepaintRect;
9435 self.fire('repaint', {}, false);
9436 return self;
9437 },
9438 renderHtml: function () {
9439 var self = this;
9440 var settings = self.settings;
9441 var attrs, elm;
9442 attrs = {
9443 id: self._id,
9444 hidefocus: '1'
9445 };
9446 global$2.each([
9447 'rows',
9448 'spellcheck',
9449 'maxLength',
9450 'size',
9451 'readonly',
9452 'min',
9453 'max',
9454 'step',
9455 'list',
9456 'pattern',
9457 'placeholder',
9458 'required',
9459 'multiple'
9460 ], function (name) {
9461 attrs[name] = settings[name];
9462 });
9463 if (self.disabled()) {
9464 attrs.disabled = 'disabled';
9465 }
9466 if (settings.subtype) {
9467 attrs.type = settings.subtype;
9468 }
9469 elm = funcs.create(settings.multiline ? 'textarea' : 'input', attrs);
9470 elm.value = self.state.get('value');
9471 elm.className = self.classes.toString();
9472 return elm.outerHTML;
9473 },
9474 value: function (value) {
9475 if (arguments.length) {
9476 this.state.set('value', value);
9477 return this;
9478 }
9479 if (this.state.get('rendered')) {
9480 this.state.set('value', this.getEl().value);
9481 }
9482 return this.state.get('value');
9483 },
9484 postRender: function () {
9485 var self = this;
9486 self.getEl().value = self.state.get('value');
9487 self._super();
9488 self.$el.on('change', function (e) {
9489 self.state.set('value', e.target.value);
9490 self.fire('change', e);
9491 });
9492 },
9493 bindStates: function () {
9494 var self = this;
9495 self.state.on('change:value', function (e) {
9496 if (self.getEl().value !== e.value) {
9497 self.getEl().value = e.value;
9498 }
9499 });
9500 self.state.on('change:disabled', function (e) {
9501 self.getEl().disabled = e.value;
9502 });
9503 return self._super();
9504 },
9505 remove: function () {
9506 this.$el.off();
9507 this._super();
9508 }
9509 });
9510
9511 var getApi = function () {
9512 return {
9513 Selector: Selector,
9514 Collection: Collection$2,
9515 ReflowQueue: ReflowQueue,
9516 Control: Control$1,
9517 Factory: global$4,
9518 KeyboardNavigation: KeyboardNavigation,
9519 Container: Container,
9520 DragHelper: DragHelper,
9521 Scrollable: Scrollable,
9522 Panel: Panel,
9523 Movable: Movable,
9524 Resizable: Resizable,
9525 FloatPanel: FloatPanel,
9526 Window: Window,
9527 MessageBox: MessageBox,
9528 Tooltip: Tooltip,
9529 Widget: Widget,
9530 Progress: Progress,
9531 Notification: Notification,
9532 Layout: Layout,
9533 AbsoluteLayout: AbsoluteLayout,
9534 Button: Button,
9535 ButtonGroup: ButtonGroup,
9536 Checkbox: Checkbox,
9537 ComboBox: ComboBox,
9538 ColorBox: ColorBox,
9539 PanelButton: PanelButton,
9540 ColorButton: ColorButton,
9541 ColorPicker: ColorPicker,
9542 Path: Path,
9543 ElementPath: ElementPath,
9544 FormItem: FormItem,
9545 Form: Form,
9546 FieldSet: FieldSet,
9547 FilePicker: FilePicker,
9548 FitLayout: FitLayout,
9549 FlexLayout: FlexLayout,
9550 FlowLayout: FlowLayout,
9551 FormatControls: FormatControls,
9552 GridLayout: GridLayout,
9553 Iframe: Iframe$1,
9554 InfoBox: InfoBox,
9555 Label: Label,
9556 Toolbar: Toolbar$1,
9557 MenuBar: MenuBar,
9558 MenuButton: MenuButton,
9559 MenuItem: MenuItem,
9560 Throbber: Throbber,
9561 Menu: Menu,
9562 ListBox: ListBox,
9563 Radio: Radio,
9564 ResizeHandle: ResizeHandle,
9565 SelectBox: SelectBox,
9566 Slider: Slider,
9567 Spacer: Spacer,
9568 SplitButton: SplitButton,
9569 StackLayout: StackLayout,
9570 TabPanel: TabPanel,
9571 TextBox: TextBox,
9572 DropZone: DropZone,
9573 BrowseButton: BrowseButton
9574 };
9575 };
9576 var appendTo = function (target) {
9577 if (target.ui) {
9578 global$2.each(getApi(), function (ref, key) {
9579 target.ui[key] = ref;
9580 });
9581 } else {
9582 target.ui = getApi();
9583 }
9584 };
9585 var registerToFactory = function () {
9586 global$2.each(getApi(), function (ref, key) {
9587 global$4.add(key, ref);
9588 });
9589 };
9590 var Api = {
9591 appendTo: appendTo,
9592 registerToFactory: registerToFactory
9593 };
9594
9595 Api.registerToFactory();
9596 Api.appendTo(window.tinymce ? window.tinymce : {});
9597 global.add('modern', function (editor) {
9598 FormatControls.setup(editor);
9599 return ThemeApi.get(editor);
9600 });
9601 function Theme () {
9602 }
9603
9604 return Theme;
9605
9606}(window));
9607})();
9608