Adds the 'inputEx-MapField' default className
15243
function(options) { 
		inputEx.MapField.superclass.setOptions.call(this, options);
		this.options.className = options.className || 'inputEx-Field inputEx-MapField';
		
		this.options.width = options.width || '400px';
		this.options.height = options.height || '400px';
		this.options.loading = options.loading || 'loading....';

		this.options.lat = options.lat || inputEx.MapFieldGlobals.lat;
		this.options.lon = options.lon || inputEx.MapFieldGlobals.lon;
		this.options.uzoom = options.uzoom || inputEx.MapFieldGlobals.uzoom;
		this.options.api = options.api || inputEx.MapFieldGlobals.api;
		this.options.api_key = options.api_key || inputEx.MapFieldGlobals.api_key;
	}
987172
@Override
    public Object map(Object input) {
        List<Object> ret = new ArrayList<>();
        Long l = (Long) input;
        for (DerivedColumn d : derivedColumns) {
            switch (d.columnType) {
                case String:
                    ret.add(d.dateTimeFormatter.print(l));
                    break;
                case Integer:
                    DateTime dt = new DateTime(l, inputTimeZone);
                    ret.add(dt.get(d.fieldType));
                    break;
                default:
                    throw new IllegalStateException("Unexpected column type: " + d.columnType);
            }
        }

        return ret;
    }
881942
function(e){
		 //the onBlur from an old version of inputex took in the AutoComplete.js file
	   if (this.hiddenEl.value != this.el.value && this.el.value != this.options.typeInvite) this.el.value = this.hiddenEl.value;
	     if(this.el.value == '' && this.options.typeInvite) {
	          Dom.addClass(this.divEl, "inputEx-typeInvite");
			   if (this.el.value == '') this.el.value = this.options.typeInvite;
      }
  }
1135572
private Optional<ArrayLabelSetter> createMapField(final Class<?> beanClass, final String fieldName) {
        
        final Field labelsField;
        try {
            labelsField = beanClass.getDeclaredField("labels");
            labelsField.setAccessible(true);
            
        } catch (NoSuchFieldException | SecurityException e) {
            // フィールドが見つからない場合は、何もしない。
            return Optional.empty();
        }
        
        if(!Map.class.isAssignableFrom(labelsField.getType())) {
            return Optional.empty();
        }
        
        final ParameterizedType type = (ParameterizedType) labelsField.getGenericType();
        final Class<?> keyType = (Class<?>) type.getActualTypeArguments()[0];
        final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[1];
        
        if(keyType.equals(String.class) && valueType.equals(String.class)) {
            return Optional.of(new ArrayLabelSetter() {
                
                @SuppressWarnings("unchecked")
                @Override
                public void set(final Object beanObj, final String label, final int index) {
                    ArgUtils.notNull(beanObj, "beanObj");
                    ArgUtils.notEmpty(label, "label");
                    
                    try {
                        Map<String, String> labelsMapObj = (Map<String, String>) labelsField.get(beanObj);
                        if(labelsMapObj == null) {
                            labelsMapObj = new LinkedHashMap<>();
                            labelsField.set(beanObj, labelsMapObj);
                        }
                        
                        final String mapKey = createMapKey(fieldName, index);
                        
                        labelsMapObj.put(mapKey, label);
                        
                    } catch (IllegalArgumentException | IllegalAccessException e) {
                        throw new RuntimeException("fail access labels field.", e);
                    }
                }
            });
            
        } else {
            // タイプが一致しない場合
            log.warn("not match generics type of labels. key type:{}, value type:{}.", keyType.getName(), valueType.getName());
            return Optional.empty();
        }
        
    }
713578
function (e) {
            this.props.actions.setRenameValue(this.props.parentPath + this.refs.name.value.trim());

            if (e.keyCode !== KeyEvent.DOM_VK_LEFT &&
                    e.keyCode !== KeyEvent.DOM_VK_RIGHT) {
                // update the width of the input field
                var node = this.refs.name,
                    newWidth = _measureText(node.value);
                $(node).width(newWidth);
            }
        }
