+
+
+
+
+
+
+
+
diff --git a/test/unit-tests/common/main/lib/component/BaseView.js b/test/unit-tests/common/main/lib/component/BaseView.js
new file mode 100644
index 0000000000..bab307eab4
--- /dev/null
+++ b/test/unit-tests/common/main/lib/component/BaseView.js
@@ -0,0 +1,117 @@
+/*
+ *
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+*/
+/**
+ * BaseView.js
+ *
+ * Created by Alexander Yuzhin on 1/17/14
+ * Copyright (c) 2018 Ascensio System SIA. All rights reserved.
+ *
+ */
+
+if (Common === undefined)
+ var Common = {};
+
+define([
+ 'backbone'
+], function (Backbone) {
+ 'use strict';
+
+ Common.UI = _.extend(Common.UI || {}, {
+ Keys : {
+ BACKSPACE: 8,
+ TAB: 9,
+ RETURN: 13,
+ SHIFT: 16,
+ CTRL: 17,
+ ALT: 18,
+ ESC: 27,
+ LEFT: 37,
+ UP: 38,
+ RIGHT: 39,
+ DOWN: 40,
+ DELETE: 46,
+ HOME: 36,
+ END: 35,
+ SPACE: 32,
+ PAGEUP: 33,
+ PAGEDOWN: 34,
+ INSERT: 45,
+ EQUALITY_FF:61,
+ NUM_PLUS: 107,
+ NUM_MINUS: 109,
+ F1: 112,
+ F2: 113,
+ F3: 114,
+ F4: 115,
+ F5: 116,
+ F6: 117,
+ F7: 118,
+ F8: 119,
+ F9: 120,
+ F10: 121,
+ F11: 122,
+ F12: 123,
+ MINUS_FF: 173,
+ EQUALITY: 187,
+ MINUS: 189
+ },
+
+ BaseView: Backbone.View.extend({
+ isSuspendEvents: false,
+
+ initialize : function(options) {
+ this.options = this.options ? _({}).extend(this.options, options) : options;
+ },
+
+ setVisible: function(visible) {
+ return this[visible ? 'show': 'hide']();
+ },
+
+ isVisible: function() {
+ return $(this.el).is(":visible");
+ },
+
+ suspendEvents: function() {
+ this.isSuspendEvents = true;
+ },
+
+ resumeEvents: function() {
+ this.isSuspendEvents = false;
+ }
+ }),
+
+ getId: function(prefix) {
+ return _.uniqueId(prefix || "asc-gen");
+ }
+ });
+});
\ No newline at end of file
diff --git a/test/unit-tests/common/main/lib/component/Button.js b/test/unit-tests/common/main/lib/component/Button.js
new file mode 100644
index 0000000000..941a930b75
--- /dev/null
+++ b/test/unit-tests/common/main/lib/component/Button.js
@@ -0,0 +1,774 @@
+/*
+ *
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+*/
+/**
+ * Button.js
+ *
+ * Created by Alexander Yuzhin on 1/20/14
+ * Copyright (c) 2018 Ascensio System SIA. All rights reserved.
+ *
+ */
+
+/**
+ * Using template
+ *
+ * A simple button with text:
+ *
+ *
+ * A simple button with icon:
+ *
+ *
+ * A button with menu:
+ *
+ *
+ *
+ *
+ *
+ * A split button:
+ *
+ *
+ *
+ *
+ *
+ *
+ * A useful classes of button size
+ *
+ * - `'small'`
+ * - `'normal'`
+ * - `'large'`
+ * - `'huge'`
+ *
+ * A useful classes of button type
+ *
+ * - `'default'`
+ * - `'active'`
+ *
+ *
+ * Buttons can also be toggled. To enable this, you simple set the {@link #enableToggle} property to `true`.
+ *
+ * Example usage:
+ * new Common.UI.Button({
+ * el: $('#id'),
+ * enableToggle: true
+ * });
+ *
+ *
+ * @property {Boolean} disabled
+ * True if this button is disabled. Read-only.
+ *
+ * disabled: false,
+ *
+ *
+ * @property {Boolean} pressed
+ * True if this button is pressed (only if enableToggle = true). Read-only.
+ *
+ * pressed: false,
+ *
+ *
+ * @cfg {Boolean} [allowDepress=true]
+ * False to not allow a pressed Button to be depressed. Only valid when {@link #enableToggle} is true.
+ *
+ * @cfg {String/Object} hint
+ * The tooltip for the button - can be a string to be used as bootstrap tooltip
+ *
+ */
+
+if (Common === undefined)
+ var Common = {};
+
+define([
+ 'unit-tests/common/main/lib/component/BaseView',
+ 'unit-tests/common/main/lib/component/ToggleManager'
+], function () {
+ 'use strict';
+
+ window.createButtonSet = function() {
+ function ButtonsArray(args) {};
+ ButtonsArray.prototype = new Array;
+ ButtonsArray.prototype.constructor = ButtonsArray;
+
+ var _disabled = false;
+
+ ButtonsArray.prototype.add = function(button) {
+ button.setDisabled(_disabled);
+ this.push(button);
+ };
+
+ ButtonsArray.prototype.setDisabled = function(disable) {
+ // if ( _disabled != disable ) //bug when disable buttons outside the group
+ {
+ _disabled = disable;
+
+ this.forEach( function(button) {
+ button.setDisabled(disable);
+ });
+ }
+ };
+
+ ButtonsArray.prototype.toggle = function(state, suppress) {
+ this.forEach(function(button) {
+ button.toggle(state, suppress);
+ });
+ };
+
+ ButtonsArray.prototype.pressed = function() {
+ return this.some(function(button) {
+ return button.pressed;
+ });
+ };
+
+ ButtonsArray.prototype.contains = function(id) {
+ return this.some(function(button) {
+ return button.id == id;
+ });
+ };
+
+ ButtonsArray.prototype.concat = function () {
+ var args = Array.prototype.slice.call(arguments);
+ var result = Array.prototype.slice.call(this);
+
+ args.forEach(function(sub){
+ if (sub instanceof Array )
+ Array.prototype.push.apply(result, sub);
+ else if (sub)
+ result.push(sub);
+ });
+
+ return result;
+ };
+
+ var _out_array = Object.create(ButtonsArray.prototype);
+ for ( var i in arguments ) {
+ _out_array.add(arguments[i]);
+ }
+
+ return _out_array;
+ };
+
+ var templateBtnIcon =
+ '<% if ( iconImg ) { %>' +
+ '' +
+ '' +
+ '
';
+
+ var templateHugeSplitCaption =
+ '' +
+ '' +
+ '' +
+ '
';
+
+ Common.UI.Button = Common.UI.BaseView.extend({
+ options : {
+ id : null,
+ hint : false,
+ enableToggle : false,
+ allowDepress : true,
+ toggleGroup : null,
+ cls : '',
+ iconCls : '',
+ caption : '',
+ menu : null,
+ disabled : false,
+ pressed : false,
+ split : false,
+ visible : true,
+ dataHint : '',
+ dataHintDirection: '',
+ dataHintOffset: '0, 0'
+ },
+
+ template: _.template([
+ '<% var applyicon = function() { %>',
+ '<% if (iconImg) { print(\'',
+ '',
+ '
',
+ '<% } else { %>',
+ '',
+ '',
+ '',
+ '
',
+ '<% } %>'
+ ].join('')),
+
+ initialize : function(options) {
+ Common.UI.BaseView.prototype.initialize.call(this, options);
+
+ var me = this;
+
+ me.id = me.options.id || Common.UI.getId();
+ me.hint = me.options.hint;
+ me.enableToggle = me.options.enableToggle;
+ me.allowDepress = me.options.allowDepress;
+ me.cls = me.options.cls;
+ me.iconCls = me.options.iconCls;
+ me.menu = me.options.menu;
+ me.split = me.options.split;
+ me.toggleGroup = me.options.toggleGroup;
+ me.disabled = me.options.disabled;
+ me.visible = me.options.visible;
+ me.pressed = me.options.pressed;
+ me.caption = me.options.caption;
+ me.template = me.options.template || me.template;
+ me.style = me.options.style;
+ me.rendered = false;
+
+ if (me.options.el) {
+ me.render();
+ } else if (me.options.parentEl)
+ me.render(me.options.parentEl);
+ },
+
+ render: function(parentEl) {
+ var me = this;
+
+ me.trigger('render:before', me);
+
+ me.cmpEl = me.$el || $(me.el);
+
+ if (parentEl) {
+ me.setElement(parentEl, false);
+
+ if (!me.rendered) {
+ if ( /icon-top/.test(me.cls) && !!me.caption && /huge/.test(me.cls) ) {
+ if ( me.split === true ) {
+ !!me.cls && (me.cls = me.cls.replace(/\s?(?:x-huge|icon-top)/g, ''));
+ this.template = _.template(templateHugeSplitCaption);
+ } else
+ if ( !!me.menu ) {
+ this.template = _.template(templateHugeMenuCaption);
+ } else {
+ this.template = _.template(templateHugeCaption);
+ }
+ }
+
+ me.cmpEl = $(this.template({
+ id : me.id,
+ cls : me.cls,
+ iconCls : me.iconCls,
+ iconImg : me.options.iconImg,
+ menu : me.menu,
+ split : me.split,
+ disabled : me.disabled,
+ pressed : me.pressed,
+ caption : me.caption,
+ style : me.style,
+ dataHint : me.options.dataHint,
+ dataHintDirection: me.options.dataHintDirection,
+ dataHintOffset: me.options.dataHintOffset,
+ dataHintTitle: me.options.dataHintTitle
+ }));
+
+ if (me.menu && _.isObject(me.menu) && _.isFunction(me.menu.render))
+ me.menu.render(me.cmpEl);
+
+ parentEl.html(me.cmpEl);
+ me.$icon = me.$el.find('.icon');
+ }
+ }
+
+ if (!me.rendered) {
+ var el = me.cmpEl,
+ isGroup = el.hasClass('btn-group'),
+ isSplit = el.hasClass('split');
+
+ if (me.options.hint) {
+ var modalParents = me.cmpEl.closest('.asc-window');
+
+ if (typeof me.options.hint == 'object' && me.options.hint.length>1 && $('button', el).length>0) {
+ var btnEl = $('button', el);
+ me.btnEl = $(btnEl[0]);
+ me.btnMenuEl = $(btnEl[1]);
+ } else {
+ me.btnEl = me.cmpEl;
+ me.btnEl.attr('data-toggle', 'tooltip');
+ }
+ me.btnEl.tooltip({
+ title : (typeof me.options.hint == 'string') ? me.options.hint : me.options.hint[0],
+ placement : me.options.hintAnchor||'cursor'
+ });
+ me.btnMenuEl && me.btnMenuEl.tooltip({
+ title : me.options.hint[1],
+ placement : me.options.hintAnchor||'cursor'
+ });
+
+ if (modalParents.length > 0) {
+ me.btnEl.data('bs.tooltip').tip().css('z-index', parseInt(modalParents.css('z-index')) + 10);
+ me.btnMenuEl && me.btnMenuEl.data('bs.tooltip').tip().css('z-index', parseInt(modalParents.css('z-index')) + 10);
+ var onModalClose = function(dlg) {
+ if (modalParents[0] !== dlg.$window[0]) return;
+ var tip = me.btnEl.data('bs.tooltip');
+ if (tip) {
+ if (tip.dontShow===undefined)
+ tip.dontShow = true;
+
+ tip.hide();
+ }
+ Common.NotificationCenter.off({'modal:close': onModalClose});
+ };
+ Common.NotificationCenter.on({'modal:close': onModalClose});
+ }
+ }
+
+ if (_.isString(me.toggleGroup)) {
+ me.enableToggle = true;
+ }
+
+ var buttonHandler = function(e) {
+ if (!me.disabled && e.which == 1) {
+ me.doToggle();
+ if (me.options.hint) {
+ var tip = me.btnEl.data('bs.tooltip');
+ if (tip) {
+ if (tip.dontShow===undefined)
+ tip.dontShow = true;
+
+ tip.hide();
+ }
+ }
+ me.trigger('click', me, e);
+ }
+ };
+
+ var doSplitSelect = function(select, element, e) {
+ if (!select) {
+ // Is mouse under button
+ var isUnderMouse = false;
+
+ $('button', el).each(function(index, button){
+ if ($(button).is(':hover')) {
+ isUnderMouse = true;
+ return false;
+ }
+ });
+
+ if (!isUnderMouse) {
+ el.removeClass('over');
+ $('button', el).removeClass('over');
+ }
+ }
+
+ if ( element == 'button') {
+ if (!select && (me.enableToggle && me.allowDepress && me.pressed))
+ return;
+ if (select && !isSplit && (me.enableToggle && me.allowDepress && !me.pressed)) { // to depress button with menu
+ e.preventDefault();
+ return;
+ }
+
+ $('button:first', el).toggleClass('active', select);
+ } else
+ $('[data-toggle^=dropdown]', el).toggleClass('active', select);
+
+ el.toggleClass('active', select);
+ };
+
+ var menuHandler = function(e) {
+ if (!me.disabled && e.which == 1) {
+ if (isSplit) {
+ if (me.options.hint) {
+ var tip = (me.btnMenuEl ? me.btnMenuEl : me.btnEl).data('bs.tooltip');
+ if (tip) {
+ if (tip.dontShow===undefined)
+ tip.dontShow = true;
+
+ tip.hide();
+ }
+ }
+ var isOpen = el.hasClass('open');
+ doSplitSelect(!isOpen, 'arrow', e);
+ }
+ }
+ };
+
+ var doSetActiveState = function(e, state) {
+ if (isSplit) {
+ doSplitSelect(state, 'button', e);
+ } else {
+ el.toggleClass('active', state);
+ $('button', el).toggleClass('active', state);
+ }
+ };
+
+ var splitElement;
+ var onMouseDown = function (e) {
+ splitElement = e.currentTarget.className.match(/dropdown/) ? 'arrow' : 'button';
+ doSplitSelect(true, splitElement, e);
+ $(document).on('mouseup', onMouseUp);
+ };
+
+ var onMouseUp = function (e) {
+ doSplitSelect(false, splitElement, e);
+ $(document).off('mouseup', onMouseUp);
+ };
+
+ var onAfterHideMenu = function(e, isFromInputControl) {
+ me.cmpEl.find('.dropdown-toggle').blur();
+ if (me.cmpEl.hasClass('active') !== me.pressed)
+ me.cmpEl.trigger('button.internal.active', [me.pressed]);
+ };
+
+ if (isGroup) {
+ if (isSplit) {
+ $('[data-toggle^=dropdown]', el).on('mousedown', _.bind(menuHandler, this));
+ $('button', el).on('mousedown', _.bind(onMouseDown, this));
+ (me.options.width>0) && $('button:first', el).css('width', me.options.width - $('[data-toggle^=dropdown]', el).outerWidth());
+ }
+
+ el.on('hide.bs.dropdown', _.bind(doSplitSelect, me, false, 'arrow'));
+ el.on('show.bs.dropdown', _.bind(doSplitSelect, me, true, 'arrow'));
+ el.on('hidden.bs.dropdown', _.bind(onAfterHideMenu, me));
+
+ $('button:first', el).on('click', buttonHandler);
+ } else {
+ el.on('click', buttonHandler);
+ }
+
+ el.on('button.internal.active', _.bind(doSetActiveState, me));
+
+ el.on('mouseover', function(e) {
+ if (!me.disabled) {
+ me.cmpEl.addClass('over');
+ me.trigger('mouseover', me, e);
+ }
+ });
+
+ el.on('mouseout', function(e) {
+ me.cmpEl.removeClass('over');
+ if (!me.disabled) {
+ me.trigger('mouseout', me, e);
+ }
+ });
+
+ // Register the button in the toggle manager
+ Common.UI.ToggleManager.register(me);
+ }
+
+ me.rendered = true;
+
+ if (me.pressed) {
+ me.toggle(me.pressed, true);
+ }
+
+ if (me.disabled) {
+ me.setDisabled(!(me.disabled=false));
+ }
+
+ if (!me.visible) {
+ me.setVisible(me.visible);
+ }
+
+ me.trigger('render:after', me);
+
+ return this;
+ },
+
+ doToggle: function(){
+ var me = this;
+ if (me.enableToggle && (me.allowDepress !== false || !me.pressed)) {
+ me.toggle();
+ }
+ },
+
+ toggle: function(toggle, suppressEvent) {
+ var state = toggle === undefined ? !this.pressed : !!toggle;
+
+ this.pressed = state;
+
+ if (this.cmpEl)
+ this.cmpEl.trigger('button.internal.active', [state]);
+
+ if (!suppressEvent)
+ this.trigger('toggle', this, state);
+ },
+
+ click: function(opts) {
+ if ( !this.disabled ) {
+ this.doToggle();
+ this.trigger('click', this, opts);
+ }
+ },
+
+ isActive: function() {
+ if (this.enableToggle)
+ return this.pressed;
+
+ return this.cmpEl.hasClass('active')
+ },
+
+ setDisabled: function(disabled) {
+ if (this.rendered && this.disabled != disabled) {
+ var el = this.cmpEl,
+ isGroup = el.hasClass('btn-group'),
+ me = this;
+
+ disabled = (disabled===true);
+
+ if (disabled !== el.hasClass('disabled')) {
+ var decorateBtn = function(button) {
+ button.toggleClass('disabled', disabled);
+ if (!me.options.allowMouseEventsOnDisabled)
+ (disabled) ? button.attr({disabled: disabled}) : button.removeAttr('disabled');
+ };
+
+ decorateBtn(el);
+ isGroup && decorateBtn(el.children('button'));
+ }
+
+ if ((disabled || !Common.Utils.isGecko) && this.options.hint) {
+ var tip = this.btnEl.data('bs.tooltip');
+ if (tip) {
+ disabled && tip.hide();
+ !Common.Utils.isGecko && (tip.enabled = !disabled);
+ }
+ if (this.btnMenuEl) {
+ tip = this.btnMenuEl.data('bs.tooltip');
+ if (tip) {
+ disabled && tip.hide();
+ !Common.Utils.isGecko && (tip.enabled = !disabled);
+ }
+ }
+ }
+
+ if (disabled && this.menu && _.isObject(this.menu) && this.menu.rendered && this.menu.isVisible())
+ setTimeout(function(){ me.menu.hide()}, 1);
+
+ if ( !!me.options.signals ) {
+ var opts = me.options.signals;
+ if ( !(opts.indexOf('disabled') < 0) ) {
+ me.trigger('disabled', me, disabled);
+ }
+ }
+ }
+
+ this.disabled = disabled;
+ },
+
+ isDisabled: function() {
+ return this.disabled;
+ },
+
+ setIconCls: function(cls) {
+ var btnIconEl = $(this.el).find('.icon'),
+ oldCls = this.iconCls;
+
+ this.iconCls = cls;
+ if (/svgicon/.test(this.iconCls)) {
+ var icon = /svgicon\s(\S+)/.exec(this.iconCls);
+ btnIconEl.find('use.zoom-int').attr('xlink:href', icon && icon.length>1 ? '#' + icon[1]: '');
+ btnIconEl.find('use.zoom-grit').attr('xlink:href', icon && icon.length>1 ? '#' + icon[1] + '-150' : '');
+ } else {
+ btnIconEl.removeClass(oldCls);
+ btnIconEl.addClass(cls || '');
+ }
+ },
+
+ changeIcon: function(opts) {
+ var me = this;
+ if ( opts && (opts.curr || opts.next) && me.$icon) {
+ !!opts.curr && (me.$icon.removeClass(opts.curr));
+ !!opts.next && !me.$icon.hasClass(opts.next) && (me.$icon.addClass(opts.next));
+
+ if ( !!me.options.signals ) {
+ if ( !(me.options.signals.indexOf('icon:changed') < 0) ) {
+ me.trigger('icon:changed', me, opts);
+ }
+ }
+ }
+ },
+
+ hasIcon: function(iconcls) {
+ return this.$icon.hasClass(iconcls);
+ },
+
+ setVisible: function(visible) {
+ if (this.cmpEl) this.cmpEl.toggleClass('hidden', !visible);
+ this.visible = visible;
+ },
+
+ isVisible: function() {
+ return (this.cmpEl) ? this.cmpEl.is(":visible") : $(this.el).is(":visible");
+ },
+
+ updateHint: function(hint) {
+ this.options.hint = hint;
+
+ if (!this.rendered) return;
+
+ var cmpEl = this.cmpEl,
+ modalParents = cmpEl.closest('.asc-window');
+
+
+ if (!this.btnEl) {
+ if (typeof this.options.hint == 'object' && this.options.hint.length>1 && $('button', cmpEl).length>0) {
+ var btnEl = $('button', cmpEl);
+ this.btnEl = $(btnEl[0]);
+ this.btnMenuEl = $(btnEl[1]);
+ } else {
+ this.btnEl = cmpEl;
+ this.btnEl.attr('data-toggle', 'tooltip');
+ }
+ }
+
+ if (this.btnEl.data('bs.tooltip'))
+ this.btnEl.removeData('bs.tooltip');
+ if (this.btnMenuEl && this.btnMenuEl.data('bs.tooltip'))
+ this.btnMenuEl.removeData('bs.tooltip');
+
+ this.btnEl.tooltip({
+ title : (typeof hint == 'string') ? hint : hint[0],
+ placement : this.options.hintAnchor||'cursor'
+ });
+ this.btnMenuEl && this.btnMenuEl.tooltip({
+ title : hint[1],
+ placement : this.options.hintAnchor||'cursor'
+ });
+
+ if (modalParents.length > 0) {
+ this.btnEl.data('bs.tooltip').tip().css('z-index', parseInt(modalParents.css('z-index')) + 10);
+ this.btnMenuEl && this.btnMenuEl.data('bs.tooltip').tip().css('z-index', parseInt(modalParents.css('z-index')) + 10);
+ }
+
+ if (this.disabled || !Common.Utils.isGecko) {
+ var tip = this.btnEl.data('bs.tooltip');
+ if (tip) {
+ this.disabled && tip.hide();
+ !Common.Utils.isGecko && (tip.enabled = !this.disabled);
+ }
+ if (this.btnMenuEl) {
+ tip = this.btnMenuEl.data('bs.tooltip');
+ if (tip) {
+ this.disabled && tip.hide();
+ !Common.Utils.isGecko && (tip.enabled = !this.disabled);
+ }
+ }
+ }
+ },
+
+ setCaption: function(caption) {
+ if (this.caption != caption) {
+ this.caption = caption;
+
+ if (this.rendered) {
+ var captionNode = this.cmpEl.find('.caption');
+
+ if (captionNode.length > 0) {
+ captionNode.text(caption);
+ } else {
+ this.cmpEl.find('button:first').addBack().filter('button').text(caption);
+ }
+ }
+ }
+ },
+
+ setMenu: function (m) {
+ if (m && _.isObject(m) && _.isFunction(m.render)){
+ this.menu = m;
+ if (this.rendered)
+ this.menu.render(this.cmpEl);
+ }
+ }
+ });
+});
+
diff --git a/test/unit-tests/common/main/lib/component/ToggleManager.js b/test/unit-tests/common/main/lib/component/ToggleManager.js
new file mode 100644
index 0000000000..3df283a624
--- /dev/null
+++ b/test/unit-tests/common/main/lib/component/ToggleManager.js
@@ -0,0 +1,115 @@
+/*
+ *
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+*/
+/**
+ * ToggleManager.js
+ *
+ * Created by Alexander Yuzhin on 1/28/14
+ * Copyright (c) 2018 Ascensio System SIA. All rights reserved.
+ *
+ */
+
+
+if (Common === undefined)
+ var Common = {};
+
+define([
+ 'unit-tests/common/main/lib/component/BaseView'
+], function () {
+ 'use strict';
+
+ var groups = {};
+
+ function toggleGroup(cmp, state) {
+ var g, i, l;
+ if (state) {
+ g = groups[cmp.toggleGroup];
+ for (i = 0, l = g.length; i < l; i++) {
+ if (g[i] !== cmp) {
+ if (g[i].isActive) {
+ g[i].isActive() && g[i].toggle(false);
+ } else {
+ g[i].toggle(false);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Private utility class used by component
+ */
+ Common.UI.ToggleManager = {
+ register: function(cmp) {
+ if (!cmp.toggleGroup) {
+ return;
+ }
+ var group = groups[cmp.toggleGroup];
+ if (!group) {
+ group = groups[cmp.toggleGroup] = [];
+ }
+ group.push(cmp);
+ cmp.on('toggle', toggleGroup);
+ },
+
+ unregister: function(cmp) {
+ if (!cmp.toggleGroup) {
+ return;
+ }
+ var group = groups[cmp.toggleGroup];
+ if (group) {
+ _.without(group, cmp);
+ cmp.off('toggle', toggleGroup);
+ }
+ },
+
+ /**
+ * Gets the toggled components in the passed group or null
+ * @param {String} group
+ * @return {Common.UI.BaseView}
+ */
+ getToggled: function(group) {
+ var g = groups[group],
+ i = 0,
+ len;
+ if (g) {
+ for (len = g.length; i < len; i++) {
+ if (g[i].pressed === true ||
+ g[i].checked === true) {
+ return g[i];
+ }
+ }
+ }
+ return null;
+ }
+ }
+});
\ No newline at end of file
diff --git a/test/unit-tests/common/main/lib/core/NotificationCenter.js b/test/unit-tests/common/main/lib/core/NotificationCenter.js
new file mode 100644
index 0000000000..4415acffde
--- /dev/null
+++ b/test/unit-tests/common/main/lib/core/NotificationCenter.js
@@ -0,0 +1,78 @@
+/*
+ *
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+*/
+/**
+ * NotificationCenter.js
+ *
+ * A pub-sub object that can be used to decouple various parts
+ * of an application through event-driven architecture.
+ *
+ * Created by Alexander Yuzhin on 1/21/14
+ * Copyright (c) 2018 Ascensio System SIA. All rights reserved.
+ *
+ */
+
+
+/**
+ * Using:
+ *
+ * Common.NotificationCenter.on("foo", function(){
+ * alert("bar");
+ * });
+ *
+ * Common.NotificationCenter.trigger("foo"); // => alert box "bar"
+ *
+ */
+
+if (Common === undefined)
+ var Common = {};
+
+define([
+ 'backbone'
+], function (Backbone) {
+ 'use strict';
+
+ var NotificationCenter = function(){};
+
+ // Copy the basic Backbone.Events on to the event aggregator
+ _.extend(NotificationCenter.prototype, Backbone.Events);
+
+ if(typeof Common.NotificationCenter == 'undefined') {
+ // Method to create new Common.NotificationCenter class
+ NotificationCenter.extend = Backbone.Model.extend;
+
+ Common.NotificationCenter = new NotificationCenter();
+ }
+ else {
+ throw ('Native Common.NotificationCenter instance already defined.')
+ }
+});
\ No newline at end of file
diff --git a/test/unit-tests/common/main/lib/core/application.js b/test/unit-tests/common/main/lib/core/application.js
new file mode 100644
index 0000000000..2903aaa1b8
--- /dev/null
+++ b/test/unit-tests/common/main/lib/core/application.js
@@ -0,0 +1,565 @@
+(function(){
+ var resolveNamespace = function(className, root) {
+ var parts = className.split('.'),
+ current = root || window;
+
+ for(var a = 0, b = parts.length; a < b; a++) {
+ current = current[parts[a]] || {};
+ }
+
+ return current;
+ };
+
+ /**
+ * @class Backbone.Application
+ * @cfg {Object} options The list of options available within Application
+ */
+ var Application = function(options) {
+ _.extend(this, options || {});
+
+ this.eventbus = new EventBus({application: this});
+
+ this.createApplicationNamespace();
+ this.initialize.apply(this, arguments);
+
+ if (this.autoCreate !== false)
+ $($.proxy(this.onReady, this));
+ };
+
+ _.extend(Application.prototype, {
+ /**
+ * @cfg {Object} nameSpace (required)
+ * Define the application namespace
+ */
+ nameSpace: 'Application',
+
+ models: {},
+ collections: {},
+ controllers: {},
+
+ /**
+ * @cfg allocationMap Define the inner structure of our application object
+ * @cfg allocationMap.model The key for models map
+ * @cfg allocationMap.collection The key for collections map
+ * @cfg allocationMap.controller The key for controllers map
+ * @cfg allocationMap.view The key for views map
+ */
+ allocationMap: {
+ model: 'Models',
+ collection: 'Collections',
+ controller: 'Controllers',
+ view: 'Views'
+ },
+
+ /**
+ * Function to create inner structure of the application using {@link #allocationMap allocationMap} config
+ */
+ createApplicationNamespace: function() {
+ var nameSpace = window;
+
+ // create global reference in the defined namespace
+ if(this.nameSpace) {
+ // if it wasn't already defined, create it
+ if(typeof nameSpace[this.nameSpace] == 'undefined') {
+ nameSpace[this.nameSpace] = {}
+ }
+ }
+
+ // let's have a link to the application namespace
+ // this way we will be able to get all references to Models, Collections and Controllers
+ // using given namespace
+ nameSpace[this.nameSpace] = this;
+
+ _.each(this.allocationMap, function(name, key) {
+ this[name] = this[name] || {};
+ }, this);
+ },
+
+ /**
+ * Function that will be called during application instance creation
+ */
+ initialize: function() {},
+
+ /**
+ * Called when DOM is ready. This is global callback is used to:
+ * * Used to initialize controllers and execute {@link Backbone.Controller#onLaunch onLaunch} callback
+ * * Execute {@link Backbone.Application#launch launch} callback
+ */
+ onReady: function() {
+ this.start();
+ },
+
+ start: function() {
+ // initialize controllers
+ this.initializeControllers(this.controllers || {});
+ // call to controller.onLaunch callback
+ this.launchControllers();
+ // call application.launch callback
+ this.launch.call(this);
+ },
+
+ /**
+ * Function that will convert string identifier into the instance reference
+ * @param {String} type Type of instance that should be resolved. See {@link #allocationMap} for valid values
+ * @param {String[]} classes The list of class references
+ * @return {Object} The objects map
+ */
+ getClasseRefs: function(type, classes) {
+ var hashMap = {},
+ allocationMap = this.allocationMap[type],
+ root = this[allocationMap];
+
+ _.each(classes, function(cls) {
+ hashMap[cls] = resolveNamespace(cls, (cls.indexOf('.') > -1) ? window : root);
+ }, this);
+
+ return hashMap;
+ },
+
+ /**
+ * Function that will loop through all application controllers and create their instances
+ * Additionally, read the list of models and collections from each controller and save the reference within application
+ */
+ initializeControllers: function(controllers) {
+ this.controllers = {};
+
+ _.each(controllers, function(ctrl) {
+ var root = (ctrl.indexOf('.') > -1) ? window : this[this.allocationMap.controller],
+ classReference = resolveNamespace(ctrl, root),
+ id = ctrl.split('.').pop();
+
+ var controller = new classReference({
+ id: ctrl,
+ application: this
+ });
+
+ controller.views = this.getClasseRefs('view', controller.views || []);
+
+ _.extend(this.models, this.getClasseRefs('model', controller.models || []));
+ _.extend(this.collections, this.getClasseRefs('collection', controller.collections || {}));
+
+ this.buildCollections();
+ this.controllers[ctrl] = controller;
+ }, this);
+ },
+
+ /**
+ * Launch all controllers using {@link Backbone.Controller#onLaunch callback}
+ */
+ launchControllers: function() {
+ _.each(this.controllers, function(ctrl, id) {
+ ctrl.onLaunch(this);
+ }, this);
+ },
+
+ /**
+ * Called during application launch
+ * @template
+ */
+ launch: function() {},
+
+ /**
+ * Function to add event listeners to the {@link #Backbone.EventBus EventBus}
+ */
+ addListeners: function(listeners, controller) {
+ this.eventbus.addListeners(listeners, controller)
+ },
+
+ /**
+ * Getter to retreive link to the particular controller instance by name
+ * @param {String} name
+ * @return {Backbone.Controller} The controller instance
+ */
+ getController: function(name) {
+ return this.controllers[name];
+ },
+
+ /**
+ * Getter to retrieve link to the particular model instance by name
+ * If model instance isn't created, create it
+ * @param {String} name
+ * @return {Backbone.Model} The model instance
+ */
+ getModel: function(name) {
+ this._modelsCache = this._modelsCache || {};
+
+ var model = this._modelsCache[name],
+ modelClass = this.getModelConstructor(name);
+
+ if(!model && modelClass) {
+ model = this.createModel(name);
+ this._modelsCache[name] = model;
+ }
+
+ return model || null;
+ },
+
+ /**
+ * Getter to retrieve link to the particular model constructor by name
+ * @param {String} name
+ * @return {Backbone.Model} The model constructor
+ */
+ getModelConstructor: function(name) {
+ return this.models[name];
+ },
+
+ /**
+ * Function to create new model instance
+ * @param {String} name The name of the model that needs to be created
+ * @param {Object} [options] The list of option that should be passed to the model constructor
+ */
+ createModel: function(name, options) {
+ var modelClass = this.getModelConstructor(name),
+ model = null;
+
+ if (modelClass)
+ model = new modelClass(_.extend(options || {}));
+
+ return model;
+ },
+
+ /**
+ * Getter to retrieve link to the particular collection instance by name
+ * If collection instance isn't created, create it
+ * @param {String} name
+ * @return {Backbone.Collection} The collection instance
+ */
+ getCollection: function(name) {
+ this._collectionsCache = this._collectionsCache || {};
+
+ var collection = this._collectionsCache[name],
+ collectionClass = this.getCollectionConstructor(name);
+
+ if(!collection && collectionClass) {
+ collection = this.createCollection(name);
+ this._collectionsCache[name] = collection;
+ }
+
+ return collection || null;
+ },
+
+ /**
+ * Getter to retrieve link to the particular collection constructor
+ * @param {String} name
+ * @return {Backbone.Collection} The collection constructor
+ */
+ getCollectionConstructor: function(name) {
+ return this.collections[name];
+ },
+
+ /**
+ * Function to create new collection instance
+ * @param {String} name The name of the collection that needs to be created
+ */
+ createCollection: function(name) {
+ var collectionClass = this.getCollectionConstructor(name),
+ collection = null;
+
+ if (collectionClass)
+ collection = new collectionClass();
+
+ return collection;
+ },
+
+ /**
+ * Function that will loop throught the list of collection constructors and create instances
+ */
+ buildCollections: function() {
+ _.each(this.collections, function(collection, alias) {
+ this.getCollection(alias);
+ }, this);
+ }
+ });
+
+
+ // Since we are using Backbone let's make sure that there are no conflicts in namespaces
+ if(typeof Backbone.Application == 'undefined') {
+ Backbone.Application = Application;
+ /**
+ * @method extend
+ * Method to create new Backbone.Application class
+ * @static
+ */
+ Backbone.Application.extend = Backbone.Model.extend;
+ }
+ else {
+ throw ('Native Backbone.Application instance already defined.')
+ }
+
+ /**
+ * @class Backbone.Controller
+ * @cfg {Object} options The list of options available within Controller
+ */
+ var Controller = function(options) {
+ _.extend(this, options || {});
+ this.initialize.apply(this, arguments);
+ };
+
+ _.extend(Controller.prototype, {
+ name: null,
+ views: {},
+ models: {},
+ collections: {},
+
+ initialize: function(options) {
+ },
+
+ /**
+ * Add new listener to the application event bus
+ * Delegate to {@link Backbone.Application#addListeners addListeners} callback
+ */
+ addListeners: function(listeners) {
+ this.getApplication().addListeners(listeners, this);
+ },
+
+ /**
+ * Called after application launch
+ * @template
+ */
+ onLaunch: function(application) {
+ },
+
+ /**
+ * Getter that will return the reference to the application instance
+ */
+ getApplication: function() {
+ return this.application;
+ },
+
+ /**
+ * Getter that will return the reference to the view instance
+ */
+ getView: function(name) {
+ return this._viewsCache[name];
+ },
+
+ /**
+ * Getter that will return the reference to the view constructor by name
+ * @param {String} name
+ * @return {Backbone.View} The view constructor
+ */
+ getViewConstructor: function(name) {
+ return this.views[name];
+ },
+
+ /**
+ * Function to create a new view instance
+ * All views are cached within _viewsCache hash map
+ * @param {String} name
+ * @param {Object} options Options to be passed within view constructor
+ * @return {Backbone.View} The view instance
+ */
+ createView: function(name, options) {
+ var view = this.getViewConstructor(name),
+ viewOptions = _.extend(options || {}, {
+ alias: name
+ });
+
+ this._viewsCache = this._viewsCache || {};
+ this._viewsCache[name] = new view(viewOptions);
+
+ this._viewsCache[name].options = _.extend({}, viewOptions);
+
+ return this._viewsCache[name];
+ },
+
+ /**
+ * Method to get model instance reference by name
+ * Delegate to {@link Backbone.Application#getModel getModel} method
+ */
+ getModel: function(name) {
+ return this.application.getModel(name);
+ },
+
+ /**
+ * Method to get model constructor reference by name
+ * Delegate to {@link Backbone.Application#getModelConstructor getModelConstructor} method
+ */
+ getModelConstructor: function(name) {
+ return this.application.getModelConstructor(name);
+ },
+
+ /**
+ * Method to create model instance by name
+ * Delegate to {@link Backbone.Application#createModel createModel} method
+ */
+ createModel: function(name, options) {
+ return this.application.createModel(name)
+ },
+
+ /**
+ * Delegate method to get collection instance reference by name
+ * Delegate to {@link Backbone.Application#getCollection getCollection} method
+ */
+ getCollection: function(name) {
+ return this.application.getCollection(name);
+ },
+
+ /**
+ * Delegate method to get collection constructor reference by name
+ * Delegate to {@link Backbone.Application#getCollectionConstructor getCollectionConstructor} method
+ */
+ getCollectionConstructor: function(name) {
+ return this.application.getCollectionConstructor(name);
+ },
+
+ /**
+ * Delegate method to create collection instance
+ * Delegate to {@link Backbone.Application#createCollection createCollection} method
+ */
+ createCollection: function(name) {
+ return this.application.createCollection(name);
+ },
+
+ /**
+ * Method to fire cross-controller event
+ * Delegate to {@link Backbone.Application#fireEvent fireEvent} method
+ */
+ fireEvent: function(selector, event, args) {
+ this.application.eventbus.fireEvent(selector, event, args);
+ },
+
+ /**
+ * Method to bind events from controlling view to controller
+ * probably isn't safe, testing needed
+ */
+ bindViewEvents: function(view, events) {
+ this.unbindViewEvents(view);
+
+ events = _.isFunction(events) ? events.call(this) : events;
+
+ for (var key in events) {
+ var method = events[key];
+ if (!_.isFunction(method)) method = this[events[key]];
+
+ var match = key.match(/^(\S+)\s*(.*)$/);
+ var eventName = match[1], selector = match[2];
+ method = _.bind(method, this);
+ eventName += '.bindViewEvents' + view.cid;
+ view.$el.on(eventName, selector, method);
+ }
+
+ return this;
+ },
+
+ /**
+ * Method to unbind events from view to controller
+ *
+ */
+ unbindViewEvents: function(view) {
+ view.$el.off('.bindViewEvents' + view.cid);
+ return this;
+ }
+ });
+
+ if(typeof Backbone.Controller == 'undefined') {
+ Backbone.Controller = Controller;
+ /**
+ * @method extend
+ * Method to create new Backbone.Controller class
+ * @static
+ */
+ Backbone.Controller.extend = Backbone.Model.extend;
+ }
+ else {
+ throw ('Native Backbone.Controller instance already defined.')
+ }
+
+ /**
+ * @class Backbone.EventBus
+ * @cfg {Object} options The list of options available within Controller
+ * @private
+ */
+ var EventBus = function(options) {
+ var me = this;
+
+ _.extend(this, options || {});
+
+ _.extend(Backbone.View.prototype, {
+ alias: null,
+ hidden: false,
+ getAlias: function() {
+ return this.options.alias;
+ },
+ /**
+ * Instead of calling View.trigger lets use custom function
+ * It will notify the EventBus about new event
+ */
+ fireEvent: function(event, args) {
+ this.trigger.apply(this, arguments);
+ me.fireEvent(this.getAlias(), event, args);
+ },
+ hide: function() {
+ this.$el.hide();
+ this.hidden = true;
+ },
+ show: function() {
+ this.$el.show();
+ this.hidden = false;
+ }
+ });
+ };
+
+ _.extend(EventBus.prototype, {
+ pool: {},
+ /**
+ * Add new listeners to the event bus
+ */
+ addListeners: function(selectors, controller) {
+
+ this.pool[controller.id] = this.pool[controller.id] || {};
+ var pool = this.pool[controller.id];
+
+ if(_.isArray(selectors)) {
+ _.each(selectors, function(selector) {
+ this.addListeners(selector, controller);
+ }, this)
+ }
+ else if(_.isObject(selectors)) {
+ _.each(selectors, function(listeners, selector) {
+ _.each(listeners, function(listener, event) {
+ pool[selector] = pool[selector] || {};
+ pool[selector][event] = pool[selector][event] || [];
+ pool[selector][event].push(listener);
+
+ }, this);
+ }, this)
+
+ }
+ },
+
+ /**
+ * Execute event listener by given selector and event name
+ */
+ fireEvent: function(selector, event, args) {
+ var application = this.getApplication();
+
+ _.each(this.pool, function(eventsPoolByAlias, controllerId) {
+ var events = eventsPoolByAlias[selector];
+
+ if(events) {
+ var listeners = events[event],
+ controller = application.getController(controllerId);
+
+ _.each(listeners, function(fn) {
+ fn.apply(controller, args);
+ });
+ }
+
+
+ }, this);
+ },
+
+ getApplication: function() {
+ return this.application;
+ }
+ });
+
+ // Since we are using Backbone let's make sure that there are no conflicts in namespaces
+ if(typeof Backbone.EventBus == 'undefined') {
+ Backbone.EventBus = EventBus;
+ }
+ else {
+ throw ('Native Backbone.Application instance already defined.')
+ }
+})();
\ No newline at end of file
diff --git a/test/unit-tests/common/main/lib/core/keymaster.js b/test/unit-tests/common/main/lib/core/keymaster.js
new file mode 100644
index 0000000000..eeac761ebf
--- /dev/null
+++ b/test/unit-tests/common/main/lib/core/keymaster.js
@@ -0,0 +1,346 @@
+// keymaster.js
+// (c) 2011-2013 Thomas Fuchs
+// keymaster.js may be freely distributed under the MIT license.
+//
+// changesets: 833cf1a00fe2, e19d5b8a37fe
+
+;(function(global){
+ var k,
+ _handlers = {},
+ _mods = { 16: false, 18: false, 17: false, 91: false },
+ _scope = 'all',
+ // modifier keys
+ _MODIFIERS = {
+ '⇧': 16, shift: 16,
+ '⌥': 18, alt: 18, option: 18,
+ '⌃': 17, ctrl: 17, control: 17,
+ '⌘': 91, command: 91
+ },
+ // special keys
+ _MAP = {
+ backspace: 8, tab: 9, clear: 12,
+ enter: 13, 'return': 13,
+ esc: 27, escape: 27, space: 32,
+ left: 37, up: 38,
+ right: 39, down: 40,
+ del: 46, 'delete': 46,
+ home: 36, end: 35,
+ pageup: 33, pagedown: 34,
+ ',': 188, '.': 190, '/': 191,
+ '`': 192, '-': 189, '=': 187,
+ ';': 186, '\'': 222,
+ '[': 219, ']': 221, '\\': 220,
+ 'ff-': 173, 'ff=': 61
+ },
+ code = function(x){
+ return _MAP[x] || x.toUpperCase().charCodeAt(0);
+ },
+ _downKeys = [];
+ var locked;
+
+ for(k=1;k<20;k++) _MAP['f'+k] = 111+k;
+
+ // IE doesn't support Array#indexOf, so have a simple replacement
+ function index(array, item){
+ var i = array.length;
+ while(i--) if(array[i]===item) return i;
+ return -1;
+ }
+
+ // for comparing mods before unassignment
+ function compareArray(a1, a2) {
+ if (a1.length != a2.length) return false;
+ for (var i = 0; i < a1.length; i++) {
+ if (a1[i] !== a2[i]) return false;
+ }
+ return true;
+ }
+
+ var modifierMap = {
+ 16:'shiftKey',
+ 18:'altKey',
+ 17:'ctrlKey',
+ 91:'metaKey'
+ };
+ function updateModifierKey(event) {
+ for(k in _mods) _mods[k] = event[modifierMap[k]];
+ };
+
+ // handle keydown event
+ function dispatch(event) {
+ var key, handler, k, i, modifiersMatch, scope;
+ key = event.keyCode;
+
+ if (Common.UI.HintManager.isHintVisible()) {
+ if (key === 112) {
+ Common.UI.HintManager.clearHints();
+ } else if (key !== 27) {
+ return;
+ }
+ }
+
+ if (index(_downKeys, key) == -1) {
+ _downKeys.push(key);
+ }
+
+ // if a modifier key, set the key.