/** * A combobox control with support for autocomplete, remote loading, and many other features. * * A ComboBox is like a combination of a traditional HTML text `<input>` field and a `<select>` * field; if the {@link #cfg!editable} config is `true`, then the user is able to type freely * into the field, and/or pick values from a dropdown selection list. * * The user can input any value by default, even if it does not appear in the selection list; * to prevent free-form values and restrict them to items in the list, set * {@link #forceSelection} to `true`. * * The selection list's options are populated from any {@link Ext.data.Store}, including remote * stores. The data items in the store are mapped to each option's displayed text and backing * value via the {@link #valueField} and {@link #displayField} configurations which are applied * to the list via the {@link #cfg!itemTpl}. * * If your store is not remote, i.e. it depends only on local data and is loaded up front, you MUST * set the {@link #queryMode} to `'local'`. * * # Example usage: * * ```javascript * @example({ framework: 'extjs' }) * Ext.create({ * fullscreen: true, * xtype: 'container', * padding: 50, * layout: 'vbox', * items: [{ * xtype: 'combobox', * label: 'Choose State', * queryMode: 'local', * displayField: 'name', * valueField: 'abbr', * * store: [ * { abbr: 'AL', name: 'Alabama' }, * { abbr: 'AK', name: 'Alaska' }, * { abbr: 'AZ', name: 'Arizona' } * ] * }] * }); * ``` * * # Events * * ComboBox fires a select event if an item is chosen from the associated list. If * the ComboBox is configured with {@link #forceSelection}: true, an action event is fired * when the user has typed the ENTER key while editing the field, and a change event on * each keystroke. * * ## Customized combobox * * Both the text shown in dropdown list and text field can be easily customized: *```javascript * @example({ framework: 'extjs' }) * Ext.create({ * fullscreen: true, * xtype: 'container', * padding: 50, * layout: 'vbox', * items: [{ * xtype: 'combobox', * label: 'Choose State', * queryMode: 'local', * displayField: 'name', * valueField: 'abbr', * * // For the dropdown list * itemTpl: '<span role="option" class="x-boundlist-item">{abbr} - {name}</span>', * * // For the content of the text field * displayTpl: '{abbr} - {name}', * * editable: false, // disable typing in the text field * * store: [ * { abbr: 'AL', name: 'Alabama' }, * { abbr: 'AK', name: 'Alaska' }, * { abbr: 'AZ', name: 'Arizona' } * ] * }] * }); * * See also the {@link #cfg!floatedPicker} and {@link #cfg!edgePicker} options for additional * configuration of the options list. * * ``` * ```javascript * @example({framework: 'ext-angular', packages:['ext-angular']}) * import { Component } from '@angular/core' * declare var Ext: any; * * @Component({ * selector: 'app-root-1', * styles: [``], * template: ` * <ExtContainer [layout]='"center"'> * <ExtFormPanel [shadow]> * <ExtComboBox * [width]="200" * [label]='"State"' * [options]='data' * [displayField]='"name"' * [valueField]='"code"' * [queryMode]='"local"' * [labelAlign]='"placeholder"' * [typeAhead] * ></ExtComboBox> * </ExtFormPanel> * </ExtContainer> * }) * export class AppComponent { * data = [ * {"name":"Alabama","abbrev":"AL"}, * {"name":"Alaska","abbrev":"AK"}, * {"name":"Arizona","abbrev":"AZ"} * ]; * } * ``` * ```html * @example({framework: 'ext-web-components', packages:['ext-web-components'], tab: 1 }) * <ext-formpanel * shadow="true" * > * <ext-combobox * width="200" * label="State" * displayField="name" * valueField="code" * queryMode="local" * labelAlign="placeholder" * typeAhead="true" * onready="comboboxfield.comboboxFieldReady" * > * </ext-combobox> * </ext-formpanel> * ``` * ```javascript * @example({framework: 'ext-web-components', packages:['ext-web-components'], tab: 2 }) * import '@sencha/ext-web-components/dist/ext-formpanel.component'; * import '@sencha/ext-web-components/dist/ext-combobox.component'; * * export default class ComboBoxFieldComponent { * constructor() { * this.data = [ * {"name":"Alabama","abbrev":"AL"}, * {"name":"Alaska","abbrev":"AK"}, * {"name":"Arizona","abbrev":"AZ"} * ] * } * comboboxFieldReady(event) { * this.combobox = event.detail.cmp; * this.combobox.setOptions(this.data); * } * } * * window.comboboxfield = new ComboBoxFieldComponent(); * ``` * ```javascript * @example({framework: 'ext-react', packages:['ext-react']}) * import React, { Component } from 'react'; * import { ExtFormPanel, ExtComboBox } from '@sencha/ext-react'; * * export default class MyExample extends Component { * render() { * const data = [ * {"name":"Alabama","abbrev":"AL"}, * {"name":"Alaska","abbrev":"AK"}, * {"name":"Arizona","abbrev":"AZ"} * ] * * return ( * <ExtFormPanel shadow> * <ExtComboBox * width={200} * label="State" * options={data} * displayField="name" * valueField="code" * queryMode="local" * labelAlign="placeholder" * typeAhead * /> * </ExtFormPanel> * ) * } * } * ``` * * @since 6.5.0 */Ext.define('Ext.field.ComboBox', { extend: 'Ext.field.Select', xtype: [ 'combobox', 'comboboxfield' ], alternateClassName: [ 'Ext.form.field.ComboBox' // classic compat ], requires: [ 'Ext.dataview.BoundListNavigationModel' ], config: { /** * @cfg {Function/String/Object/Ext.util.Filter} primaryFilter * A filter config object, or a Filter instance used to filter the store on input * field mutation by typing or pasting. * * This may be a filter config object which specifies a filter which uses the * {@link #cfg!store}'s fields. * * {@link Ext.util.Filter Filters} may also be instantiated using a custom `filterFn` * to allow a developer to specify complex matching. For example, a combobox developer * might allow a user to filter using either the {@link #cfg!valueField} or * {@link #cfg!displayField} by using: * * primaryFilter: function(candidateRecord) { * // This called in the scope of the Filter instance, we have this config * var value = this.getValue(); * * return Ext.String.startsWith(candidateRecord.get('stateName', value, true) || * Ext.String.startsWith(candidateRecord.get('abbreviation', value, true); * } * * This may also be configured as the name of a method on a ViewController which is to * be used as the filtering function. Note that this will *still* be called in the * scope of the created Filter object because that has access to the `value` * which is being tested for. */ primaryFilter: true, /** * @cfg {String} queryParam * Name of the parameter used by the Store to pass the typed string when the ComboBox * is configured with * `{@link #queryMode}: 'remote'`. If explicitly set to a falsy value it will not be * sent. */ queryParam: 'query', /** * @cfg {String} queryMode * The mode in which the ComboBox uses the configured Store. Acceptable values are: * * - **`'local'`** : In this mode, the ComboBox assumes the store is fully loaded and * will query it directly. * * - **`'remote'`** : In this mode the ComboBox loads its Store dynamically based upon * user interaction. * * This is typically used for "autocomplete" type inputs, and after the user finishes * typing, the Store is {@link Ext.data.Store#method!load load}ed. * * A parameter containing the typed string is sent in the load request. The default * parameter name for the input string is `query`, but this can be configured using * the {@link #cfg!queryParam} config. * * In `queryMode: 'remote'`, the Store may be configured with * `{@link Ext.data.Store#cfg!remoteFilter remoteFilter}: true`, and further filters * may be _programmatically_ added to the Store which are then passed with every * load request which allows the server to further refine the returned dataset. * * Typically, in an autocomplete situation, {@link #cfg!hideTrigger} is configured * `true` because it has no meaning for autocomplete. */ queryMode: 'remote', /** * @cfg {Boolean} queryCaching * When true, this prevents the combo from re-querying (either locally or remotely) * when the current query is the same as the previous query. */ queryCaching: true, /** * @cfg {Number} queryDelay * The length of time in milliseconds to delay between the start of typing and sending * the query to filter the dropdown list. * * Defaults to `500` if `{@link #queryMode} = 'remote'` or `10` if * `{@link #queryMode} = 'local'` */ queryDelay: true, /** * @cfg {Number} minChars * The minimum number of characters the user must type before autocomplete and * {@link #typeAhead} activate. * * Defaults to `4` if {@link #queryMode} is `'remote'` or `0` if {@link #queryMode} * is `'local'`, does not apply if {@link Ext.form.field.Trigger#editable editable} * is `false`. */ minChars: null, /** * @cfg {Boolean} anyMatch * * Only valid when {@link #cfg!queryMode} is `'local'`.* * Configure as `true` to cause the {@link #cfg!primaryFilter} to match the typed * characters at any position in the {@link #displayField}'s value when filtering * *locally*. */ anyMatch: false, /** * @cfg {Boolean} caseSensitive * * Only valid when {@link #cfg!queryMode} is `'local'`.* * Configure as `true` to cause the {@link #cfg!primaryFilter} to match with * exact case matching. */ caseSensitive: false, /** * @cfg {Boolean} typeAhead * `true` to populate and autoselect the remainder of the text being typed after * a configurable delay ({@link #typeAheadDelay}) if it matches a known value. */ typeAhead: false, /** * @cfg {Number} typeAheadDelay * The length of time in milliseconds to wait until the typeahead text is displayed * if {@link #typeAhead} is `true`. */ typeAheadDelay: 250, /** * @cfg {String} triggerAction * The action to execute when the trigger is clicked. * * - **`'all'`** : * * {@link #doFilter run the query} specified by the `{@link #cfg!allQuery}` config option * * - **`'last'`** : * * {@link #doFilter run the query} using the `{@link #lastQuery last query value}`. * * - **`'query'`** : * * {@link #doFilter run the query} using the {@link Ext.form.field.Base#getRawValue * raw value}. * * See also `{@link #queryParam}`. */ triggerAction: 'all', /** * @cfg {String} allQuery * The text query to use to filter the store when the trigger element is tapped * (or expansion is requested by a keyboard gesture). By default, this is `null` * causing no filtering to occur. */ allQuery: null, /** * @cfg {Boolean} enableRegEx * *When {@link #queryMode} is `'local'` only* * * Set to `true` to have the ComboBox use the typed value as a RegExp source to * filter the store to get possible matches. * Invalid regex values will be ignored. */ enableRegEx: null }, /** * @cfg {Boolean} autoSelect * `true` to auto select the first value in the {@link #store} or {@link #options} when * they are changed. Only happens when the {@link #value} is set to `null`. */ autoSelect: false, classCls: Ext.baseCSSPrefix + 'combobox', /** * @cfg editable * @inheritdoc Ext.field.Text#cfg-editable */ editable: true, /** * @cfg {Boolean} forceSelection * Set to `true` to restrict the selected value to one of the values in the list, or * `false` to allow the user to set arbitrary text into the field. */ forceSelection: false, /** * @event beforepickercreate * Fires before the pop-up picker is created to give a developer a chance to configure it. * @param {Ext.field.ComboBox} this * @param {Object} newValue The config object for the picker. */ /** * @event pickercreate * Fires after the pop-up picker is created to give a developer a chance to configure it. * @param {Ext.field.ComboBox} this * @param {Ext.dataview.List/Ext.Component} picker The instantiated picker. */ /** * @event beforequery * Fires before all queries are processed. Return false to cancel the query or set the * queryPlan's cancel property to true. * * @param {Object} queryPlan An object containing details about the query to be executed. * @param {Ext.form.field.ComboBox} queryPlan.combo A reference to this ComboBox. * @param {String} queryPlan.query The query value to be used to match against the ComboBox's * {@link #valueField}. * @param {Boolean} queryPlan.force If `true`, causes the query to be executed even if the * minChars threshold is not met. * @param {Boolean} queryPlan.cancel A boolean value which, if set to `true` upon return, * causes the query not to be executed. * @param {Object} [queryPlan.lastQuery] The queryPlan object used in the previous query. */ /** * @event select * Fires when the user has selected an item from the associated picker. * @param {Ext.field.ComboBox} this This field * @param {Ext.data.Model} newValue The corresponding record for the new value */ /** * @event change * Fires when the field is changed, or if forceSelection is false, on keystroke. * @param {Ext.field.ComboBox} this This field * @param {Ext.data.Model} newValue The new value * @param {Ext.data.Model} oldValue The original value */ // Start with value on prototype. lastQuery: {}, // ENTER does not trigger an input event keyMap: { scope: 'this', ENTER: 'onEnterKey' }, platformConfig: { phone: { editable: false } }, /** * @private * Respond to selection. Needed if we are multiselect */ onCollectionAdd: function(valueCollection, adds) { // Clear the suggestion input upon add of a new selection if (this.getMultiSelect()) { this.inputElement.dom.value = ''; // If we were expanded, then release the filter constrains that were // in place due to the primaryFilter using the inputElement's value. if (this.expanded) { this.doRawFilter(); } } this.callParent([valueCollection, adds]); }, onInput: function(e) { var me = this, filterTask = me.doFilterTask, value = me.inputElement.dom.value, filters = me.getStore().getFilters(), keyboardEvent, isDelimiter; if (Ext.supports.inputEventData) { isDelimiter = e.browserEvent.data === me.getDelimiter(); } // Fall back to testing whether the last keyboard event was the delimiter key and // is close enough in time to be the source of this input event. else { keyboardEvent = me.lastKeyMapEvent; isDelimiter = keyboardEvent && keyboardEvent.getChar() === me.getDelimiter() && (Ext.ticks() - keyboardEvent.time) < 20; } // Keep our config up to date: me._inputValue = value; if (!me.hasFocus && me.getLabelAlign() === 'placeholder') { me.syncLabelPlaceholder(true); } if (!me.getForceSelection() || (value === '' && !me.getRequired())) { // If we are allowing addition of multiple new values, do so on receipt of // the delimiter character. if (me.getMultiSelect()) { if (isDelimiter) { return me.addNewMultiValues(); } } else { me.callParent([e]); } } else { me.syncEmptyState(); } if (value.length) { if (!filterTask) { filterTask = me.doFilterTask = new Ext.util.DelayedTask(me.doRawFilter, me); } filterTask.delay(me.getQueryDelay()); } else { me.collapse(); filters.beginUpdate(); me.getPrimaryFilter().setDisabled(true); filters.endUpdate(); } }, onEnterKey: function(e) { var me = this; if (!me.getForceSelection() && me.getMultiSelect()) { me.addNewMultiValues(); } }, addNewMultiValues: function() { var me = this, inputValue = me.inputElement.dom.value, newValue; newValue = me.getValue() || []; newValue.push.apply(newValue, inputValue.split(me.getDelimiter())); return me.setValue(Ext.Array.clean(newValue)); }, /** * @private * Execute the query with the raw contents within the textfield. */ doRawFilter: function() { var me = this, rawValue = me.inputElement.dom.value, lastQuery = me.lastQuery.query, isErase = lastQuery && lastQuery.length > rawValue.length; me.doFilter({ query: rawValue, isErase: isErase }); }, /** * @private * Show the dropdown based upon triggerAction and allQuery */ onExpandTap: function() { var me = this, triggerAction = me.getTriggerAction(); // TODO: Keyboard operation // Alt-Down arrow opens the picker but does not select items: // http://www.w3.org/TR/wai-aria-practices/#combobox if (me.expanded) { // Check the expended time to check that we are not being called in the immediate // aftermath of an expand. The reason being that expandTrigger does focusOnTap // and Picker fields expand on focus if the focus happened via touch. // But then, when the expandTrigger calls its handler, we get here immediately // and do a collapse. if (Ext.now() - me.expanded > 100) { me.collapse(); } } else if (!me.getReadOnly() && !me.getDisabled()) { if (triggerAction === 'all') { me.doFilter({ query: me.getAllQuery(), force: true // overrides the minChars test }); } else if (triggerAction === 'last') { me.doFilter({ query: me.lastQuery.query, force: true // overrides the minChars test }); } else { me.doFilter({ query: me.inputElement.dom.value }); } } }, clearValue: function() { var me = this; me.setValue(null); me.setInputValue(''); me.setFieldDisplay(); }, /** * Executes a query to filter the dropdown list. Fires the {@link #beforequery} event * prior to performing the query allowing the query action to be canceled if needed. * * @param {Object} query An object containing details about the query to be executed. * @param {String} [query.query] The query value to be used to match against the * ComboBox's {@link #textField}. If not present, the primary {@link #cfg!textfield} * filter is disabled. * @param {Boolean} query.force If `true`, causes the query to be executed even if * the {@link #cfg!minChars} threshold is not met. * @returns {Boolean} `true` if the query resulted in picker expansion. */ doFilter: function(query) { var me = this, isLocal = me.getQueryMode() === 'local', lastQuery = me.lastQuery, store = me.getStore() && me._pickerStore, filter = me.getPrimaryFilter(), filters = store.getFilters(), // Decide if, and how we are going to query the store queryPlan = me.beforeFilter(Ext.apply({ filterGeneration: filter.generation, lastQuery: lastQuery || {}, combo: me, cancel: false }, query)), picker, source; // Allow veto. if (store && queryPlan !== false && !queryPlan.cancel) { // User can be typing a regex in here, if it's invalid // just swallow the exception and move on if (me.getEnableRegEx()) { try { queryPlan.query = new RegExp(queryPlan.query); } catch (e) { queryPlan.query = null; } } // Update the value. filter.setValue(queryPlan.query); // If we are not caching previous queries, or the filter has changed in any way // (value, or matching criteria etc), or the force flag is different, then we // must re-filter. Otherwise, we just drop through to expand. if (!me.getQueryCaching() || filter.generation !== lastQuery.filterGeneration || query.force) { // If there is a query string to filter against, enable the filter now and prime // its value. // Filtering will occur when the store's FilterCollection broadcasts its // endUpdate signal. if (Ext.isEmpty(queryPlan.query)) { filter.setDisabled(true); } else { filter.setDisabled(false); // If we are doing remote filtering, set a flag to // indicate to onStoreLoad that the load is the result of filering. me.isFiltering = !isLocal; } me.lastQuery = queryPlan; // Firing the ensUpdate event will cause the store to refilter if local filtering // or reload starting at page 1 if remote. filters.beginUpdate(); filters.endUpdate(); // If we are doing local filtering, the upstream store MUST be loaded. // Now we use a ChainedStore we must do this. In previous versions // simply adding a filter caused automatic store load. if (store.isChainedStore) { source = store.getSource(); if (!source.isLoaded() && !source.hasPendingLoad()) { source.load(); } } } if (me.getTypeAhead()) { me.doTypeAhead(queryPlan); } // If the query result is non-zero length, or there is empty text to display // we must expand. // Note that edge pickers do not have an emptyText config. picker = me.getPicker(); // If it's a remote store, we must expand now, so that the picker will show its // loading mask to show that some activity is happening. if (!isLocal || store.getCount() || (picker.getEmptyText && picker.getEmptyText())) { me.expand(); // If the use is querying by a value, and it's a local filter, then // set the location immediately. If it's going to be a remote filter, // then onStoreLoad will set the location after the if (queryPlan.query && isLocal) { me.setPickerLocation(); } return true; } // The result of the filtering is no records and there's no emptyText... // if it's a local query, hide the picker. If it's remote, we do not // know the result size yet, so the loading mask must stay visible. me.collapse(); } return false; }, /** * @template * A method which may modify aspects of how the store is to be filtered (if * {@link #queryMode} is `"local"`) of loaded (if {@link #queryMode} is `"remote"`). * * This is called by the {@link #doFilter method, and may be overridden in subclasses to modify * the default behaviour. * * This method is passed an object containing information about the upcoming query operation * which it may modify before returning. * * @param {Object} queryPlan An object containing details about the query to be executed. * @param {String} [queryPlan.query] The query value to be used to match against the * ComboBox's {@link #textField}. * If not present, the primary {@link #cfg!textfield} filter is disabled. * @param {String} queryPlan.lastQuery The query value used the last time a store query * was made. * @param {Boolean} queryPlan.force If `true`, causes the query to be executed even if * the minChars threshold is not met. * @param {Boolean} queryPlan.cancel A boolean value which, if set to `true` upon * return, causes the query not to be executed. */ beforeFilter: function(queryPlan) { var me = this, query = queryPlan.query, len; // Allow beforequery event to veto by returning false if (me.fireEvent('beforequery', queryPlan) === false) { queryPlan.cancel = true; } // Allow beforequery event to veto by returning setting the cancel flag else if (!queryPlan.cancel) { len = query && query.length; // If the minChars threshold has not been met, and we're not forcing a query, cancel // the query if (!queryPlan.force && len && len < me._getMinChars()) { queryPlan.cancel = true; } } return queryPlan; }, completeEdit: function() { var me = this, inputValue = me.getInputValue(), value = me.getValue(), selection = me.getSelection(), valueField, displayField, displayValueField; // displayValueField is the field wherein combobox values are set/selected // in case of displayTpl check the entire diplayTpl value // else just check the value of displayField if (me.getDisplayTpl() && selection) { valueField = selection.get(this.getValueField()); displayField = selection.get(this.getDisplayField()); displayValueField = me.getDisplayTpl().apply({ abbr: valueField, name: displayField }); } else { displayValueField = selection && selection.get(this.getDisplayField()); } // Don't want to callParent here, we need custom handling if (me.doFilterTask) { me.doFilterTask.cancel(); } // Allow the input value to add a new value if configured to do so. if (!me.getForceSelection() && me.getMultiSelect()) { // If there is input left, then if selectOnTab is set, process it // into a new value, otherwise clear the input. if (inputValue) { if (this.getSelectOnTab()) { me.addNewMultiValues(); } else { this.setInputValue(''); } } } else { // We must not leave an inconsistent state. // So if there's a textual value, there must be some // selection. if (inputValue) { // Prevent an issue where we have duplicate display values with // different underlying values. If the typed value exactly matches // the selection Record, we must not do a syncValue. if (!selection || displayValueField !== inputValue) { me.syncMode = 'input'; me.syncValue(); // If syncValue finds that they quit after typing some non-matchable text, // revert to the underlying value. if (!me.getValue()) { me.setValue(value); } } } // They cleared out the text, and are leaving. // If there's an underlying value: // If we're required, restore the display // Else clear the selection else if (selection) { if (me.getRequired()) { me.setFieldDisplay(selection); } else { me.setSelection(null); } } if (me.getTypeAhead()) { me.select(inputValue ? inputValue.length : 0); } } }, /** * @private * Called when local filtering is being used. * Only effective when NOT actively using the primary filter */ onStoreFilterChange: function() { var me = this, store = me.getStore(), selection = me.getSelection() || null, toRemove = []; // If we are not in the middle of doing a primary filter, then prune no longer // present value(s) if (selection && !me.destroying && store && store.isLoaded() && me.getPrimaryFilter().getDisabled()) { if (me.getMultiSelect()) { Ext.Array.each(selection, function(record) { if (!record.isEntered && !store.contains(record)) { toRemove.push(record); } }); } else { if (!selection.isEntered && !store.contains(selection)) { toRemove.push(selection); } } // Prune out values which are no longer in the source store if (toRemove.length) { this.getValueCollection().remove(toRemove); } } }, // TODO: Decide on an EdgePicker onListSelect: Ext.emptyFn, applyQueryDelay: function(queryDelay) { if (queryDelay === true) { queryDelay = this.getQueryMode() === 'local' ? 10 : 500; } return queryDelay; }, applyPrimaryFilter: function(filter, oldFilter) { var me = this, store = me.getStore() && me._pickerStore, isInstance = filter && filter.isFilter, methodName; // If we have to remove the oldFilter, or reconfigure it... if (store && oldFilter) { // We are replacing the old filter if (filter) { if (isInstance) { store.removeFilter(oldFilter, true); } else { oldFilter.setConfig(filter); return; } } // We are removing the old filter else if (!store.destroyed) { store.getFilters().remove(oldFilter); } } // There is a new filter if (filter) { if (filter === true) { filter = { id: me.id + '-primary-filter', anyMatch: me.getAnyMatch(), caseSensitive: me.getCaseSensitive(), root: 'data', property: me.getDisplayField(), value: me.inputElement.dom.value, disabled: true }; } // If it's a string, create a function which calls it where it can be found // but using the Filter as the scope. if (typeof filter === 'string') { methodName = filter; filter = { filterFn: function(rec) { var methodOwner = me.resolveListenerScope(me); // Maintainer: MUST pass "this" as the scope because the method must // be executed as a Filter method for access to the filter configurations. return methodOwner[methodName].call(this, rec); } }; } // Ensure it's promoted to an instance if (!filter.isFilter) { filter = new Ext.util.Filter(filter); } // Primary filter serialized as simple value by default filter.serialize = function() { return me.serializePrimaryFilter(this); }; // Add filter if we have a store already if (store) { store.addFilter(filter, true); } } return filter; }, updateOptions: function(options, oldOptions) { if (options) { this.setQueryMode('local'); } this.callParent([options, oldOptions]); }, updatePicker: function(picker, oldPicker) { if (picker) { picker.getSelectable().addIgnoredFilter(this.getPrimaryFilter()); } this.callParent([picker, oldPicker]); }, updateStore: function(store, oldStore) { var me = this, isRemote = me.getQueryMode() === 'remote', primaryFilter, proxy, oldFilters; // Tweak the proxy to encode the primaryFilter's parameter as documented for ComboBox if (isRemote) { store.setRemoteFilter(true); // Set the Proxy's filterParam name to our queryParam name if it is a ServerProxy // which encodes params. proxy = store.getProxy(); if (proxy.setFilterParam) { proxy.setFilterParam(me.getQueryParam()); } } // Superclass ensures that there's a ChainedStore in the _pickerStore // property if we are going to be adding our own local filters to it. me.callParent([store, oldStore]); // The primaryFilter (Our typing filter) will add itself to the _pickerStore. primaryFilter = me.getPrimaryFilter(); if (primaryFilter) { // Remove primaryFilter from the outgoing store. // It will only be there if the outgoing store was remoteFilter. if (oldStore && !oldStore.destroyed) { oldFilters = oldStore.getFilters(); // Filter collection might not exist. if (oldFilters) { oldFilters.remove(primaryFilter); } } // Add the primary filter to the (possibly new, but possibly just // re-attached to the incoming store) pickerStore. // See Ext.field.Select#updateStore, and its call to updatePickerStore. me._pickerStore.addFilter(primaryFilter, true); } // If we are doing remote filtering, then mutating the store's filters should not // result in a re-evaluation of whether the current value(s) is/are still present in // the store. // For local filtering, if a new filter is added (must not be done while typing is // taking place) then the current selection is pruned to remove no longer valid // entries. if (me.getQueryMode() === 'local') { store.on({ filterchange: 'onStoreFilterChange', scope: me }); } }, /** * @template * A method that may be overridden in a subclass which serializes the primary filter * (the filter that passes the typed value for transmission to the server in the * {@link #cfg!queryParam}). * * The provided implementation simply passes the filter's textual value as the * {@link #cfg!queryParam} value. * * @param {Ext.util.Filter} filter The {@link #cfg!primaryFilter} of this ComboBox which * encapsulates the typed value and the matching rules. * @return {String/Object} A value which, when encoded as an HTML parameter, your server * will understand. */ serializePrimaryFilter: function(filter) { return filter.getValue(); }, doDestroy: function() { var me = this; me.setPrimaryFilter(null); if (me.typeAheadTask) { me.typeAheadTask = me.typeAheadTask.cancel(); } me.callParent(); }, doTypeAhead: function(queryPlan) { var me = this; if (!me.typeAheadTask) { me.typeAheadTask = new Ext.util.DelayedTask(me.onTypeAhead, me); } // Only typeahead when user extends the query string, or it's a completely different query // If user is erasing, re-extending with typeahead is not wanted. if ( (!queryPlan.lastQuery.query || !queryPlan.query || queryPlan.query.length > queryPlan.lastQuery.query.length) || !Ext.String.startsWith(queryPlan.lastQuery.query, queryPlan.query) ) { me.typeAheadTask.delay(me.getTypeAheadDelay()); } }, onTypeAhead: function() { var me = this, displayField = me.getDisplayField(), inputEl = me.inputElement.dom, rawValue = inputEl.value, store = me.getStore(), record = store.findRecord(displayField, rawValue), newValue, len, selStart; if (record) { newValue = record.get(displayField); len = newValue.length; selStart = rawValue.length; if (selStart !== 0 && selStart !== len) { inputEl.value = me._inputValue = newValue; me.select(selStart, len); } } }, privates: { _getMinChars: function() { var result = this.getMinChars(); if (result == null) { result = this.getQueryMode() === 'remote' ? 4 : 0; } return result; }, setFieldDisplay: function(selection) { var me = this, inputValue; me.callParent([selection]); if (!me.getMultiSelect()) { if (me.getTypeAhead()) { inputValue = me.getInputValue(); me.select(inputValue ? inputValue.length : 0); } } } }});