add extjs 6.0.1 sources

[extjs.git] / extjs / classic / classic / src / grid / feature / GroupStore.js

/**\r
 * Private record store class which takes the place of the view's data store to provide a grouped\r
 * view of the data when the Grouping feature is used.\r
 *\r
 * Relays granular mutation events from the underlying store as refresh events to the view.\r
 *\r
 * On mutation events from the underlying store, updates the summary rows by firing update events on the corresponding\r
 * summary records.\r
 * @private\r
 */\r
Ext.define('Ext.grid.feature.GroupStore', {\r
    extend: 'Ext.util.Observable',\r
\r
    isStore: true,\r
\r
    // Number of records to load into a buffered grid before it has been bound to a view of known size\r
    defaultViewSize: 100,\r
\r
    // Use this property moving forward for all feature stores. It will be used to ensure\r
    // that the correct object is used to call various APIs. See EXTJSIV-10022.\r
    isFeatureStore: true,\r
\r
    badGrouperKey: '[object Object]',\r
\r
    constructor: function(groupingFeature, store) {\r
        var me = this;\r
\r
        me.callParent();\r
        me.groupingFeature = groupingFeature;\r
        me.bindStore(store);\r
\r
        // We don't want to listen to store events in a locking assembly.\r
        if (!groupingFeature.grid.isLocked) {\r
            me.bindViewStoreListeners();\r
        }\r
    },\r
\r
    bindStore: function(store) {\r
        var me = this;\r
\r
        if (!store || me.store !== store) {\r
            Ext.destroy(me.storeListeners);\r
            me.store = null;\r
        }\r
\r
        if (store) {\r
            me.storeListeners = store.on({\r
                groupchange: me.onGroupChange,\r
                remove: me.onRemove,\r
                add: me.onAdd,\r
                idchanged: me.onIdChanged,\r
                update: me.onUpdate,\r
                refresh: me.onRefresh,\r
                clear: me.onClear,\r
                scope: me,\r
                destroyable: true\r
            });\r
\r
            me.store = store;\r
            me.processStore(store);\r
        }\r
    },\r
\r
    bindViewStoreListeners: function () {\r
        var view = this.groupingFeature.view,\r
            listeners = view.getStoreListeners();\r
\r
        listeners.scope = view;\r
\r
        this.on(listeners);\r
    },\r
\r
    processStore: function (store) {\r
        var me = this,\r
            groupingFeature = me.groupingFeature,\r
            collapseAll = groupingFeature.startCollapsed,\r
            data = me.data,\r
            ExtArray = Ext.Array,\r
            indexOf = ExtArray.indexOf,\r
            splice = ExtArray.splice,\r
            groups = store.getGroups(),\r
            groupCount = groups ? groups.length : 0,\r
            groupField = store.getGroupField(),\r
            // We need to know all of the possible unique group names. The only way to know this is to check itemGroupKeys, which will keep a\r
            // list of all potential group names. It's not enough to get the key of the existing groups since the collection may be filtered.\r
            groupNames = groups && ExtArray.unique(Ext.Object.getValues(groups.itemGroupKeys)),\r
            isCollapsed = false,\r
            oldMetaGroupCache = groupingFeature.getCache(),\r
            metaGroup, metaGroupCache, i, len, featureGrouper, group, groupName, groupPlaceholder, key, modelData, Model;\r
\r
        groupingFeature.invalidateCache();\r
        // Get a new cache since we invalidated the old one.\r
        metaGroupCache = groupingFeature.getCache();\r
\r
        // Persist what we can.\r
        if (oldMetaGroupCache.map) {\r
            metaGroupCache.map = oldMetaGroupCache.map;\r
        }\r
\r
        if (data) {\r
            data.clear();\r
        } else {\r
            data = me.data = new Ext.util.Collection({\r
                rootProperty: 'data',\r
                extraKeys: {\r
                    byInternalId: {\r
                        property: 'internalId',\r
                        rootProperty: ''\r
                    }\r
                }\r
            });\r
        }\r
\r
        if (store.getCount()) {\r
            // Upon first process of a loaded store, clear the "always" collapse" flag\r
            groupingFeature.startCollapsed = false;\r
\r
            if (groupCount > 0) {\r
                Model = store.getModel();\r
\r
                for (i = 0; i < groupCount; i++) {\r
                    group = groups.getAt(i);\r
\r
                    // Cache group information by group name.\r
                    key = group.getGroupKey();\r
\r
                    // If there is no store grouper and the groupField looks up a complex data type, the store will stringify it and\r
                    // the group name will be '[object Object]'. To fix this, groupers can be defined in the feature config, so we'll\r
                    // simply do a lookup here and re-group the store.\r
                    //\r
                    // Note that if a grouper wasn't defined on the feature that we'll just default to the old behavior and still try\r
                    // to group.\r
                    if (me.badGrouperKey === key && (featureGrouper = groupingFeature.getGrouper(groupField))) {\r
                        // We must reset the value b/c store.group() will call into this method again!\r
                        groupingFeature.startCollapsed = collapseAll;\r
                        store.group(featureGrouper);\r
                        return;\r
                    }\r
\r
                    // Persist what we can.\r
                    metaGroup = metaGroupCache[key] = oldMetaGroupCache[key] || groupingFeature.getMetaGroup(key);\r
\r
                    // Remove the group name from the list of all possible group names. This is how we'll know if any remaining groups\r
                    // in the old cache should be retained.\r
                    splice(groupNames, indexOf(groupNames, key), 1);\r
\r
                    isCollapsed = metaGroup.isCollapsed = collapseAll || metaGroup.isCollapsed;\r
\r
                    // If group is collapsed, then represent it by one dummy row which is never visible, but which acts\r
                    // as a start and end group trigger.\r
                    if (isCollapsed) {\r
                        modelData = {};\r
                        modelData[groupField] = key;\r
                        metaGroup.placeholder = groupPlaceholder = new Model(modelData);\r
                        groupPlaceholder.isNonData = groupPlaceholder.isCollapsedPlaceholder = true;\r
                        groupPlaceholder.group = group;\r
                        data.add(groupPlaceholder);\r
                    }\r
                    // Expanded group - add the group's child records.\r
                    else {\r
                        data.insert(me.data.length, group.items);\r
                    }\r
                }\r
\r
                if (groupNames.length) {\r
                    // The remainig group names in this list may refer to potential groups that have been filtered/sorted. If the group\r
                    // name exists in the old cache, we must retain it b/c the groups could be recreated. See EXTJS-15755 for an example.\r
                    // Anything left in the old cache can be discarded.\r
                    for (i = 0, len = groupNames.length; i < len; i++) {\r
                        groupName = groupNames[i];\r
                        metaGroupCache[groupName] = oldMetaGroupCache[groupName];\r
                    }\r
                }\r
\r
                oldMetaGroupCache = null;\r
            } else {\r
                data.add(store.getRange());\r
            }\r
        }\r
    },\r
\r
    isCollapsed: function(name) {\r
        return this.groupingFeature.getCache()[name].isCollapsed;\r
    },\r
\r
    isLoading: function() {\r
        return false;\r
    },\r
\r
    getData: function() {\r
        return this.data;\r
    },\r
\r
    getCount: function() {\r
        return this.data.getCount();\r
    },\r
\r
    getTotalCount: function() {\r
        return this.data.getCount();\r
    },\r
\r
    // This class is only created for fully loaded, non-buffered stores\r
    rangeCached: function(start, end) {\r
        return end < this.getCount();\r
    },\r
\r
    getRange: function(start, end, options) {\r
        // Collection's getRange is exclusive. Do NOT mutate the value: it is passed to the callback.\r
        var result = this.data.getRange(start, Ext.isNumber(end) ? end + 1 : end);\r
\r
        if (options && options.callback) {\r
            options.callback.call(options.scope || this, result, start, end, options);\r
        }\r
        return result;\r
    },\r
\r
    getAt: function(index) {\r
        return this.data.getAt(index);\r
    },\r
\r
    /**\r
     * Get the Record with the specified id.\r
     *\r
     * This method is not affected by filtering, lookup will be performed from all records\r
     * inside the store, filtered or not.\r
     *\r
     * @param {Mixed} id The id of the Record to find.\r
     * @return {Ext.data.Model} The Record with the passed id. Returns null if not found.\r
     */\r
    getById: function(id) {\r
        return this.store.getById(id);\r
    },\r
\r
    /**\r
     * @private\r
     * Get the Record with the specified internalId.\r
     *\r
     * This method is not effected by filtering, lookup will be performed from all records\r
     * inside the store, filtered or not.\r
     *\r
     * @param {Mixed} internalId The id of the Record to find.\r
     * @return {Ext.data.Model} The Record with the passed internalId. Returns null if not found.\r
     */\r
    getByInternalId: function (internalId) {\r
        // Find the record in the base store.\r
        // If it was a placeholder, then it won't be there, it will be in our data Collection.\r
        return this.store.getByInternalId(internalId) || this.data.byInternalId.get(internalId);\r
    },\r
\r
    expandGroup: function(group) {\r
        var me = this,\r
            groupingFeature = me.groupingFeature,\r
            metaGroup, placeholder, startIdx, items;\r
\r
        if (typeof group === 'string') {\r
            group = groupingFeature.getGroup(group);\r
        }\r
\r
        if (group) {\r
            items = group.items;\r
            metaGroup = groupingFeature.getMetaGroup(group);\r
            placeholder = metaGroup.placeholder;\r
        }\r
\r
        if (items.length && (startIdx = me.data.indexOf(placeholder)) !== -1) {\r
            // Any event handlers must see the new state\r
            metaGroup.isCollapsed = false;\r
            me.isExpandingOrCollapsing = 1;\r
\r
            // Remove the collapsed group placeholder record\r
            me.data.removeAt(startIdx);\r
\r
            // Insert the child records in its place\r
            me.data.insert(startIdx, group.items);\r
\r
            // Update views\r
            me.fireEvent('replace', me, startIdx, [placeholder], group.items);\r
\r
            me.fireEvent('groupexpand', me, group);\r
            me.isExpandingOrCollapsing = 0;\r
        }\r
    },\r
\r
    collapseGroup: function(group) {\r
        var me = this,\r
            groupingFeature = me.groupingFeature,\r
            startIdx,\r
            placeholder,\r
            len, items;\r
\r
        if (typeof group === 'string') {\r
            group = groupingFeature.getGroup(group);\r
        }\r
\r
        if (group) {\r
            items = group.items;\r
        }\r
\r
        if (items && (len = items.length) && (startIdx = me.data.indexOf(items[0])) !== -1) {\r
\r
            // Any event handlers must see the new state\r
            groupingFeature.getMetaGroup(group).isCollapsed = true;\r
            me.isExpandingOrCollapsing = 2;\r
\r
            // Remove the group child records\r
            me.data.removeAt(startIdx, len);\r
\r
            // Insert a placeholder record in their place\r
            me.data.insert(startIdx, placeholder = me.getGroupPlaceholder(group));\r
\r
            // Update views\r
            me.fireEvent('replace', me, startIdx, items, [placeholder]);\r
\r
            me.fireEvent('groupcollapse', me, group);\r
            me.isExpandingOrCollapsing = 0;\r
        }\r
    },\r
\r
    getGroupPlaceholder: function(group) {\r
        var metaGroup = this.groupingFeature.getMetaGroup(group);\r
\r
        if (!metaGroup.placeholder) {\r
            var store = this.store,\r
                Model = store.getModel(),\r
                modelData = {},\r
                key = group.getGroupKey(),\r
                groupPlaceholder;\r
\r
            modelData[store.getGroupField()] = key;\r
            groupPlaceholder = metaGroup.placeholder = new Model(modelData);\r
            groupPlaceholder.isNonData = groupPlaceholder.isCollapsedPlaceholder = true;\r
\r
            // Let's poke the groupKey onto the record instead of storing a reference to the group\r
            // itself. The latter can cause problems if the store is reloaded and the referenced\r
            // group is lost.\r
            // See EXTJS-18655\r
            groupPlaceholder.groupKey = key;\r
        }\r
\r
        return metaGroup.placeholder;\r
    },\r
\r
    // Find index of record in group store.\r
    // If it's in a collapsed group, then it's -1, not present\r
    indexOf: function(record) {\r
        var ret = -1;\r
        if (!record.isCollapsedPlaceholder) {\r
            ret = this.data.indexOf(record);\r
        }\r
        return ret;\r
    },\r
\r
    contains: function(record) {\r
        return this.indexOf(record) > -1;\r
    },\r
\r
    indexOfPlaceholder: function(record) {\r
        return this.data.indexOf(record);\r
    },\r
\r
    /**\r
     * Get the index within the store of the Record with the passed id.\r
     *\r
     * Like #indexOf, this method is effected by filtering.\r
     *\r
     * @param {String} id The id of the Record to find.\r
     * @return {Number} The index of the Record. Returns -1 if not found.\r
     */\r
    indexOfId: function(id) {\r
        return this.data.indexOfKey(id);\r
    },\r
\r
    /**\r
     * Get the index within the entire dataset. From 0 to the totalCount.\r
     *\r
     * Like #indexOf, this method is effected by filtering.\r
     *\r
     * @param {Ext.data.Model} record The Ext.data.Model object to find.\r
     * @return {Number} The index of the passed Record. Returns -1 if not found.\r
     */\r
    indexOfTotal: function(record) {\r
        return this.store.indexOf(record);\r
    },\r
\r
    onAdd: function(store) {\r
        var me = this;\r
\r
        me.processStore(me.store);\r
        me.fireEvent('refresh', me);\r
\r
        // Don't allow the event to propagate or another group will be added upstream by tableview!\r
        return false;\r
    },\r
\r
    onClear: function(store, records, startIndex) {\r
        var me = this;\r
\r
        me.processStore(me.store);\r
        me.fireEvent('clear', me);\r
    },\r
\r
    onIdChanged: function(store, rec, oldId, newId) {\r
        this.data.updateKey(rec, oldId);\r
    },\r
\r
    onRefresh: function() {\r
        this.processStore(this.store);\r
        this.fireEvent('refresh', this);\r
    },\r
\r
    onRemove: function() {\r
        var me = this;\r
\r
        me.processStore(me.store);\r
        me.fireEvent('refresh', me);\r
\r
        // Don't allow the event to propagate or the view will not be fully updated.\r
        return false;\r
    },\r
\r
    onUpdate: function(store, record, operation, modifiedFieldNames) {\r
        var me = this,\r
            groupingFeature = me.groupingFeature,\r
            group, metaGroup, firstRec, lastRec, items;\r
\r
        // The grouping field value has been modified.\r
        // This could either move a record from one group to another, or introduce a new group.\r
        // Either way, we have to refresh the grid\r
        if (store.isGrouped()) {\r
            // Updating a single record, attach the group to the record for Grouping.setupRowData to use.\r
            group = record.group = groupingFeature.getGroup(record);\r
\r
            // Make sure that still we have a group and that the last member of it wasn't just filtered.\r
            // See EXTJS-18083.\r
            if (group) {\r
                metaGroup = groupingFeature.getMetaGroup(record);\r
\r
                if (modifiedFieldNames && Ext.Array.contains(modifiedFieldNames, groupingFeature.getGroupField())) {\r
                    return me.onRefresh(me.store);\r
                }\r
\r
                // Fire an update event on the collapsed metaGroup placeholder record\r
                if (metaGroup.isCollapsed) {\r
                    me.fireEvent('update', me, metaGroup.placeholder);\r
                }\r
\r
                // Not in a collapsed group, fire update event on the modified record\r
                // and, if in a grouped store, on the first and last records in the group.\r
                else {\r
                    Ext.suspendLayouts();\r
\r
                    // Propagate the record's update event\r
                    me.fireEvent('update', me, record, operation, modifiedFieldNames);\r
\r
                    // Fire update event on first and last record in group (only once if a single row group)\r
                    // So that custom header TPL is applied, and the summary row is updated\r
                    items = group.items;\r
                    firstRec = items[0];\r
                    lastRec = items[items.length - 1];\r
\r
                    // Fire an update on the first and last row in the group (ensure we don't refire update on the modified record).\r
                    // This is to give interested Features the opportunity to update the first item (a wrapped group header + data row),\r
                    // and last item (a wrapped data row + group summary)\r
                    if (firstRec !== record) {\r
                        firstRec.group = group;\r
                        me.fireEvent('update', me, firstRec, 'edit', modifiedFieldNames);\r
                        delete firstRec.group;\r
                    }\r
                    if (lastRec !== record && lastRec !== firstRec && groupingFeature.showSummaryRow) {\r
                        lastRec.group = group;\r
                        me.fireEvent('update', me, lastRec, 'edit', modifiedFieldNames);\r
                        delete lastRec.group;\r
                    }\r
                    Ext.resumeLayouts(true);\r
                }\r
            }\r
\r
            delete record.group;\r
        } else {\r
            // Propagate the record's update event\r
            me.fireEvent('update', me, record, operation, modifiedFieldNames);\r
        }\r
    },\r
\r
    // Relay the groupchange event\r
    onGroupChange: function(store, grouper) {\r
        if (!grouper) {\r
            this.processStore(store);\r
        }\r
        this.fireEvent('groupchange', store, grouper);\r
    },\r
\r
    destroy: function() {\r
        var me = this;\r
\r
        me.bindStore(null);\r
        Ext.destroyMembers(me, 'data', 'groupingFeature');\r
\r
        me.callParent();\r
    }\r
});\r
\r