Builds a single form field.<p>

@param ownProps the entry's own properties
@param propName the property name
@param mode the mode which controls which kind of field will be built
760514
private void buildField(
        Map<String, CmsClientProperty> ownProps,
        final String propName,
        CmsClientProperty.Mode mode) {

        String entryId = m_handler.getId().toString();
        CmsXmlContentProperty propDef = m_propertyConfig.get(propName);

        if (propDef == null) {
            String widget = CmsClientProperty.PROPERTY_TEMPLATE.equals(propName) ? "template" : "string";
            propDef = new CmsXmlContentProperty(
                propName,
                "string",
                widget,
                "",
                null,
                null,
                null,
                null,
                null,
                null,
                null);
        }

        if (mode != Mode.effective) {
            propDef = propDef.withNiceName(propName);
        }

        CmsClientProperty ownProp = m_properties.get(propName);
        CmsPathValue pathValue = CmsClientProperty.getPathValue(ownProp, mode).prepend(entryId + "/" + propName + "/");

        //CHECK: should fields other than NavText be really automatically allowed to be empty in navigation mode?
        final String tab = tabs.get(mode);
        final CmsBasicFormField field = CmsBasicFormField.createField(
            propDef,
            pathValue.getPath() + "#" + tab,
            this,
            Collections.<String, String> emptyMap(),
            true);

        CmsPair<String, String> defaultValueAndOrigin = getDefaultValueToDisplay(ownProp, mode);
        String defaultValue = "";
        String origin = "";
        if (defaultValueAndOrigin != null) {
            defaultValue = defaultValueAndOrigin.getFirst();
            origin = defaultValueAndOrigin.getSecond();
        }
        final Widget w = (Widget)field.getWidget();
        I_CmsStringModel model = getStringModel(pathValue);
        field.bind(model);
        boolean ghost = CmsStringUtil.isEmptyOrWhitespaceOnly(pathValue.getValue());
        String initialValue = pathValue.getValue();
        if (w instanceof I_CmsHasGhostValue) {
            ((I_CmsHasGhostValue)w).setGhostValue(defaultValue, ghost);
            if (ghost) {
                initialValue = null;
            }
        }
        if (w instanceof HasFocusHandlers) {
            try {
                ((HasFocusHandlers)w).addFocusHandler(new FocusHandler() {

                    @SuppressWarnings("synthetic-access")
                    public void onFocus(FocusEvent event) {

                        if ((w instanceof CmsTextBox) || (w instanceof CmsTextArea)) {
                            m_activeFieldData = new CmsActiveFieldData(field, tab, propName);
                        } else {
                            // field received focus, but it doesn't make sense to restore it later
                            m_activeFieldData = null;
                        }
                    }
                });
            } catch (Exception e) {
                CmsDebugLog.consoleLog("" + e);
            }

        }

        boolean isShowingGhost = ghost && !CmsStringUtil.isEmpty(defaultValue);

        if (isShowingGhost) {
            field.getLayoutData().put("info", origin);
        }
        if (!ghost || isShowingGhost) {
            field.getLayoutData().put(CmsPropertyPanel.LD_DISPLAY_VALUE, "true");
        }
        field.getLayoutData().put(CmsPropertyPanel.LD_PROPERTY, propName);
        field.getLayoutData().put("tab", tab);
        m_form.addField(tab, field, initialValue);
    }
1079466
@Override
    public void set(String propName, Object value) {
        if (propName.equals(PROP_C)) {
            setC(((String) value));
        }
        if (propName.equals(PROP_COUNTRY_NAME)) {
            setCountryName(((String) value));
        }
        if (propName.equals(PROP_DESCRIPTION)) {
            getDescription().add(((String) value));
        }
        super.set(propName, value);
    }