704199
def formfield(self, **kwargs):
        """"""
        defaults = {
            'form_class': LocalizedIntegerFieldForm
        }

        defaults.update(kwargs)
        return super().formfield(**defaults)
781825
public Mapping<T> addFields() {

        if (idColumn == null) {
            throw new RuntimeException("Map ID column before adding class fields");
        }

        for (Field f : ReflectionUtils.getDeclaredFieldsInHierarchy(clazz)) {
            if (!Modifier.isStatic(f.getModifiers())
                    && !isFieldMapped(f.getName())
                    && !ignoredFields.contains(f.getName())) {
                addColumn(f.getName());
            }
        }

        return this;
    }
101175
void addFieldInfo(String className, List<FieldInfo> fieldInfoList) {
        if (ivFieldInfoMap == null) {
            ivFieldInfoMap = new HashMap<String, List<FieldInfo>>();
        }
        ivFieldInfoMap.put(className, fieldInfoList);
    }
946771
public void setMapOutputValueClass(Class<?> theClass
                                     ) throws IllegalStateException {
    ensureState(JobState.DEFINE);
    conf.setMapOutputValueClass(theClass);
  }
728014
function() {
      inputEx.MultiSelectField.superclass.renderComponent.call(this);
      
      this.ddlist = new inputEx.widget.ListCustom({parentEl: this.fieldContainer,listSelectOptions: this.listSelectOptions, maxItems: this.maxItems, maxItemsAlert: this.maxItemsAlert });
      
   }
439470
def formfield(self, **kwargs):
        
        widget_kwargs = {
            'lat_field': self.latitude_field_name,
            'lon_field': self.longitude_field_name,
        }

        if self.data_field_name:
            widget_kwargs['data_field'] = self.data_field_name

        defaults = {
            'form_class': OSMFormField,
            'widget': OSMWidget(**widget_kwargs),
        }
        defaults.update(kwargs)

        return super(OSMField, self).formfield(**defaults)
