ru.coon 2.7.53 → 2.7.55

package/src/report/toolbar/dropdown/ToolbarOverflowPanel.scss

@@ -0,0 +1,37 @@
+.ToolbarOverflowPanel {
+
+  border: 1px solid #9DB2BF;
+  border-top: none;
+  .x-btn-button > .fix-btn-width  {
+    width: 30px;
+  }
+  .white-space{
+    background-color: transparent;
+    border-top: 1px solid #9DB2BF;
+    width: 100%;
+    height: 1px;
+    position: absolute;
+    top: 0;
+    right: 32px;
+  }
+
+  .panel-body-buttons > .x-panel-bodyWrap > .x-panel-body{
+    border-bottom: 1px solid #9DB2BF !important;
+    //padding-bottom: 20px;
+  }
+
+  .panel-body-buttons .x-btn{
+    margin: 0 3px 5px 3px !important;
+    border: 1px solid transparent;
+  }
+
+
+}
+.shadow-elem{
+  background-repeat: no-repeat;
+  background-image: url("data:image/svg+xml;base64,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");
+  position: absolute;
+  cursor: pointer;
+  width: 40px;
+  height: 40px;
+}

package/src/report/toolbar/layout/ReportToolbarOverflow.js

@@ -0,0 +1,374 @@
+Ext.define('Coon.report.toolbar.layout.ReportToolbarOverflow', {
+    extend: 'Ext.layout.container.boxOverflow.Menu',
+    alias: 'box.overflow.ReportToolbarOverflow',
+
+    pTypePriority: {
+        CopyRowsFromGrid: 1,
+        ExportReportDataToFilePlugin: 2,
+        ExporterPlugin: 3,
+        PrintPdfButtonPlugin: 4,
+        GroupButtonsPlugin: 5,
+    },
+
+    constructor: function(config) {
+        const me = this;
+
+        me.callParent([config]);
+
+        /**
+         * @property {Array} menuItems
+         * Array of all items that are currently hidden and should go into the dropdown menu
+         */
+        me.menuItems = [];
+
+        /**
+         * @property {Array} buttons
+         * Массив системных кнопок
+         */
+        me.systemItems = [];
+    },
+
+    beginLayout: function(ownerContext) {
+        this.callParent([ownerContext]);
+        // Before layout, we need to re-show all items which we may have hidden due to a
+        // previous overflow...
+        if (this.menuButton.dropDownMenu) {
+            this.layout.owner.foldItemsContainer.items.items.forEach((button) => {
+                if (button.hasCls(this.menuItemOverflowedCls)) {
+                    this.layout.owner.add(button);
+                    button.removeCls(this.menuItemOverflowedCls);
+                }
+            });
+        }
+        this.clearOverflow(ownerContext);
+    },
+
+    beginLayoutCycle: function(ownerContext, firstCycle) {
+        this.callParent([ownerContext, firstCycle]);
+
+        if (!firstCycle) {
+            // if we are being re-run, we need to clear any overflow from the last run and
+            // recache the childItems collection
+            this.clearOverflow(ownerContext);
+
+            this.layout.cacheChildItems(ownerContext);
+        }
+    },
+
+    /**
+     * @private
+     * Called by the layout, when it determines that there is no overflow.
+     * Also called as an interceptor to the layout's onLayout method to reshow
+     * previously hidden overflowing items.
+     */
+    clearOverflow: function(ownerContext) {
+        const me = this;
+        const items = me.menuItems;
+        const length = items.length;
+        const owner = me.layout.owner;
+        const asLayoutRoot = owner._asLayoutRoot;
+        let item; let i;
+
+        owner.suspendLayouts();
+        me.captureChildElements();
+        me.hideSystemToolbar();
+        owner.resumeLayouts();
+
+        for (i = 0; i < length; i++) {
+            item = items[i];
+
+            // What we are doing here is preventing the layout bubble from invalidating our
+            // owner component. We need just the button to be added to the layout run.
+            item.suspendLayouts();
+            item.removeCls(me.menuItemOverflowedCls);
+            me.clearItem(item);
+            item.resumeLayouts(asLayoutRoot);
+        }
+
+        items.length = 0;
+    },
+
+    hideSystemToolbar: function() {
+        const systemContainer = this.systemContainer;
+
+        if (systemContainer) {
+            systemContainer.setWidth(this.systemContainerTotalWidth);
+        }
+    },
+
+    // Вызывается в hbox лейауте в шаблоне
+    getSuffixConfig: function() {
+        const me = this;
+        const layout = me.layout;
+        const owner = layout.owner;
+        const oid = owner.id;
+
+        /*
+        picker
+        me.menuButton = Ext.create('Coon.report.toolbar.dropdown.TestPicker', {
+            width: 200,
+            minWidth: 10,
+        });
+
+        me.menuButton.on({
+            scope: me,
+            expand: me.beforeMenuShow,
+        });*/
+        me.menuButton = Ext.widget('ToolbarOverflowButton', {
+            id: oid + '-menu-trigger',
+            // To enable the Menu to ascertain a valid zIndexManager owner in the same tree
+            ownerCt: owner,
+            ownerLayout: layout,
+            reportToolbar: owner,
+            position: 999,
+            style: {
+                marginRight: '10px',
+                marginLeft: '10px',
+            },
+        });
+        me.menuButton.dropDownMenu.on({
+            scope: me,
+            beforeshow: me.beforeMenuShow,
+        });
+
+        const systemItemsList = [...me.systemItems, me.menuButton];
+
+        me.systemContainer = Ext.create({
+            xtype: 'container',
+            itemId: 'systemContainer',
+            layout: 'hbox',
+            width: 2,
+            defaults: {
+                style: {
+                    marginLeft: '10px',
+                },
+            },
+            style: {
+                borderLeft: '3px solid #D3D3D3',
+            },
+            items: systemItemsList,
+        });
+
+        return me.systemContainer.getRenderTree();
+    },
+
+    // Добавление кнопки в системный тулбар
+    addButton: function(button) {
+        const me = this;
+        if (button.pType !== 'ToolbarOverflowButton') {
+            button.setTooltip(button.getText());
+            button.setText('');
+            this.setIconClsByType(button);
+        }
+        button.arrowVisible = false;
+        me.systemItems.push(button);
+        me.systemContainer.insert(0, button);
+        this.setButtonsPositionsByPType();
+        this.sortButtons();
+        if (!me.systemContainer.rendered) {
+            me.systemContainer.on('afterrender', function(btn) {
+                this.systemContainer.setWidth(this.systemContainer.getWidth() + btn.getWidth());
+            }, me, {single: true});
+        }
+    },
+
+    setIconClsByType(button) {
+        let cls = '';
+        switch (button.pType) {
+        case 'CopyRowsFromGrid':
+            cls = 'print-excel-button';
+            break;
+        case 'ExportReportDataToFilePlugin':
+            switch (button.exportFileFormat) {
+            case 'excel':
+            default:
+                cls = 'print-excel-button';
+                break;
+            case 'pdf':
+                cls = 'print-pdf-button';
+                break;
+            case 'csv':
+                cls = 'print-csv-button';
+                break;
+            case 'txt':
+                cls = 'print-txt-button';
+                break;
+            }
+            break;
+        case 'ExporterPlugin':
+            cls = 'print-excel-button';
+            break;
+        case 'PrintPdfButtonPlugin':
+            cls = 'print-pdf-button';
+            break;
+        case 'GroupButtonsPlugin':
+            cls = 'go-to-button';
+            break;
+        default:
+            cls = 'fa fa-plus';
+            break;
+        }
+        button.setIconCls(' masked-system-button '+ cls);
+    },
+    setButtonsPositionsByPType() {
+        const buttons = this.systemContainer.items.items;
+        if (buttons.length <= 1) {
+            return false;
+        }
+        buttons.forEach((button) => {
+            if (button.xtype !== 'ToolbarOverflowButton') {
+                button.position = this.pTypePriority[button.pType] || 0;
+            }
+        });
+    },
+
+    sortButtons() {
+        if (this.systemContainer.items.length <= 1) {
+            return;
+        }
+        this.systemContainer.items.doSort((a, b) => {
+            if (a.position < b.position) {
+                return -1;
+            }
+            if (a.position > b.position) {
+                return 1;
+            }
+            return 0;
+        });
+    },
+    /**
+     * Вычисление ширины системной части тулбара
+     */
+    calculateSystemContainerWidth() {
+        const me = this;
+        const systemContainer = me.systemContainer;
+        const names = me.layout.names;
+        const DEFAULT_BUTTON_WIDTH = 0;
+        const systemButtonsWidth = me.systemItems.reduce((acc, button) => {
+            // console.log('button width', button.rendered && Ext.isFunction(button.getWidth) ?
+            //     button.getWidth() + 10:
+            //     DEFAULT_BUTTON_WIDTH);
+            acc += button.rendered && Ext.isFunction(button.getWidth) ?
+                button.getWidth() + 10:
+                DEFAULT_BUTTON_WIDTH;
+            return acc;
+        }, 0);
+        // console.log('buttons width', systemButtonsWidth);
+        // console.log('menuButton', me.menuButton.getWidth());
+        // console.log('getMargin', systemContainer.el.getMargin(names.parallelMargins));
+        const width = systemButtonsWidth +
+            (me.menuButton.getWidth() || 30) + 20 +
+            systemContainer.el.getMargin(names.parallelMargins);
+        // console.log('allWidth', width);
+        return width;
+    },
+    calculate: function(ownerContext) {
+        const me = this;
+        const plan = ownerContext.state.boxPlan;
+        let overflow;
+        if (plan /* && plan.tooNarrow*/) { // Не учитываем, есть переполнение или нет
+            overflow = me.handleOverflow(ownerContext);
+            if (overflow) {
+                if (overflow.reservedSpace) {
+                    me.layout.publishInnerCtSize(ownerContext, overflow.reservedSpace);
+                }
+            }
+        }
+    },
+
+    handleOverflow: function(ownerContext) {
+        const me = this;
+        const layout = me.layout;
+
+        me.showSystemToolbar(ownerContext);
+
+        // Center the systemContainer button only if we are not vertical.
+        if (layout.direction !== 'vertical') {
+            me.systemContainer.setLocalY(
+                (ownerContext.state.boxPlan.maxSize - me.systemContainer[layout.names.getHeight]()) / 2
+            );
+        }
+        return {
+            reservedSpace: me.systemContainerTotalWidth,
+        };
+    },
+
+    beforeMenuShow: function(toolbarOverflowPanel) {
+        const me = this;
+        const layout = me.layout;
+        const owner = layout.owner;
+        const report = owner.up('ReportPanel');
+        const reportId = report.reportId;
+        const allChildItems = this.layout.owner.items.getRange().filter((item) => !item.isContainer); // Все кнопки
+        const overvlowedItems = allChildItems.filter((b) => b.hasCls(this.menuItemOverflowedCls) === true);
+        const foldItems = owner.foldItemsContainer.items.getRange().filter((b) => b.hasCls(this.menuItemOverflowedCls) !== true);
+        // Контейнер, содержащий припаркованные кнопки
+        toolbarOverflowPanel.getController().doInit(reportId, allChildItems, overvlowedItems, foldItems);
+    },
+
+    /**
+     * @private
+     * Shows the overflow trigger when enableOverflow is set to true and the items
+     * in the layout are too wide to fit in the space available
+     */
+    showSystemToolbar: function(ownerContext) {
+        const me = this;
+        const layout = me.layout;
+        const owner = layout.owner;
+        const names = layout.names;
+        const startProp = names.x;
+        const sizeProp = names.width;
+        const plan = ownerContext.state.boxPlan;
+        let available = plan.targetSize[sizeProp];
+        const childItems = ownerContext.childItems;
+        const systemContainer = me.systemContainer;
+        const menuItems = me.menuItems;
+        let childContext; let comp; let i; let props; let len;
+
+        // We don't want the systemContainer.show to cause owner's layout to be invalidated, so
+        // we force just the button to be invalidated and added to the current run.
+        systemContainer.suspendLayouts();
+        systemContainer.show();
+        systemContainer.resumeLayouts(me._asLayoutRoot);
+
+        available -= me.systemContainerTotalWidth;
+        owner.suspendLayouts();
+        // Hide all items which are off the end, and store them to allow them to be restored
+        // before each layout operation.
+        for (i = 0, len = menuItems.length; i < len; ++i) {
+            me.clearItem(menuItems[i]);
+        }
+
+        menuItems.length = 0;
+        let indicator = false;
+        for (i = 0, len = childItems.length; i < len; i++) {
+            childContext = childItems[i];
+            props = childContext.props;
+            if (props[startProp] + props[sizeProp] > available) {
+                comp = childContext.target;
+                if (comp.itemId === 'hiddenDisplayElement') {
+                    continue;
+                }
+                comp.addCls(me.menuItemOverflowedCls);
+                indicator = true;
+                me.menuItems.push(comp);
+            }
+        }
+        this.menuButton.setOverflowIndicator(indicator);
+        owner.resumeLayouts();
+    },
+
+    captureChildElements: function() {
+        const me = this;
+        const systemContainer = me.systemContainer;
+        const names = me.layout.names;
+
+        // The rendering flag is set when getRenderTree is called which we do
+        // when returning markup string for the owning layout's "suffix"
+        if (systemContainer.rendering) {
+            systemContainer.finishRender();
+        }
+        const calculatedWidth = me.calculateSystemContainerWidth();
+        me.systemContainerTotalWidth = calculatedWidth + systemContainer.el.getMargin(names.parallelMargins);
+    },
+});

