Insert the value into adapter view. It is called when the dropdown is clicked or selected.  value    - The selected element of the array callbacked from search func. strategy - The Strategy object. e        - Click or keydown event object.
547283
function (value, strategy, e) {
      this._term = null;
      this.adapter.select(value, strategy, e);
      this.fire('change').fire('textComplete:select', value, strategy);
      this.adapter.focus();
    }
1288278
function ( e ) {
            var res = { 
                id:    this._conf().fieldID,
                meta:  this._meta(),
                value: {}
            };

            res.value[ res.id ] = e.target.value; 
            this.handleEvent( 'change' )( e );
            this._conf().onChange( res );
        }
350222
private void link(Value value, ValuePanel panel) {
		controlToData.put(panel, value);
		
		if( value instanceof SimpleValue )
			panel.setValue((int) ((SimpleValue)value).getValue( 0 ));
		else if( value instanceof RandomValue )
			panel.setValue((int) ((RandomValue)value).getValue());
	}
1062609
function (arrayValue, index) {
            // Support selecting template as a function of the data being rendered
            arrayItemContext = parentBindingContext['createChildContext'](arrayValue, options['as'], function(context) {
                context['$index'] = index;
            });

            var templateName = resolveTemplateName(template, arrayValue, arrayItemContext);
            return executeTemplate(null, "ignoreTargetNode", templateName, arrayItemContext, options);
        }
369961
public boolean pasteRowValue(String value) {
        LOGGER.debug("pasteRowValue(" + value + ") - in active editor");
        TextField editor = getActiveEditor();
        boolean edited;
        if (editor instanceof ComboBox) {
            edited = editor.setValue(value);
        } else {
            edited = editor.pasteInValue(value);
        }
        if (edited) {
            editor.blur();
        }
        return edited;
    }
1029802
def add_option(self, value, text, selected=False):
        
        option = {"value": value, "text": text, "selected":selected}
        self.options += [option]
        if selected:
            self.selected_options += [option]
            self._value.append(value)
            if self._persist_value:
                self.settings.store_value("selected_options", self.selected_options)
83503
function (newVals) {
            // when clicking on an item in the dropdown list, close the dropdown and save the selected item
            var report = this.controller.checkValue(this.controller.getDataModel().value);
            var arg = {
                stopValueProp : !this._instantBind
            };
            this._reactToControllerReport(report, arg);
            if (this._instantBind && this._dropdownPopup) {
                this._dropdownPopup.updatePosition();
            }
        }
456200
def on_select(self, item, action):
        

        if not isinstance(item, int):
            item = self.items.index(item)

        self._on_select[item] = action
1243646
function (arrayValue, index) {
            // Support selecting template as a function of the data being rendered
            var templateName = typeof(template) == 'function' ? template(arrayValue) : template;
            arrayItemContext = parentBindingContext['createChildContext'](ko.utils.unwrapObservable(arrayValue));
            arrayItemContext['$index'] = index;
            return executeTemplate(null, "ignoreTargetNode", templateName, arrayItemContext, options);
        }
209673
public void selectValue(String value) {

        if (m_selectCells.get(value) == null) {
            return;
        }

        updateOpener(value);
        if (m_textMetricsPrefix != null) {
            truncate(m_textMetricsPrefix, m_widgetWidth);
        }
        m_selectedValue = value;
        close();
    }
7489
private void updateValue(Value value) {
    while (true) {
      Value current = currentValue.get();
      if (value.isNewerThan(current)) {
        if (currentValue.compareAndSet(current, value)) {
          if (current == null || !Objects.equals(current.value(), value.value())) {
            eventListeners.forEach(listener -> listener.event(new ValueDelegateEvent<>(ValueDelegateEvent.Type.UPDATE, decode(value.value()))));
          }
          break;
        }
      } else {
        break;
      }
    }
  }