791108
private FieldSpec generateRxMappingMethod(ObjectMappableAnnotatedClass clazz) {

    String objectVarName = "item";
    String cursorVarName = "cursor";

    TypeName elementType = ClassName.get(clazz.getElement().asType());

    // new Func1<Cursor, ListsItem>()

    CodeBlock.Builder initBlockBuilder = CodeBlock.builder()
        .add("new $L<$L, $L>() {\n", Func1.class.getSimpleName(), Cursor.class.getSimpleName(),
            elementType)
        .indent()
        .add("@Override public $L call($L cursor) {\n", elementType, Cursor.class.getSimpleName())
        .indent();

    // assign the columns indexes
    generateColumnIndexCode(initBlockBuilder, clazz.getColumnAnnotatedElements(), cursorVarName);

    // Instantiate element
    initBlockBuilder.addStatement("$T $L = new $T()", elementType, objectVarName, elementType);

    // read cursor into element variable
    for (ColumnAnnotateable e : clazz.getColumnAnnotatedElements()) {
      String indexVaName = e.getColumnName() + "Index";
      initBlockBuilder.beginControlFlow("if ($L >= 0)", indexVaName);
      e.generateAssignStatement(initBlockBuilder, objectVarName, cursorVarName, indexVaName);
      initBlockBuilder.endControlFlow();
    }

    initBlockBuilder.addStatement("return $L", objectVarName)
        .unindent()
        .add("}\n") // end call () method
        .unindent()
        .add("}") // end anonymous class
        .build();

    ParameterizedTypeName fieldType =
        ParameterizedTypeName.get(ClassName.get(Func1.class), ClassName.get(Cursor.class),
            elementType);

    return FieldSpec.builder(fieldType, "MAPPER", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
        .initializer(initBlockBuilder.build())
        .build();
  }
989320
public void createAssignmentFieldMap(Props props)
   {
      //System.out.println("ASSIGN");
      byte[] fieldMapData = null;
      for (Integer key : ASSIGNMENT_KEYS)
      {
         fieldMapData = props.getByteArray(key);
         if (fieldMapData != null)
         {
            break;
         }
      }

      if (fieldMapData == null)
      {
         populateDefaultData(getDefaultAssignmentData());
      }
      else
      {
         createFieldMap(fieldMapData);
      }
   }
348480
public static void addInputMap(Node node, InputMap<?> im) {
        // getInputMap calls init, so can use unsafe setter
        setInputMapUnsafe(node, InputMap.sequence(im, getInputMap(node)));
    }
429829
function() {
      
      this.editorContainer = inputEx.cn('div', {className: CSS_PREFIX+'editor'}, {display: 'none'});
      
      //  field
      this.editorField = inputEx(this.options.editorField,this);
      var editorFieldEl = this.editorField.getEl();
      
      this.editorContainer.appendChild( editorFieldEl );
      Dom.addClass( editorFieldEl , CSS_PREFIX+'editorDiv');
      
      this.okButton = new inputEx.widget.Button({
         type: this.options.buttonTypes.ok,
         parentEl: this.editorContainer,
         value: inputEx.messages.okEditor,
         className: "inputEx-Button "+CSS_PREFIX+'OkButton',
         onClick: {fn: this.onOkEditor, scope:this}
      });

      this.cancelLink = new inputEx.widget.Button({
         type: this.options.buttonTypes.cancel,
         parentEl: this.editorContainer,
         value: inputEx.messages.cancelEditor,
         className: "inputEx-Button "+CSS_PREFIX+'CancelLink',
         onClick: {fn: this.onCancelEditor, scope:this}
      });
      
      // Line breaker ()
      this.editorContainer.appendChild( inputEx.cn('div',null, {clear: 'both'}) );
      
      this.fieldContainer.appendChild(this.editorContainer);
      
   }
220860
private Optional<MapLabelSetter> createField(final Class<?> beanClass, final String fieldName) {
        
        final String labelFieldName = fieldName + "Label";
        
        final Field labelField;
        try {
            labelField = beanClass.getDeclaredField(labelFieldName);
            labelField.setAccessible(true);
            
        } catch (NoSuchFieldException | SecurityException e) {
            return Optional.empty();
        }
        
        if(!Map.class.isAssignableFrom(labelField.getType())) {
            return Optional.empty();
        }
        
        final ParameterizedType type = (ParameterizedType) labelField.getGenericType();
        final Class<?> keyType = (Class<?>) type.getActualTypeArguments()[0];
        final Class<?> valueType = (Class<?>) type.getActualTypeArguments()[1];
        
        if(keyType.equals(String.class) && valueType.equals(String.class)) {
            
            return Optional.of(new MapLabelSetter() {
                
                @SuppressWarnings("unchecked")
                @Override
                public void set(final Object beanObj, final String label, final String key) {
                    ArgUtils.notNull(beanObj, "beanObj");
                    ArgUtils.notEmpty(label, "label");
                    
                   try {
                       Map<String, String> labelMapObj = (Map<String, String>) labelField.get(beanObj);
                       if(labelMapObj == null) {
                           labelMapObj = new LinkedHashMap<>();
                           labelField.set(beanObj, labelMapObj);
                       }
                       
                       
                       labelMapObj.put(key, label);
                       
                    } catch (IllegalArgumentException | IllegalAccessException e) {
                        throw new RuntimeException("fail access label field.", e);
                    }
                }
            });
            
        }
        
        return Optional.empty();
    }
850422
public static <K, V> MapField<K, V> newMapField(MapEntry<K, V> defaultEntry) {
        return new MapField<K, V>(defaultEntry, StorageMode.MAP, new HashMap<K, V>(), null);
    }