ru.coon 2.8.65 → 3.0.2

package/src/report/plugin/grid/AddFilterConditionPlugin.js

@@ -7,63 +7,213 @@ Ext.define('Coon.report.plugin.grid.AddFilterConditionPlugin', {
     ],
     configurePanelWizard: 'AddFilterConditionPluginConfigPanel',
 
-    filters: new Map(),
+    columnFilterTypes: undefined,
+    filters: undefined,
+    filterAllVisible: true,
+    filterOptions: {},
 
     init: function(grid) {
+        this.filters = new Map();
         this.grid = grid;
-        this.grid.on('clearAllFilters', this.clearAllFilters, this);
-        grid.on('added', function(grid) {
-            const contextMenu = grid.contextMenu;
-            contextMenu.add(new Ext.menu.Item({
-                iconCls: 'svg-icon svg-icon-filter-alt',
-                text: 'фильтр по значению',
-                itemId: 'filterByCellValue',
-                handler: this.addFilter.bind(this),
-            }));
-            contextMenu.add(new Ext.menu.Item({
-                originalText: 'Отменить фильтр',
-                hidden: true,
-                itemId: 'cancelCurrentColumnFilter',
-                handler: this.clearCurrentColumnFilter.bind(this),
-            }));
-            contextMenu.add(new Ext.menu.Item({
-                text: 'Отменить все',
-                itemId: 'cancelAllFilters',
-                handler: this.clearAllFilters.bind(this),
-            }));
-        }, this);
-        grid.on('load', function() {
-            this.clearAllFilters();
-        }, this);
+        this.columnFilterTypes = this.getColumnFilterTypes();
+        grid.on('clearAllFilters', this.clearAllFilters, this);
+        grid.on('added', this.addMenuItems, this);
+        grid.on('load', this.clearAllFilters, this);
         grid.contextMenu.on('requestMenuItems', this.onShowMenu, this);
     },
+    addMenuItems(grid) {
+        const contextMenu = grid.contextMenu;
+        const infoMenuItem = Ext.widget('InfoMenuItem', {
+            itemId: 'infoMenuItem',
+            originalText: '', // 'Фильтр не задан',
+            forbiddenText: 'Фильтр не разрешен',
+            isItemHidden: this.isInfoMenuItemHidden.bind(this),
+            isItemDisabled: this.isInfoMenuItemDisabled.bind(this),
+        });
+        infoMenuItem.on('removefilter', function() {
+            this.clearCurrentColumnFilter();
+            contextMenu.hide();
+        }, this);
+        contextMenu.addToAdvancedSearch(infoMenuItem);
+        contextMenu.addToAdvancedSearch(new Ext.menu.Item({
+            text: 'Фильтр по значению',
+            itemId: 'filterByCellValue',
+            handler: this.filterByCellValue.bind(this),
+            isItemHidden: this.isFilterByCellValueHidden.bind(this),
+            isItemDisabled: this.isFilterByCellValueDisabled.bind(this),
+        }));
+        const filterMenu = Ext.widget('FilterMenu', {
+            listeners: {
+                beforeshow: this.createSearchMenuItem.bind(this),
+                resize: this.onResizeSearchSubMenu.bind(this),
+            },
+        });
+
+        contextMenu.addToAdvancedSearch({
+            text: 'Поиск',
+            iconCls: 'svg-icon svg-icon-magnifying-glass',
+            itemId: 'searchByValueItem',
+            menu: filterMenu,
+            isItemHidden: this.isSearchByValueItemHidden.bind(this),
+            isItemDisabled: this.isSearchByValueItemDisabled.bind(this),
+        });
+        // contextMenu.addToAdvancedSearch(new Ext.menu.Item({
+        //     text: 'Расширенный поиск',
+        //     itemId: 'advancedSearch',
+        //     handler: this.advancedSearch.bind(this),
+        //     isItemHidden: () => false,
+        //     isItemDisabled: () => false,
+        // }));
+        contextMenu.addToAdvancedSearch(new Ext.menu.Item({
+            text: 'Очистить все фильтры',
+            itemId: 'cancelAllFilters',
+            handler: this.clearAllFilters.bind(this),
+            isItemHidden: this.isCancelAllFiltersHidden.bind(this),
+            isItemDisabled: this.isCancelAllFiltersDisabled.bind(this),
+        }));
+    },
+
+    getColumnFilterTypes() {
+        const columnFilterTypes = {};
+        this.grid.getColumns().forEach((column) => {
+            if (column.dataIndex && column.filter) {
+                columnFilterTypes[column.dataIndex] = column.filter && column.filter.type;
+            }
+        });
+        return columnFilterTypes;
+    },
+
+    canUseCombo() {
+        const col = this.column;
+        const info = this.grid.reportPanel.serviceMap.maps.get(col.dataIndex);
+        // Можно использовать как список
+        const canUsedAsListFilter = Ext.isObject(info) && !info.isExtremum && !info.isFull;
+        return !!(canUsedAsListFilter && col.filter.type === 'string');
+    },
+
+    onResizeSearchSubMenu(menu) {
+        const searchByValueItem = this.findMenuItem('searchByValueItem');
+        menu.alignTo(searchByValueItem, menu._lastAlignToPos);
+    },
+
+    getGridColumns() {
+        return this.grid.getVisibleColumns();
+    },
 
     onShowMenu({record, cellIndex}) {
-        const cancelAllItem = this.findMenuItem('cancelAllFilters');
-        cancelAllItem && cancelAllItem.setDisabled(this.filters.size === 0);
-        if (this.filters.size) {
-            this.findMenuItem('cancelCurrentColumnFilter').hide();
-        }
-        this.findMenuItem('filterByCellValue').hide();
-        record && this.setMenuText(record, cellIndex);
+        const columns = this.grid.getColumns();
+        const column = columns.length && columns[cellIndex];
+        this.column = column;
+        this.columnValue = record && record.get(column.dataIndex);
+        this.setMenuText();
+    },
+
+    filterByCellValue: function() {
+        const key = this.getColumnKey();
+        this.addFilter(key, 'eq', this.columnValue);
+        this.doFilter();
+        this.changeColumnStyle(this.column);
     },
 
-    addFilter: function() {
+    addFilter: function(key, operator, value) {
         if (!this.grid) {
             return;
         }
-        const key = this.getColumnKey();
-        this.filters.set(key, this.columnValue);
+        this.filters.set(key, {
+            value,
+            operator,
+        });
+    },
+
+    getSearchPanel() {
+        const panel = Ext.widget('AdvancedSearchPanel', {
+            reportGrid: this.grid,
+            filterAllVisible: this.filterAllVisible,
+            filterOptions: this.filterOptions,
+        });
+        const win = Ext.widget('WindowWrap', {
+            maximizable: false,
+            resizable: false,
+            autoShow: true,
+            closeAction: 'close',
+            width: 600,
+            minHeight: 300,
+            alwaysInCenter: true,
+            items: panel,
+        });
+
+        panel.on('addfilters', this.addFilters, this);
+        panel.on('addremovefilter', () => {
+            win.center();
+        });
+
+        return panel;
+    },
+
+    addFilters(filters) {
+        Coon.log.log('addfilters', filters);
+        this.filters.clear();
+        if (Array.isArray(filters) && filters.length) {
+            const reversed = Ext.Array.clone(filters).reverse();
+            reversed.forEach(function(filter) {
+                this.addFilter(filter.dataIndex, filter.operator, filter.value);
+            }, this);
+        }
         this.doFilter();
-        this.changeColumnStyle(this.column);
+        this.changeColumnsStyle();
+    },
+
+    // Расширенный поиск
+    advancedSearch() {
+        const usedFilterConfig = {};
+        this.filters.forEach(function(value, key) {
+            usedFilterConfig[key] = {
+                isCurrent: this.column && this.column.dataIndex === key,
+                dataIndex: key,
+                type: this.columnFilterTypes[key],
+                operator: value.operator,
+                value: value.value,
+            };
+        }, this);
+        const isCurrentColumnFilterable = this.isFilterable();
+        const panel = this.getSearchPanel();
+
+        const newFilterConfig = {};
+        if (this.column) {
+            const dataIndex = this.column.dataIndex;
+            newFilterConfig.value = this.columnValue;
+            newFilterConfig.isCurrentColumnFilterable = isCurrentColumnFilterable;
+            newFilterConfig.currentColumnDataIndex = dataIndex;
+            const filterType = this.columnFilterTypes[dataIndex];
+            if (filterType === 'string') {
+                newFilterConfig.useCombo = /* this.filters.size === 0 &&*/ this.canUseCombo();
+            }
+        }
+
+        panel.getController().doInit(usedFilterConfig, newFilterConfig);
     },
 
     changeColumnStyle(column) {
         if (this.filters.has(column.dataIndex)) {
+            if (!column.tdCls.includes('filtered-cell')) {
+                column.tdCls = column.tdCls + ' filtered-cell';
+            }
             column.addCls('filtered-column');
         } else {
+            column.tdCls = Ext.isString(column.tdCls) && column.tdCls.replace('filtered-cell', ' ');
             column.removeCls('filtered-column');
         }
+        this.grid.getView().refresh();
+    },
+
+    changeColumnsStyle() {
+        this.grid.getColumns().forEach(function(column) {
+            const dataIndex = column.dataIndex;
+            if (!dataIndex) {
+                return;
+            }
+            this.changeColumnStyle(column);
+        }, this);
     },
 
     doFilter() {
@@ -72,31 +222,158 @@ Ext.define('Coon.report.plugin.grid.AddFilterConditionPlugin', {
             this.grid.getStore().clearFilter();
             this.grid.getStore().resumeEvents();
             this.grid.getStore().filter(
-                [...this.filters.entries()].map(function([property, value]) {
-                    if (Ext.isString(value) || Ext.isNumber(value)) {
-                        return {property, operator: '=', value};
-                    } else if (Ext.isDate(value)) {
-                        return new Ext.util.Filter({
-                            filterFn: function(rec) {
-                                return Ext.Date.format(rec.get(property), Coon.format.dateTime) === Ext.Date.format(value, Coon.format.dateTime);
-                            },
-                        }, this);
-                    } else {
-                        return new Ext.util.Filter({
-                            filterFn: function(rec) {
-                                return rec.get(property) === value;
-                            },
-                        }, this);
-                    }
-                }, this)
+                this.createFilterConfiguration()
             );
         } else {
             this.grid.getStore().clearFilter();
         }
+        this.rebuildServiceMap();
+    },
+
+    rebuildServiceMap() {
+        const serviceMap = this.grid.reportPanel.serviceMap;
+        if (!serviceMap) {
+            return;
+        }
+        const myMask = new Ext.LoadMask({
+            target: this.grid,
+            msg: 'Перестройка справочников...',
+        });
+        myMask.show();
+        serviceMap.clearData.call(serviceMap);
+        this.grid.getStore().each((record) => {
+            const fn = serviceMap.getConvert();
+            if (Ext.isFunction(fn)) {
+                fn.call(serviceMap, undefined, record);
+            }
+        });
+        myMask.hide();
     },
 
-    isColumnFiltered() {
-        return this.filters.has(this.getColumnKey());
+    prepareFilters() {
+        const newFilters = [];
+        for (const [property, filterCfg] of [...this.filters.entries()]) {
+            const operator = filterCfg.operator;
+            const value = filterCfg.value;
+            if (operator === 'between') {
+                const fromValue = value[0];
+                const toValue = value[1];
+                const newCfg = Ext.clone(filterCfg);
+                if (fromValue) {
+                    newCfg.id = property + '_from';
+                    newCfg.operator = 'ge';
+                    newCfg.value = fromValue;
+                    newFilters.push([property, newCfg]);
+                }
+                const newCfgTo = Ext.clone(filterCfg);
+                if (toValue) {
+                    newCfg.id = property + '_to';
+                    newCfgTo.operator = 'le';
+                    newCfgTo.value = toValue;
+                    newFilters.push([property, newCfgTo]);
+                }
+            } else {
+                newFilters.push([property, filterCfg]);
+            }
+        }
+        return newFilters;
+    },
+
+    createFilterConfiguration() {
+        const store = this.grid.getStore();
+        const fields = store.config.fields;
+        const getFieldType = function(dataIndex) {
+            const found = Array.isArray(fields) && fields.find((field) => field.name === dataIndex);
+            return found && found.type;
+        };
+
+        return this.prepareFilters().map(function([property, filterCfg]) {
+            const value = filterCfg.value;
+            const id = filterCfg.id;
+            const operator = filterCfg.operator;
+            const column = this.grid.getColumns().find((column) => column.dataIndex===property);
+            const filterType = this.columnFilterTypes[property];
+            const fieldType = getFieldType(column.dataIndex);
+            if (operator === 'notfilled') {
+                return new Ext.util.Filter({
+                    filterFn: (rec) => {
+                        return Ext.isEmpty(rec.get(property));
+                    },
+                });
+            } else if (filterType === 'list' && Array.isArray(value)) {
+                return {property, operator, value};
+            } else if (operator === 'likefrom') {
+                return new Ext.util.Filter({
+                    filterFn: function(rec) {
+                        return Ext.isString(rec.get(property)) && rec.get(property).startsWith(value);
+                    },
+                });
+            } else if (filterType === 'numeric') {
+                return this.createNumberFilter(property, operator, value, fieldType, id);
+            } else if (Ext.isDate(value) && filterType === 'date') {
+                return this.createDateFilter(property, operator, value, fieldType, id);
+            } else if (Ext.isString(value) || Ext.isNumber(value)) {
+                return {property, operator: operator || '=', value};
+            } else {
+                return new Ext.util.Filter({
+                    filterFn: function(rec) {
+                        return rec.get(property) === value;
+                    },
+                });
+            }
+        }, this);
+    },
+
+    /**
+     * Создание фильтра с числовым значением
+     * @param {String} property - dataIndex поля
+     * @param {String} operator оператор сравнения (lt, gt, ne, eq и другие)
+     * @param {Number} value значение фильтра
+     * @param {String} fieldType - тип поля (float, string)
+     * @param {String} id - id фильтра (фильтр по диапазону реализуется двумя фильтрами по одной колонке. id нужен, чтобы фильтры отличались)
+     * @returns {Object} конфигурация фильтра
+     */
+    createNumberFilter(property, operator, value, fieldType, id) {
+        if (fieldType==='float') {
+            return {id, property, operator, value};
+        } else if (fieldType==='string') {
+            return {
+                id, property, operator, value, fieldType,
+                // конвертация сравниваемых значений
+                convert: function(val) {
+                    if (Ext.isString(val)) {
+                        return parseFloat(val);
+                    }
+                    return val;
+                },
+            };
+        }
+    },
+
+    /**
+     * Создание фильтра со значением типа Date
+     * @param {String} property - dataIndex поля
+     * @param {String} operator оператор сравнения (lt, gt, ne, eq и другие)
+     * @param {Date} value значение фильтра
+     * @param {String} fieldType - тип поля (date, string)
+     * @param {String} id - id фильтра (фильтр по диапазону реализуется двумя фильтрами по одной колонке. id нужен, чтобы фильтры отличались)
+     * @returns {Object} конфигурация фильтра
+     */
+    createDateFilter(property, operator, value, fieldType, id) {
+        if (fieldType==='date') {
+            return {id, property, operator, value};
+        } else if (fieldType==='string') {
+            return {
+                id, property, operator, value, fieldType,
+                // конвертация сравниваемых значений
+                convert: function(val) {
+                    if (Ext.isString(val) && val) {
+                        return Ext.Date.parse(val, Coon.format.date);
+                    }
+                    return val;
+                },
+            };
+        }
     },
 
     findMenuItem: function(findBy) {
@@ -109,13 +386,21 @@ Ext.define('Coon.report.plugin.grid.AddFilterConditionPlugin', {
     },
 
     clearAllFilters: function() {
+        if (this.filters.size === 0) {
+            return;
+        }
         this.filters.clear();
         this.doFilter();
+
+        let needRefresh = false;
         this.grid.getColumns().forEach((column) => {
             if (column.hasCls('filtered-column')) {
                 column.removeCls('filtered-column');
+                column.tdCls = Ext.isString(column.tdCls) && column.tdCls.replace('filtered-cell', ' ');
+                needRefresh = true;
             }
         });
+        needRefresh && this.grid.getView().refresh();
     },
 
     clearCurrentColumnFilter: function() {
@@ -125,10 +410,13 @@ Ext.define('Coon.report.plugin.grid.AddFilterConditionPlugin', {
     },
 
     isFilterable: function() {
-        if (!this.filterOptions[this.column.dataIndex]) {
+        if (!this.column) {
+            return false;
+        }
+        if (!this.filterAllVisible && !this.filterOptions[this.column.dataIndex]) {
+            Coon.log.debug(`Фильтрация по колонке ${this.column.dataIndex} запрещена конфигурацией`);
             return false;
         }
-
         if (Array.isArray(this.columnValue) || Ext.isObject(this.columnValue)) {
             Coon.log.debug('Фильтрация по значению из ячейки невозможна. Сложный тип данных');
             return false;
@@ -140,51 +428,206 @@ Ext.define('Coon.report.plugin.grid.AddFilterConditionPlugin', {
         return true;
     },
 
-    getValueText() {
-        if (typeof this.columnValue !== true && this.columnValue) {
-            return this.columnValue;
+    getValueText(value) {
+        if (Ext.isDate(value)) {
+            return Ext.Date.format(value, this.column.format || Coon.format.dateTime);
+        }
+        if (Ext.isNumber(value)) {
+            return value;
         }
-        if (typeof this.columnValue === 'boolean') {
-            return this.columnValue ? 'истинно' : 'ложно';
+        if (value !== true && value) {
+            return value;
         }
-        if (this.columnValue === null || this.columnValue === undefined || this.columnValue === '') {
+        if (typeof value === 'boolean') {
+            const booleanLabels = this.column ? {trueText: this.column.trueText, falseText: this.column.falseText}: {};
+            return value ? booleanLabels.trueText || 'да' : booleanLabels.falseText || 'нет';
+        }
+        if (value === null || value === undefined || value === '') {
             return 'пустое значение';
         }
     },
 
-    setMenuText(record, cellIndex) {
+    setMenuText() {
         const contextMenu = this.grid.contextMenu;
-        const columns = this.grid.getColumns();
-        const column = columns.length && columns[cellIndex];
-        if (!column) {
+        if (!this.column) {
             return;
         }
-        this.column = column;
-        this.columnValue = record.get(column.dataIndex);
+        const infoMenuItem = contextMenu.down('#infoMenuItem');
+        infoMenuItem.removeQTip();
+        infoMenuItem.setFilterText(infoMenuItem.originalText);
+        infoMenuItem.setFilterPrefix('');
 
-        const cancelCurrentItem = this.findMenuItem('cancelCurrentColumnFilter');
-        cancelCurrentItem.hide();
+        const currentColumnFilter = this.filters.get(this.getColumnKey());
+        const formatFilterValue = (value) => {
+            return Ext.isDate(value) ? Ext.Date.format(value, this.column.format || Coon.format.dateTime): value;
+        };
 
         const foundMenuItem = contextMenu.down('#filterByCellValue');
-        foundMenuItem.show();
-        if (this.filters.size && this.filters.get(this.getColumnKey()) === this.columnValue) {
-            foundMenuItem.hide();
-            cancelCurrentItem.setText(`${cancelCurrentItem.originalText} по значению: ${this.getValueText()}`);
-            cancelCurrentItem.show();
-        }
-
-        if (this.isFilterable()) {
-            foundMenuItem.setDisabled(false);
-            if (Ext.isDate(this.columnValue)) {
-                foundMenuItem.setText(`фильтр по "${Ext.Date.format(this.columnValue, column.format || Coon.format.dateTime)}"`);
-            } else if (Ext.isEmpty(this.columnValue)) {
-                foundMenuItem.setText(`фильтр по пустому значению`);
+        if (!this.isFilterable()) {
+            infoMenuItem.buttonSetHidden(true);
+            infoMenuItem.setFilterText(infoMenuItem.forbiddenText);
+            this.column.config && infoMenuItem.setColumnName(this.column.config.text);
+            return;
+        } else {
+            infoMenuItem.buttonSetHidden(false);
+            if (Ext.isEmpty(this.columnValue)) {
+                foundMenuItem.setText(`Фильтр по пустому значению`);
             } else {
-                foundMenuItem.setText(`фильтр по "${this.columnValue}"`);
+                foundMenuItem.setText(`<div style="max-width: 300px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">
+                    Фильтр по "${this.getValueText(this.columnValue)}"
+                </div>`);
             }
+        }
+        if (currentColumnFilter) {
+            infoMenuItem.buttonSetHidden(false);
+            const operators = {
+                'ne': 'не равно',
+                'gt': 'больше',
+                'ge': 'больше или равно',
+                'lt': 'меньше',
+                'le': 'меньше или равно',
+                'notfilled': 'не заполнено',
+                'like': 'Содержит',
+                'in': 'Список',
+            };
+            let itemText; let itemPrefix;
+            switch (currentColumnFilter.operator) {
+            case 'between':
+                // Фильтр between может быть задан без одной из границ. Тогда информацию о фильтрации не корректно отображать как диапазон.
+                const operator = currentColumnFilter.operator !== 'between' ?
+                    currentColumnFilter.operator:
+                    Ext.isEmpty(currentColumnFilter.value[0]) ?
+                        'le':
+                        Ext.isEmpty(currentColumnFilter.value[1]) ? 'ge': 'between';
+                const valueStart = formatFilterValue(currentColumnFilter.value[0]);
+                const valueEnd = formatFilterValue(currentColumnFilter.value[1]);
+                if (operator === 'between') {
+                    itemPrefix = 'по диапазону';
+                    itemText = `  &laquo;${valueStart} - ${valueEnd}&raquo;`;
+                } else {
+                    const value = Ext.isEmpty(currentColumnFilter.value[0]) ? currentColumnFilter.value[1] :currentColumnFilter.value[0];
+                    itemPrefix = operators[operator];
+                    itemText = `  &laquo;${this.getValueText(value)}&raquo;`;
+                }
+
+                break;
+            case 'ge':
+            case 'gt':
+            case 'le':
+            case 'lt':
+            case 'ne':
+                itemPrefix = operators[currentColumnFilter.operator];
+                itemText = `&laquo;${this.getValueText(currentColumnFilter.value)}&raquo;`;
+                break;
+            case 'eq':
+                itemPrefix = ' равно ';
+                itemText = `&laquo;${this.getValueText(currentColumnFilter.value)}&raquo;`;
+                break;
+            case 'like':
+                itemPrefix = ' по подстроке ';
+                itemText = `&laquo;${currentColumnFilter.value}&raquo;`;
+                break;
+            case 'in':
+                itemPrefix = 'по списку';
+                itemText = ' ';
+                break;
+            case 'notfilled':
+                itemPrefix = ' не заполнено ';
+                itemText = ' ';
+                break;
+            }
+            infoMenuItem.setColumnName(this.column.config.text);
+            infoMenuItem.setFilterText(itemText);
+            infoMenuItem.setFilterPrefix(itemPrefix);
+            infoMenuItem.setQTip(this.column.config.text, this.getColumnGroup(), itemPrefix, itemText);
         } else {
-            foundMenuItem.setText(`Нет возможности фильтрации`);
-            foundMenuItem.setDisabled(true);
+            infoMenuItem.buttonSetHidden(true);
+            this.column.config && infoMenuItem.setColumnName(this.column.config.text);
         }
     },
+
+    getColumnGroup() {
+        let columnGroup = this.column && this.column.columnGroup;
+        columnGroup = Ext.isString(columnGroup) ? columnGroup.replaceAll(';', ' / ') + ' / ': '';
+        return columnGroup;
+    },
+
+    /**
+     * Создать подменю простого фильтра
+     * @param menu
+     */
+    createSearchMenuItem(menu) {
+        const currentColumnFilter = this.filters.get(this.getColumnKey());
+        const dataIndex = this.column && this.column.dataIndex;
+        const filterType = this.columnFilterTypes[dataIndex];
+        if (dataIndex) {
+            const filter = {
+                dataIndex,
+                operator: undefined,
+                type: filterType,
+                value: undefined,
+            };
+            if (currentColumnFilter) {
+                filter.value = currentColumnFilter.value;
+                filter.operator = currentColumnFilter.operator;
+            } else {
+                filter.value = filterType === 'list' ? [this.columnValue]: this.columnValue;
+                filter.operator = filterType === 'list' ?
+                    'in':
+                    Ext.isEmpty(this.columnValue) ? 'notfilled': 'eq';
+            }
+            if (filterType === 'string') {
+                filter.useCombo = /* this.filters.size === 0 &&*/ this.canUseCombo();
+            }
+            const filterWrapPanelCfg = {
+                filterType,
+                filter,
+                reportGrid: this.grid,
+                cellValue: this.columnValue,
+                dataIndex: this.column.dataIndex,
+            };
+            if (['string', 'numeric', 'date', 'list', 'combo'].includes(filterType)) {
+                filterWrapPanelCfg.width = 600;
+            } else {
+                filterWrapPanelCfg.minWidth = 200;
+            }
+            const menuItem = Ext.widget('FilterWrapPanel', filterWrapPanelCfg);
+            menuItem.on('dofilter', function(value, condition) {
+                Coon.log.log('dofilter', value, condition);
+                this.addFilter(dataIndex, condition, value);
+                this.doFilter();
+                this.changeColumnsStyle();
+                this.grid.contextMenu.hide();
+            }, this);
+            menuItem.on('advancedsearch', this.advancedSearch, this);
+            menu.removeAll();
+            menu.add(menuItem);
+        }
+    },
+
+    isCancelAllFiltersHidden() {
+        return false;
+    },
+    isCancelAllFiltersDisabled() {
+        return this.filters.size === 0;
+    },
+    isInfoMenuItemHidden() {
+        return !this.column;
+    },
+    isInfoMenuItemDisabled() {
+        return false;
+    },
+    isSearchByValueItemHidden() {
+        return !this.column;
+    },
+    isSearchByValueItemDisabled() {
+        return !this.isFilterable();
+    },
+    isFilterByCellValueHidden() {
+        return !this.column || !this.isFilterable() || this.filters.has(this.getColumnKey(this.column));
+    },
+    isFilterByCellValueDisabled() {
+        return false;
+    },
 });
+