Well, actually, i am NOT the author of this code, just rewriting some parts of it.
labelField, dataField are used for work with combobox dataProvider.
Contents of SelectObjectCombo:
<mx:HBox xmlns:mx = "http://www.adobe.com/2006/mxml"
preinitialize = "onPreInitialize()"
initialize = "onInit()"
creationComplete = "onCreate();"
xmlns:ex = "http://ex.korusconsulting.ru/exodus"
xmlns:chooser = "ex.components.chooser.*"
implements = "ex.layouts.ILayoutComponent, ex.secure.ISecuredComponent, mx.core.IDataRenderer, mx.controls.listClasses.IDropInListItemRenderer">
<mx:Metadata>
/**
* Выравниваение компонента на форме, смысл такой же как и у layoutData,
* только позволяет задавать выравнивание через стили.
*
* @default null
*/
[Style(name="layoutConstraint", type="String", inherit="no")]
[Event(name="objectIdChanged",type="flash.events.Event")]
[Event(name="textChanged",type="flash.events.Event")]
[Event(name="selectItem",type="ex.events.SelectObjectEvent")]
[Event(name="openItem",type="ex.events.SelectObjectEvent")]
[Event(name="cleanItem",type="ex.events.SelectObjectEvent")]
[Event(name="change",type="flash.events.Event")]
[Event(name="select",type="flash.events.Event")]
[Event(name="refresh", type="ex.events.RefreshEvent")]
//TODO RefreshEvent заменить на SelectedObjectEvent.FETCH_BY_NAME
// а также добавить SelectedObjectEvent.FETCH_BY_ID
// добавить флаг - mode - режим, этот флаг должен поддерживать:
// 1. FETCH_MODE - можно подцеплять по имени или по ID
// (тоесть когда у нас устанавливается objectId, сразу срабатывает FETCH_BY_ID
// если такого объекта нету в dataProvider-e)
// в этом режиме проверка SelectedValueCheck - Срабатывает после окончания FETCH
// 2. TEXT_MODE - поле ввода работает как текстовое
// в этом режиме проверка SelectedValueCheck - НЕ Работает
// 3. AUTO_MODE - режим использования опережающего ввода (AutoComplete)
// в этом режиме проверка SelectedValueCheck - Работает
// 4. CUSTOM_MODE - компонент наследник должен сам следить за работой различных зависимостей
// ему доступны protected функции
// TODO
// переписать компонент ввиде ActionScript
// Посмотреть колличество визуальных компонентов, возможно их уменьшить
// как средство уменьшения - собственный Layout написать
</mx:Metadata>
<mx:Script>
<![CDATA[
import mx.controls.listClasses.ListData;
import mx.controls.dataGridClasses.DataGridListData;
import mx.controls.listClasses.BaseListData;
import mx.logging.Log;
import mx.logging.ILogger;
import net.miginfocom.layout.WeakReference;
import mx.rpc.xml.SchemaTypeRegistry;
import ex.events.RefreshEvent;
import ex.ConfigLib;
import ex.utils.Utils;
import ex.events.SelectObjectEvent;
import ex.events.TimedInputEvent;
import mx.events.FlexEvent;
import mx.collections.ArrayCollection;
import mx.core.UIComponent;
import ex.layouts.ILayoutComponent;
import mx.core.IInvalidating;
protected static const logger:ILogger = Log.getLogger("ex.components.chooser.SelectObjectCombo");
private function onPreInitialize():void {
ConfigLib.securityProvider.registerComponent(this);
}
private function onInit():void {
if (Log.isDebug()) {
logger.debug("name:{0} initialize", name);
}
_initializingStart = true;
addEventListener(SelectObjectEvent.CLEAN_ITEM, defaultCleanItemHandler);
addEventListener(Event.CHANGE, defaultChangeHandler);
componentEnabled = _componentEnabled;
}
private function onCreate():void {
if (Log.isDebug()) {
logger.debug("name:{0} onCreate", name);
}
// данный код нельзя выполнять в onInit, так как родительские mxml
// компоненты не имеют его идентификатора
// тоесть значение этого идентификатора еще не установлено
// мы в большинстве случаев получим null exception
// воспроизводим срабатывание триггера первый раз
_objectIdChanged = true;
invalidateProperties();
// просто вызывать dispatchChangeEvent мы можем, но тогда надо также дублировать код который находиться в
// commitProperties, мне кажется, что гораздо более элегантно позволить commitProperties
// самому сделать свое дело.
//dispatchChangeEvent();
styleChanged(null);
}
private var _initializingStart:Boolean = false;
//---------------------------------------------------------------
//---------------------------------------------------------------
private var _showSearchButtonChanged:Boolean = true;
private var _showSearchButton:Boolean = true;
public function get showSearchButton():Boolean {
return _showSearchButton;
}
[Inspectable(defaultValue="true",category="Common")]
public function set showSearchButton(value:Boolean):void {
if (_showSearchButton == value) {
return;
}
if (Log.isDebug()) {
logger.debug("name:{0} showSearchButton=", name, value);
}
_showSearchButton = value;
_showSearchButtonChanged = true;
invalidateProperties();
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private var _showOpenButtonChanged:Boolean = true;
private var _showOpenButton:Boolean = true;
public function get showOpenButton():Boolean {
return _showOpenButton;
}
[Inspectable(defaultValue="true",category="Common")]
public function set showOpenButton(value:Boolean):void {
if (_showOpenButton == value) {
return;
}
if (Log.isDebug()) {
logger.debug("name:{0} showOpenButton=", name, value);
}
_showOpenButton = value;
_showOpenButtonChanged = true;
invalidateProperties();
}
//---------------------------------------------------------------
//---------------------------------------------------------------
/**
* Если флаг установлен, то автоматическое изменение состояния
* showOpenButton отключено
* */
private var _manualShowOpenButton:Boolean = false;
public function get manualShowOpenButton():Boolean {
return _manualShowOpenButton;
}
[Inspectable(defaultValue="false",category="Common")]
public function set manualShowOpenButton(value:Boolean):void {
if (_manualShowOpenButton == value) {
return;
}
_manualShowOpenButton = value;
if (Log.isDebug()) {
logger.debug("name:{0} manualShowOpenButton=", name, value);
}
// необходимо обновить текущее сосояние кнопки
_showOpenButtonChanged = true;
invalidateProperties();
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private var _showCleanButtonChanged:Boolean = true;
private var _showCleanButton:Boolean = true;
public function get showCleanButton():Boolean {
return _showCleanButton;
}
[Inspectable(defaultValue="true",category="Common")]
public function set showCleanButton(value:Boolean):void {
if (_showCleanButton == value) {
return;
}
if (Log.isDebug()) {
logger.debug("name:{0} showCleanButton=", name, value);
}
_showCleanButton = value;
_showCleanButtonChanged = true
invalidateProperties();
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _editable:Boolean = true;
public function set editable(value:Boolean):void {
value = Utils.interceptProperty(this, "editable", "editable", value,
_editable);
_editable = value;
}
public function get editable():Boolean {
return _editable;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private var _text:String;
private var _textChanged:Boolean = false;
[Bindable("textChanged")]
public function get text():String {
return _text;
}
public function set text(value:String):void {
if (_text != value) {
if (Log.isDebug()) {
logger.debug("name:{0} set text=", name, value);
}
_text = value;
_textChanged = true;
dispatchEvent(new Event("textChanged"));
invalidateProperties();
}
}
public function setText(value:String, supressEvent:Boolean = true):void {
if (_text != value) {
if (Log.isDebug()) {
logger.debug("name:{0} setText=", name, value);
}
_text = value;
if (!supressEvent) {
dispatchChangeEvent();
}
}
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private var _objectId:Object;
private var _objectIdChanged:Boolean = false;
[Bindable("objectIdChanged")]
public function get objectId():Object {
// валидаторы проверяют на null значение и на пустую строчку
// но не проверяют на NaN
// тем не менее NaN это результат приведения значения null к типу Number
// return (_objectId is Number&&isNaN(_objectId as Number))? null:_objectId;
return _objectId;
}
public function set objectId(value:Object):void {
value = ConfigLib.isNull(value) ? null : value;
if (_objectId != value) {
if (Log.isDebug()) {
logger.debug("name:{0} set objectId=", name, value);
}
_objectId = value;
_objectIdChanged = true;
dispatchEvent(new Event("objectIdChanged"));
invalidateProperties();
}
}
public function setItem(objectIdValue:Object, textValue:String):void {
if (Log.isDebug()) {
logger.debug("name:{0} setItem({1}, {2})", name, objectIdValue,
textValue);
}
text = textValue;
objectId = objectIdValue;
if (!manualShowOpenButton) {
_showOpenButtonChanged = true;
}
invalidateProperties();
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private function setVisiableForButton(btn:Button, isVisiableBtn:Boolean,
isChangedBtn:Boolean, txtForLog:String):void {
if (isChangedBtn) {
isChangedBtn = false;
if (Log.isDebug()) {
logger.debug("name:{0} {1}", name, txtForLog);
}
Utils.setVisible(btn, isVisiableBtn);
}
}
override protected function commitProperties():void {
if (Log.isDebug()) {
logger.debug("name:{0} begin commitProperties", name);
}
super.commitProperties();
if (!_initializingStart) {
return;
}
var realShowOpenButton:Boolean;
if (_showOpenButtonChanged || _saveSpaceForButtonsChanged || _inputFieldWidthChanged) {
if (!manualShowOpenButton) {
realShowOpenButton = !ConfigLib.isNull(objectId);
} else {
realShowOpenButton = _showOpenButton;
}
}
if (Log.isDebug()) {
logger.debug("name:{0} realShowOpenButton={1}", name, realShowOpenButton);
}
setVisiableForButton(searchButton, _showSearchButton, _showSearchButtonChanged,
"_showSearchButtonChanged");
setVisiableForButton(openButton, _showOpenButton, _showOpenButtonChanged,
"_showOpenButtonChanged");
setVisiableForButton(cleanButton, _showCleanButton, _showCleanButtonChanged,
"_showCleanButtonChanged");
if (_saveSpaceForButtonsChanged) {
_saveSpaceForButtonsChanged = false;
if (Log.isDebug()) {
logger.debug("name:{0} _saveSpaceForButtonsChanged", name);
}
// можно было бы просто установить для каждой кнопки
// флаг что она изменилась
// или вынести строчки кода для каждой кнопки
// я выбрал 2ое (Близнец Роман)
}
_spaceWidth = !_saveSpaceForButtons ? (((realShowOpenButton ? 1 :
0) + (_showSearchButton ? 1 : 0) + (_showCleanButton ? 1 : 0)) *
44) : (3 * 44);
if (Log.isDebug()) {
logger.debug("name:{0} _spaceWidth={1}", name, _spaceWidth);
}
// если была установлена ширина компонента, то регулируем внутренний
// автокомплит, если были изменены и ширина автокомплита и
// самого копонента, то приоритетнее изменение ширины компонента.
if (_inputFieldWidthChanged && !isNaN(_inputFieldWidth)) {
_inputFieldWidthChanged = false;
if (Log.isDebug()) {
logger.debug("name:{0} _inputFieldWidthChanged", name);
}
// _explicitWidthChanged = false;
explicitWidth = _inputFieldWidth + _spaceWidth;
}
// посылаем событие об изменении текущего objectId и text
if (initialized && (_textChanged || _objectIdChanged)) {
_textChanged = false;
_objectIdChanged = false;
// может произойти такая ситуация когда objectId
// устанавливается в rutime (clerkInput.objectId=null)
// в данной ситуации, надо обеспечить корректное сохранение
// значение в компоненте autoComplete
autoComplete.selectedValue = _objectId;
// теперь необходимо всех слушателей оповестить об изменения
// которые произошли в компоненте
dispatchChangeEvent();
}
if (Log.isDebug()) {
logger.debug("name:{0} end commitProperties", name);
}
}
//---------------------------------------------------------------
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _componentEnabled:Boolean = true;
public function set componentEnabled(value:Boolean):void {
value = Utils.interceptProperty(this, "componentEnabled", "enabled",
value, _componentEnabled);
_componentEnabled = value;
if (Log.isDebug()) {
logger.debug("name:{0} enabled={1}", name, _componentEnabled);
}
if (_initializingStart) {
// в функции инициализации есть вызов установщика
// текущего значения _enabled
searchButton.enabled = _componentEnabled;
cleanButton.enabled = _componentEnabled;
}
}
public function get componentEnabled():Boolean {
return _componentEnabled;
}
/**
* Container в методе updateDisplayList опрашивает данное
* свойство и устанавливает background соответсвующий для компонента
* чтобы предотвратить это всегда возвращаем true
*
* Реальное значение можно получить спользуя свойство: componentEnabled
**/
override public function get enabled():Boolean {
return true;
}
override public function set enabled(value:Boolean):void {
return;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _labelField:String;
public function set labelField(value:String):void {
_labelField = value;
}
public function get labelField():String {
return _labelField;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _dataField:String;
public function set dataField(value:String):void {
_dataField = value;
}
public function get dataField():String {
return _dataField;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private function onChangeString():void {
timedInputListener.text = autoComplete.text;
if (useAsTextInput && _text != autoComplete.text) {
_text = autoComplete.text;
objectId = null;
} else {
_text = autoComplete.text;
}
}
private function handleTimedInput(event:TimedInputEvent):void {
if (Log.isDebug()) {
logger.debug("name:{0} handleTimedInput={1}", name, event.text);
}
dispatchEvent(new RefreshEvent(RefreshEvent.REFRESH));
autoComplete.openDropDown();
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _dataProvider:ArrayCollection = new ArrayCollection();
public function set dataProvider(value:ArrayCollection):void {
if (_dataProvider === value) {
return;
}
if (value == null) {
_dataProvider = new ArrayCollection();
} else {
_dataProvider = value;
}
}
public function get dataProvider():ArrayCollection {
return _dataProvider;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _localData:Boolean = true;
public function set localData(value:Boolean):void {
_localData = value;
}
public function get localData():Boolean {
return _localData;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _filterFunction:Function;
public function set filterFunction(value:Function):void {
_filterFunction = value;
refresh();
}
public function filterFunctionWrapper(item:Object, searchStr:String):Boolean {
if (_filterFunction != null) {
return autoComplete.defaultFilterFunction(item, searchStr) &&
_filterFunction(item, searchStr);
} else {
return autoComplete.defaultFilterFunction(item, searchStr);
}
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _saveSpaceForButtons:Boolean = true;
private var _saveSpaceForButtonsChanged:Boolean = true;
public function set saveSpaceForButtons(value:Boolean):void {
_saveSpaceForButtons = value;
_saveSpaceForButtonsChanged = true;
invalidateProperties();
}
public function get saveSpaceForButtons():Boolean {
return _saveSpaceForButtons;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
/**
* Посылаем Event.SELECT при выборе в комбобоксе, иначе сообщение
* д.б. послано вручнуу
**/
private var _autoSelect:Boolean = true;
public function set autoSelect(value:Boolean):void {
_autoSelect = value;
}
public function get autoSelect():Boolean {
return _autoSelect;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _matchType:String = "anyPart";
[Inspectable(defaultValue="anyPart",category="Common",enumeration="beginning,word,anyPart")]
public function set matchType(value:String):void {
_matchType = value;
}
public function get matchType():String {
return _matchType;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
private var _minTextLengthForSearch:int = 3;
public function set minTextLengthForSearch(value:int):void {
_minTextLengthForSearch = value;
}
public function get minTextLengthForSearch():int {
return _minTextLengthForSearch;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private function handleSelectValueChange(event:Event):void {
setItem((event.target as Combo).selectedValue, event.target.text);
//setItem((event.target as Combo).selectedItem.cliId, event.target.text);
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private function defaultCleanItemHandler(event:SelectObjectEvent):void {
if (!event.isDefaultPrevented()) {
setItem(null, null);
}
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private function defaultChangeHandler(event:Event):void {
if (autoSelect && !ConfigLib.isNull(_objectId)) {
autoComplete.selectedValue = _objectId;
dispatchEvent(new Event(Event.SELECT));
}
}
//---------------------------------------------------------------
//---------------------------------------------------------------
[Bindable]
/**
* Если флаг установлен, то комбобокс перестает выдавать
* всплывающий список и не производиться проверок по установки
* selectedValue, т.е objectId можно выставлять любой
* он не измениться никоим образом
**/
public var useAsTextInput:Boolean = false;
//---------------------------------------------------------------
//---------------------------------------------------------------
public function get selectedItem():Object {
return autoComplete ? autoComplete.selectedItem : null;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
public function dispatchChangeEvent():void {
if (Log.isDebug()) {
logger.debug("name:{0} dispatchChangeEvent", name);
}
_textChanged = false;
_objectIdChanged = false;
dispatchEvent(new Event(Event.CHANGE, false, true));
}
//---------------------------------------------------------------
//---------------------------------------------------------------
private var _inputFieldWidth:Number;
private var _inputFieldWidthChanged:Boolean = false;
private var _spaceWidth:Number = 132;
public function set inputFieldWidth(value:Number):void {
if (_inputFieldWidth === value) {
return;
}
if (Log.isDebug()) {
logger.debug("name:{0} inputFieldWidth=", name, value);
}
_inputFieldWidth = value;
_inputFieldWidthChanged = true;
invalidateProperties();
}
public function get inputFieldWidth():Number {
return _inputFieldWidth;
}
/**
* Функция для возврата итема в исх. форму. Можно изменить тип
* возвращаемях итемов.
**/
//TODO Коментарий
public function getSelectedItem():SelectedItem {
var selectedItem:SelectedItem = new SelectedItem();
selectedItem.text = text;
selectedItem.objectId = objectId;
return selectedItem;
}
//---------------------------------------------------------------
//---------------------------------------------------------------
override public function styleChanged(styleProp:String):void {
super.styleChanged(styleProp);
if (!initialized) {
return;
}
var all:Boolean = false;
all = !styleProp || styleProp == "styleName"
if (all || styleProp == "searchButtonStyleName") {
searchButton.styleName = getStyle("searchButtonStyleName");
}
if (all || styleProp == "openButtonStyleName") {
openButton.styleName = getStyle("openButtonStyleName");
}
if (all || styleProp == "cleanButtonStyleName") {
cleanButton.styleName = getStyle("cleanButtonStyleName");
}
if (all || styleProp == "buttonWidth") {
var width:Number = getStyle("buttonWidth");
if (!ConfigLib.isNull(width)) {
openButton.width = width;
cleanButton.width = width;
searchButton.width = width;
}
}
if (all) {
setStyle("backgroundColor", null);
setStyle("backgroundDisabledColor", null);
}
if (all && autoComplete != null) {
autoComplete.styleName = styleName;
}
// if(all || styleProp.indexOf("background") !=-1 ){
// autoComplete.promptTextInput.setStyle("backgroundColor", getStyle("backgroundColor"));
// autoComplete.promptTextInput.setStyle("backgroundDisabledColor", getStyle("backgroundDisabledColor"));
// }
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
public function refresh():void {
if (_initializingStart && dataProvider) {
autoComplete.filterData();
autoComplete.invalidateSelectedValue();
}
}
//-----------------------------------------------------------------
//-----------------------------------------------------------------
//-----------------------------------------------------------
//-----------------------------------------------------------
//-----------------------------------------------------------
//Выделять весь текст при фокусе
[Bindable]
private var _canFullSelect:Boolean = false;
public function set canFullSelect(value:Boolean):void {
_canFullSelect = value;
}
public function get canFullSelect():Boolean {
return _canFullSelect;
}
[Bindable]
private var _dropDownLabelFunction:Function;
public function set dropDownLabelFunction(value:Function):void {
// if (autoComplete!=null && value!=null){
// autoComplete.dropDownLabelFunction=value;
// }
_dropDownLabelFunction = value;
}
public function get dropDownLabelFunction():Function {
return _dropDownLabelFunction;
}
//Устанавливать значение сравнением объектов
[Bindable]
public var _isInitialValueObject:Boolean = false;
public function set isInitialValueObject(value:Boolean):void {
_isInitialValueObject = value;
}
public function get isInitialValueObject():Boolean {
return _isInitialValueObject;
}
//---------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
private var _layoutData:Object;
private var _layoutDataChanged:Boolean;
public function get layoutData():Object {
return _layoutData;
}
public function set layoutData(value:Object):void {
if (value == _layoutData) {
return;
}
_layoutData = value;
_layoutDataChanged = true;
invalidateProperties();
invalidateDisplayList();
var p:IInvalidating = parent as IInvalidating;
if (p && includeInLayout) {
p.invalidateSize();
p.invalidateDisplayList();
}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
private var _prefferedWidth:Number;
public function get prefferedWidth():Number {
return _prefferedWidth;
}
public function set prefferedWidth(value:Number):void {
if (_prefferedWidth == value) {
return;
}
_prefferedWidth = value;
invalidateProperties();
invalidateDisplayList();
var p:IInvalidating = parent as IInvalidating;
if (p && includeInLayout) {
p.invalidateSize();
p.invalidateDisplayList();
}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
private var _prefferedHeight:Number;
public function get prefferedHeight():Number {
return _prefferedHeight;
}
public function set prefferedHeight(value:Number):void {
if (_prefferedHeight == value) {
return;
}
_prefferedHeight = value;
invalidateProperties();
invalidateDisplayList();
var p:IInvalidating = parent as IInvalidating;
if (p && includeInLayout) {
p.invalidateSize();
p.invalidateDisplayList();
}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
private var _secureFunction:String;
public function get secureFunction():String {
return _secureFunction;
}
public function set secureFunction(value:String):void {
if (_secureFunction == value) {
return;
}
_secureFunction = value;
dispatchEvent(new Event("secureFunctionChanged"));
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
private var _secureContext:WeakReference = new WeakReference();
public function set secureContext(value:Object):void {
_secureContext.setValue(value);
dispatchEvent(new Event("secureFunctionChanged"))
}
public function get secureContext():Object {
return _secureContext.getValue();
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
private var _propertyCache:Object;
public function set propertyCache(value:Object):void {
_propertyCache = value;
}
public function get propertyCache():Object {
return _propertyCache;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
override public function set visible(value:Boolean):void {
value = Utils.interceptProperty(this, "visible", "visible", value,
visible);
super.visible = value;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
override public function set includeInLayout(value:Boolean):void {
value = Utils.interceptProperty(this, "includeInLayout", "visible",
value, includeInLayout);
super.includeInLayout = value;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
override public function get baselinePosition():Number {
if (autoComplete == null) {
return super.baselinePosition;
}
return autoComplete.baselinePosition;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
public function invalidateSelectedValue():void {
if (autoComplete != null) {
autoComplete.invalidateSelectedValue();
}
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//----------------------------------
// listData
//----------------------------------
private var _listData:BaseListData;
[Bindable("dataChange")]
[Inspectable(environment="none")]
public function get listData():BaseListData {
return _listData;
}
public function set listData(value:BaseListData):void {
_listData = value;
}
//----------------------------------
// data
//----------------------------------
private var _data:Object;
[Bindable("dataChange")]
[Inspectable(environment="none")]
override public function get data():Object {
return _data;
}
override public function set data(value:Object):void {
var newSelectedItem:*;
_data = value;
if (_listData && _listData is DataGridListData)
newSelectedItem = _data[DataGridListData(_listData).dataField];
else if (_listData is ListData && ListData(_listData).labelField in
_data)
newSelectedItem = _data[ListData(_listData).labelField];
else {
// newSelectedItem = _data;
//do nothing - return;
}
if (newSelectedItem !== undefined) {
objectId = newSelectedItem;
invalidateSelectedValue();
}
dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
}
[Bindable]
public var lookup:Boolean = false;
public function selectedValueIsExist():Boolean {
for each (var item:Object in dataProvider) {
if (item[dataField] == objectId) {
return true;
}
}
return false;
}
override public function set errorString(value:String):void {
if (autoComplete != null && autoComplete.promptTextInput != null &&
autoComplete.promptTextInput.textInput != null) {
autoComplete.promptTextInput.textInput.errorString = value;
}
}
override public function get errorString():String {
if (autoComplete != null && autoComplete.promptTextInput != null &&
autoComplete.promptTextInput.textInput != null) {
return autoComplete.promptTextInput.textInput.errorString;
}
return null;
}
]]>
</mx:Script>
<chooser:Combo id = "autoComplete"
componentEnabled = "{_componentEnabled}"
editable = "{_editable}"
text = "{text}"
labelField = "{_labelField}"
dataField = "{_dataField}"
dataProvider = "{_dataProvider}"
matchType = "{_matchType}"
filterFunction = "{_localData? filterFunctionWrapper :null}"
searchStringChanged = "onChangeString();"
selectedValueChange = "handleSelectValueChange(event)"
openDropdownOnInput = "{_localData && !useAsTextInput}"
showCleanButton = "false"
lookup = "{lookup}"
width = "100%"
preinitialize = "{ autoComplete.lookup = useAsTextInput || lookup; autoComplete.name = name+'AutoComplete'}"
canFullSelect = "{_canFullSelect}"
dropDownLabelFunction = "{_dropDownLabelFunction}"
isInitialValueObject = "{_isInitialValueObject}"/>
<!--mx:Spacer width = "4" id = "searchButtonSpacer"/-->
<mx:Button click = "dispatchEvent(new SelectObjectEvent(SelectObjectEvent.SELECT_ITEM, getSelectedItem()))" id = "searchButton"/>
<!--mx:Spacer width = "4" id = "openButtonSpacer"/-->
<mx:Button click = "dispatchEvent(new SelectObjectEvent(SelectObjectEvent.OPEN_ITEM, getSelectedItem()))" id = "openButton"/>
<!--mx:Spacer width = "4" id = "cleanButtonSpacer"/-->
<mx:Button click = "dispatchEvent(new SelectObjectEvent(SelectObjectEvent.CLEAN_ITEM, getSelectedItem()))" id = "cleanButton"/>
<!--mx:Spacer id = "searchButtonSpacer2"
width = "{searchButton.width + searchButtonSpacer.width}"
includeInLayout = "false"
visible = "false"/-->
<!--mx:Spacer id = "openButtonSpacer2"
width = "{openButton.width + openButtonSpacer.width}"
includeInLayout = "false"
visible = "false"/>
<mx:Spacer id = "cleanButtonSpacer2"
width = "{cleanButton.width + cleanButtonSpacer.width}"
includeInLayout = "false"
visible = "false"/-->
<ex:TimedInputListener useSmartDelay = "true"
id = "timedInputListener"
enabled = "{!_localData}"
minTextLength = "{_minTextLengthForSearch}"
timedInput = "handleTimedInput(event)">
</ex:TimedInputListener>
</mx:HBox>
5
Replies
AdChoices