1339638
function (v) {
/*Line 23 - 'AtomYesNoCustom.js' */                this._value = v;
/*Line 24 - 'AtomYesNoCustom.js' */                AtomBinder.setValue(this, "hasValue", v ? true : false);
/*Line 25 - 'AtomYesNoCustom.js' */                if (!this._onUIChanged) {
/*Line 26 - 'AtomYesNoCustom.js' */                    $(this._input).val(v);
/*Line 27 - 'AtomYesNoCustom.js' */                }
/*Line 28 - 'AtomYesNoCustom.js' */            }
371766
function (name, value, oldValue) {
            // it doesn't make sense to bind both index and value,
            // so we just state that the index takes precedence on the value

            if (name === "selectedIndex") {
                this._domElt.selectedIndex = value;
                this.setValueInDataModel();
                if (!this.isIndexValid(value)) {
                    this.setIndexInDataModel();
                }
            } else if (name === "value") {
                this._domElt.selectedIndex = this.getIndex(value);
                this.setIndexInDataModel();
                // if selectedIndex is set to -1 and value is bound we modify the data model to change the value to ''
                if (this._domElt.selectedIndex === -1) {
                    this.setValueInDataModel();
                }
            }
            this.onDisabledBind(name, value, oldValue);
        }
723499
function(value) {
	      
	   // Div that wraps the deleteButton + the subField
	   var newDiv = inputEx.cn('div'), delButton;
	      
	   // Delete button
	   if(this.options.useButtons) {
	      delButton = inputEx.cn('img', {src: inputEx.spacerUrl, className: 'inputEx-ListField-delButton'});
	      Event.addListener( delButton, 'click', this.onDelete, this, true);
	      newDiv.appendChild( delButton );
      }
	      
	   // Instantiate the new subField
	   var opts = lang.merge({}, this.options.elementType);
	   
	   // Retro-compatibility with deprecated inputParams Object : TODO -> remove
      if(lang.isObject(opts.inputParams) && !lang.isUndefined(value)) {
         opts.inputParams.value = value;
         
      // New prefered way to set options of a field
      } else if (!lang.isUndefined(value)) {
         opts.value = value;
      }
	   
	   var el = inputEx(opts,this);
	   
	   var subFieldEl = el.getEl();
		YAHOO.util.Dom.addClass(subFieldEl, 'inputEx-ListField-subFieldEl');
	   newDiv.appendChild( subFieldEl );
	   
	   // Subscribe the onChange event to resend it 
	   el.updatedEvt.subscribe(this.onChange, this, true);
	
	   // Arrows to order:
	   if(this.options.sortable) {
	      var arrowUp = inputEx.cn('div', {className: 'inputEx-ListField-Arrow inputEx-ListField-ArrowUp'});
	      Event.addListener(arrowUp, 'click', this.onArrowUp, this, true);
	      var arrowDown = inputEx.cn('div', {className: 'inputEx-ListField-Arrow inputEx-ListField-ArrowDown'});
	      Event.addListener(arrowDown, 'click', this.onArrowDown, this, true);
	      newDiv.appendChild( arrowUp );
	      newDiv.appendChild( arrowDown );
	   }
	   
	   // Delete link
	   if(!this.options.useButtons) {
	      delButton = inputEx.cn('a', {className: 'inputEx-List-link'}, null, this.options.listRemoveLabel);
	      Event.addListener( delButton, 'click', this.onDelete, this, true);
	      newDiv.appendChild( delButton );
      }
	
	   // Line breaker
	   newDiv.appendChild( inputEx.cn('div', null, {clear: "both"}) );
	
	   this.childContainer.appendChild(newDiv);
	      
	   return el;
	}
633523
function setSelectValue (elem, value) {
  var optionSet, option
  var options = elem.options
  var values = makeArray(value)
  var i = options.length

  while (i--) {
    option = options[ i ]
    /* eslint-disable no-cond-assign */
    if (values.indexOf(option.value) > -1) {
      option.setAttribute('selected', true)
      optionSet = true
    }
    /* eslint-enable no-cond-assign */
  }

  // Force browsers to behave consistently when non-matching value is set
  if (!optionSet) {
    elem.selectedIndex = -1
  }
}
919754
function fieldInsert(elem, field, val) {
        try {
            $(exports).triggerHandler('fieldInsert', [elem, field, val]);
        } catch (err) {
            console.error(err);
        }
        var array = _getArray(elem, field);
        array.push(val);
        _currentOperation.ops.push({
            op: OP_FIELD_INSERT,
            arg: {
                _id: elem._id,
                f: field,
                e: val._id,
                i: array.indexOf(val)
            }
        });
    }
375666
function pickValue( ref, node, success, complete ) {

        if ( !ref ) {
            console.error('pickValue !ref return');
            return;
        }

        var events = {};
        $$.defineEvent( events );

        events.eventListener({
            // limit: 1,
            self: this,
            action: 'success',
            listen: success
        });

        events.eventListener({
            self: this,
            action: 'complete',
            listen: complete
        });

        ref.exec({ node: node }, events );
    }