1074578
function createPropsPrototype(props, parentProps, propTypes, componentClass) {
  const defaultProps = Object.create(null);

  Object.assign(defaultProps, parentProps, props);

  // Avoid freezing `id` prop
  const id = getComponentName(componentClass);
  delete props.id;

  // Add getters/setters for async prop properties
  Object.defineProperties(defaultProps, {
    // `id` is treated specially because layer might need to override it
    id: {
      configurable: false,
      writable: true,
      value: id
    }
  });

  // Add getters/setters for async prop properties
  addAsyncPropsToPropPrototype(defaultProps, propTypes);

  return defaultProps;
}
476973
public static void setProperties(Object bean, Map<String,?> props, Class<? extends Annotation> tagCls) throws IntrospectionException, IllegalAccessException, InvocationTargetException, InstantiationException
	{
		Class<?> beanCls;
		PropertyDescriptor[] descriptors;
		Map<String,PropertyDescriptor> descriptorMap = new HashMap<String,PropertyDescriptor>();
		Method meth;
		String name;
		Object value;
		Class<?> propCls;
		Class<?> valCls;

		beanCls = bean.getClass();
		if((descriptors = Introspector.getBeanInfo(beanCls).getPropertyDescriptors())==null)
			throw new IllegalArgumentException("Unable to get PropertyDescriptors for class " + beanCls.getName() + '.');
		for(PropertyDescriptor pd : descriptors)
			descriptorMap.put(pd.getName(), pd);
		for(Map.Entry<String,?> prop : props.entrySet())
		{
			name = prop.getKey();
			value = prop.getValue();
			PropertyDescriptor pd;

			if((pd=descriptorMap.get(name))==null)
				throw new IllegalArgumentException("Bean class " + beanCls.getName() + " does not have property " + name + '.');
			if((meth=pd.getWriteMethod())==null)
				throw new IllegalArgumentException("Bean class " + beanCls.getName() + " does not have a setter for property " + name + '.');
			if((propCls = pd.getPropertyType())==null)
				throw new IllegalArgumentException("Bean class " + beanCls.getName() + " does not have a type for property " + name + '.');
			propCls = Reflections.wrapperIfPrimitive(propCls);
			if(value==null)
				valCls = propCls;
			else
				valCls = value.getClass();
			if(!propCls.isAssignableFrom(valCls))
			{
				if(String.class.equals(valCls))
				{
					setPropertyAsText(bean, name, (String)value, pd, propCls, tagCls);
					continue;
				}
				throw new IllegalArgumentException("Property " + name + " of class " + beanCls.getName() + " is of type " + propCls.getName() + " which is not assignable from " + valCls.getName() + '.');
			}
			if(tagCls!=null&&!meth.isAnnotationPresent(tagCls))
				throw new IllegalArgumentException("Write method " + meth + " for property " + name + " of class " + bean.getClass() + " does not have annotation " + tagCls + '.');
			meth.invoke(bean, prop.getValue());
		}
	}
1075063
protected void handleAddProperty(EntityBuilder builder, String propName, Field currentField, Object obj) {
        builder.addProperty(propName, ReflectionUtils.getFieldValue(currentField, obj));
    }
274438
private void processPropDefaultValues() {
    getMethodsWithAnnotation(component, PropDefault.class).forEach(method -> {
      PropDefault propValidator = method.getAnnotation(PropDefault.class);

      String exposedMethodName = exposeExistingJavaMethodToJs(method);
      String propertyName = propValidator.value();
      optionsBuilder.addStatement("options.addJavaPropDefaultValue(p.$L, $S)",
          exposedMethodName,
          propertyName);
    });
  }
570993
function buildPropertyPaths(oObject, sObjectName) {
				Object.keys(oObject).forEach(function (sProperty) {
					var sPropertyPath = _Helper.buildPath(sObjectName, sProperty),
						vPropertyValue = oObject[sProperty];

					if (sProperty === "@$ui5._") {
						return; // ignore private namespace
					}

					if (vPropertyValue !== null && typeof vPropertyValue === "object") {
						buildPropertyPaths(vPropertyValue, sPropertyPath);
					} else {
						aSelect.push(sPropertyPath);
					}
				});
			}
854009
@Override
    public void onCreateProperty(String reference, PropertyRecord prop) {
        closePropertyDialoge();

        String[] tokens = reference.split("_#_");

        ModelNode operation = new ModelNode();
        operation.get(ADDRESS).set(Baseadress.get());
        operation.get(ADDRESS).add("subsystem", "jgroups");
        operation.get(ADDRESS).add("stack", tokens[0]);
        operation.get(ADDRESS).add("protocol", tokens[1]);
        operation.get(OP).set("map-put");
        operation.get(NAME).set("properties");
        operation.get("key").set(prop.getKey());
        operation.get("value").set(prop.getValue());

        dispatcher.execute(new DMRAction(operation), new SimpleCallback<DMRResponse>() {
            @Override
            public void onSuccess(DMRResponse result) {
                ModelNode response = result.get();

                if (response.isFailure()) {
                    Console.error(Console.MESSAGES.addingFailed("Protocol Property"), response.getFailureDescription());
                } else {
                    Console.info(Console.MESSAGES.added("Protocol Property"));

                    loadStacks(true);
                }
            }
        });
    }