package/src/uielement/component/settings/UiAceEditor.js

@@ -239,6 +239,9 @@ Ext.define('Coon.uielement.component.settings.UiAceEditor', {
     renderEditor: function() {
         this.editor = Ext.xAceEditor.edit(this.getId());
         this.editor.setTheme('ace/theme/xcode');
+        if (this.mode === 'javascript') {
+            this.editor.session.setOption('useWorker', !Ext.isProduction);
+        }
         if (typeof this.mode === 'string') {
             this.editor.session.setMode(`ace/mode/${this.mode}`);
         } else {

package/src/uielement/component/settings/plugin/UiCustomPanelPluginGrid.js

@@ -7,6 +7,8 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGrid', {
     requires: [
         'Coon.uielement.component.settings.plugin.UiCustomPanelPluginSelectWindow',
         'Coon.uielement.component.settings.plugin.UiCustomPanelPluginGridController',
+        'Coon.uielement.component.settings.plugin.UiCustomPanelPluginModel',
+        'Coon.uielement.component.settings.plugin.UiCustomPanelPluginStore',
         'Coon.stateProvider'
     ],
     controller: 'UiCustomPanelPluginGridController',
@@ -22,37 +24,10 @@ Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginGrid', {
 
     stateId: 'UiCustomPanelPluginGrid',
 
-    store: Ext.create('Ext.data.ArrayStore', {
-        storeId: 'UiCustomPanelPluginStore',
-        model: Ext.define('UiCustomPanelPluginModel', {
-            extend: 'Ext.data.Model',
-            fields: [
-                {name: 'isSingle', type: 'boolean'},
-                {name: 'isNew', type: 'boolean'},
-                {name: 'sequenceNumber', type: 'number'},
-                {name: 'sortSequence', type: 'number'},
-                {name: 'ptype', type: 'string'},
-                {name: 'xtype', type: 'string', convert(_, plugin) {
-                    return plugin.data.ptype;
-                }},
-                {
-                    name: 'handlerName',
-                    type: 'string',
-                    convert(v) {
-                        return v || '-/-';
-                    }},
-                {
-                    name: 'name',
-                    type: 'string',
-                    convert(val, plugin) {
-                        return `${plugin.data.ptype}${plugin.data.handlerName ? '.'+plugin.data.handlerName : ''}`;
-                    },
-                },
-                'properties',
-                'jsonProperties'
-            ],
-        }),
-    }),
+    store: {
+        type: 'UiCustomPanelPluginStore',
+    },
+
     viewConfig: {
         getRowClass: function(rec) {
             if (rec.get('isDeleted')) {

package/src/uielement/component/settings/plugin/UiCustomPanelPluginModel.js

@@ -0,0 +1,30 @@
+Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginModel', {
+    extend: 'Ext.data.Model',
+    entityName: 'UiCustomPanelPluginModel',
+
+    fields: [
+        {name: 'isSingle', type: 'boolean'},
+        {name: 'isNew', type: 'boolean'},
+        {name: 'sequenceNumber', type: 'number'},
+        {name: 'sortSequence', type: 'number'},
+        {name: 'ptype', type: 'string'},
+        {name: 'xtype', type: 'string', convert(_, plugin) {
+            return plugin.data.ptype;
+        }},
+        {
+            name: 'handlerName',
+            type: 'string',
+            convert(v) {
+                return v || '-/-';
+            }},
+        {
+            name: 'name',
+            type: 'string',
+            convert(val, plugin) {
+                return `${plugin.data.ptype}${plugin.data.handlerName ? '.'+plugin.data.handlerName : ''}`;
+            },
+        },
+        'properties',
+        'jsonProperties'
+    ],
+});

package/src/uielement/component/settings/plugin/UiCustomPanelPluginStore.js

@@ -0,0 +1,5 @@
+Ext.define('Coon.uielement.component.settings.plugin.UiCustomPanelPluginStore', {
+    extend: 'Ext.data.Store',
+    alias: 'store.UiCustomPanelPluginStore',
+    model: 'Coon.uielement.component.settings.plugin.UiCustomPanelPluginModel',
+});

package/src/version.js

@@ -1,4 +1,4 @@
 Ext.define('Coon.version', {
     singleton: true,
-    number: '2.7.53',
+    number: '2.7.55',
 });