495615
private void loadProperties(String propFileName) {
		if (propFileName != null) {
			loadProperties(getClass().getResourceAsStream(propFileName), propFileName);
		}
	}
654465
@JsOverlay
  public final void addJavaPropDefaultValue(Function javaMethod, String propertyName) {
    PropOptions propDefinition = getProps().get(propertyName);
    propDefinition.defaultValue = javaMethod;
  }
998539
public void addProperty(final String propertyName, final String value) {
        Preconditions.checkNotNull(propertyName);
        Preconditions.checkNotNull(value);
        List<String> values = properties.get(propertyName);
        if (values == null) {
            values = new ArrayList<>();
            values.add(value);
            properties.put(propertyName, values);
        } else {
            values.add(value);
        }
    }
582637
protected void saveProps(Properties props) throws IOException {

		if (loadFromPropertiesFile) {
			// Persist the change to the properties file.
			File file = getPropsFile();
			if (file != null) {
				FileWriter writer = new FileWriter(file);
				try {
					props.store(writer, null);
				} finally {
					writer.close();
				}
			}
		}
	}
145781
private void parseProperty(I_CmsXmlContentLocation field) {

        CmsPropertyConfig propConfig = parseProperty(m_cms, field);
        m_propertyConfigs.add(propConfig);
    }
203819
private CmsPair<String, String> getDefaultValueToDisplay(CmsClientProperty prop, Mode mode) {

        if ((mode == Mode.structure) && !CmsStringUtil.isEmpty(prop.getResourceValue())) {
            String message = Messages.get().key(Messages.GUI_ORIGIN_SHARED_0);

            return CmsPair.create(prop.getResourceValue(), message);
        }
        CmsClientProperty inheritedProperty = m_handler.getInheritedProperty(prop.getName());
        if (CmsClientProperty.isPropertyEmpty(inheritedProperty)) {
            return null;
        }
        CmsPathValue pathValue = inheritedProperty.getPathValue(mode);
        String message = Messages.get().key(Messages.GUI_ORIGIN_INHERITED_1, inheritedProperty.getOrigin());
        return CmsPair.create(pathValue.getValue(), message);
    }
988120
private void processProps() {
    ElementFilter
        .fieldsIn(component.getEnclosedElements())
        .stream()
        .filter(field -> hasAnnotation(field, Prop.class))
        .forEach(field -> {
          String propName = field.getSimpleName().toString();
          Prop prop = field.getAnnotation(Prop.class);

          collectionFieldsValidator.validateComponentPropField(field);

          fieldsWithNameExposed.add(new ExposedField(propName, field.asType()));

          optionsBuilder.addStatement(
              "options.addJavaProp($S, $T.getFieldName(this, () -> this.$L = $L), $L, $S)",
              propName,
              VueGWTTools.class,
              propName,
              getFieldMarkingValueForType(field.asType()),
              prop.required(),
              prop.checkType() ? getNativeNameForJavaType(field.asType()) : null
          );
        });
  }
243154
private void createProperties(ClassName vueFactoryType, Builder vueFactoryBuilder) {
    vueFactoryBuilder.addField(FieldSpec
        .builder(vueFactoryType, INSTANCE_PROP, Modifier.PRIVATE, Modifier.STATIC)
        .build());
  }
984758
protected static CmsProperty createPropertyObject(String name, String value) {

        CmsProperty prop = new CmsProperty();
        prop.setAutoCreatePropertyDefinition(true);
        prop.setName(name);
        if (OpenCms.getWorkplaceManager().isDefaultPropertiesOnStructure()) {
            prop.setValue(value, CmsProperty.TYPE_INDIVIDUAL);
        } else {
            prop.setValue(value, CmsProperty.TYPE_SHARED);
        }
        return prop;
    }