Installs a <code>Searchable</code> into the given component.

@param propertyName
the property name.
@param component
the target component.
492704
@Override
    public void processComponent(String propertyName, JComponent component) {

        if (component instanceof JComboBox) {
            this.installSearchable((JComboBox) component);
        } else if (component instanceof JList) {
            this.installSearchable((JList) component);
        } else if (component instanceof JTable) {
            this.installSearchable((JTable) component);
        } else if (component instanceof JTextComponent) {
            this.installSearchable((JTextComponent) component);
        }
    }
538180
public void addRow(Component component) {

        Component actualComponent = component == null ? m_newComponentFactory.get() : component;
        I_CmsEditableGroupRow row = m_rowBuilder.buildRow(this, actualComponent);
        m_container.addComponent(row);
        updatePlaceholder();
        updateButtonBars();
        updateGroupValidation();
    }
1135484
public static boolean isPropertySettable(
                    final Class<?> clazz,
                    final String propertyName
                    )
    {
        if (clazz == null) {
            throw new IllegalArgumentException( "no class specified" );
        }

        if (propertyName == null) {
            throw new IllegalArgumentException( "no property specified" );
        }

        PropertyAccessor  accessor = _findAccessor( clazz, propertyName );

        return (accessor == null ? false : accessor.isSettable());
    }
84118
public void addProperty(ReadableProperty<R> property) {
        property.addValueChangeListener(changeAdapter);
        properties.add(property);
        updateFromProperties();
    }
1229687
public void addComponent(Object screenField)
    { // Set up the dependencies

        if (m_iNamePrefix != null)
            m_recThis.getField(m_iNamePrefix).addComponent(screenField);
        m_recThis.getField(m_iNameFirst).addComponent(screenField);
        if (m_iNameMiddle != null)
            m_recThis.getField(m_iNameMiddle).addComponent(screenField);
        m_recThis.getField(m_iNameSur).addComponent(screenField);
        if (m_iNameSuffix != null)
            m_recThis.getField(m_iNameSuffix).addComponent(screenField);
        if (m_iNameTitle != null)
            m_recThis.getField(m_iNameTitle).addComponent(screenField);

        super.addComponent(screenField);
    }
1349031
@Override
  public void add(int index, Object element) {    
    element = mapIfNumber(element);
    addComponent(index, element, ComponentEquality.EQUAL);
  }
866577
protected Component lookForComponent(String name, Component[] components) {
        for (int i = 0; i < components.length && !mFindWithEqual; i++) {
            //String componentName = ComponentNamer.getInstance().getNameForComponent(components[c]);
            Component c = components[i];
            checkName(name, c);
            if (!mFindWithEqual) {
                if (c instanceof Container) {
                    Component result = lookForComponent(name, ((Container) c).getComponents());
                    if (result != null) {
                        return result;
                    }
                }
            }
        }
        return null;
    }
1124261
public static void setPropertyReference(BeanDefinitionBuilder builder, String beanReference, String propertyName) {
        if (StringUtils.hasText(beanReference)) {
            builder.addPropertyReference(propertyName, beanReference);
        }
    }
1204190
public void addTaggedComponent(final String tag, final WComponent component) {
		if (Util.empty(tag)) {
			throw new IllegalArgumentException("A tag must be provided.");
		}
		if (component == null) {
			throw new IllegalArgumentException("A component must be provided.");
		}

		TemplateModel model = getOrCreateComponentModel();
		if (model.taggedComponents == null) {
			model.taggedComponents = new HashMap<>();
		} else {
			if (model.taggedComponents.containsKey(tag)) {
				throw new IllegalArgumentException("The tag [" + tag + "] has already been added.");
			}
			if (model.taggedComponents.containsValue(component)) {
				throw new IllegalArgumentException("Component has already been added.");
			}
		}
		model.taggedComponents.put(tag, component);
		add(component);
	}
1230970
public static void addPropertyBoolean(
        CmsCmisTypeManager typeManager,
        PropertiesImpl props,
        String typeId,
        Set<String> filter,
        String id,
        boolean value) {

        if (!checkAddProperty(typeManager, props, typeId, filter, id)) {
            return;
        }

        props.addProperty(new PropertyBooleanImpl(id, Boolean.valueOf(value)));
    }
601334
public static void addTo(
        JTabbedPane tabbedPane, String title, JComponent component)
    {
        addTo(tabbedPane, title, component, false);
    }
187400
protected void loadQueryProperties(String propertyFilename) {

        Properties properties = new Properties();

        try {
            properties.load(getClass().getClassLoader().getResourceAsStream(propertyFilename));
            m_queries.putAll(CmsCollectionsGenericWrapper.<String, String> map(properties));
            replaceQuerySearchPatterns();
        } catch (Throwable t) {
            if (LOG.isErrorEnabled()) {
                LOG.error(
                    Messages.get().getBundle().key(Messages.LOG_LOAD_QUERY_PROP_FILE_FAILED_1, propertyFilename),
                    t);
            }

            properties = null;
        }
    }
1100738
public static void addProperty(AtlasVertex vertex, String propertyName, Object value) {
        String actualPropertyName = GraphHelper.encodePropertyKey(propertyName);

        if (LOG.isDebugEnabled()) {
            LOG.debug("Adding property {} = \"{}\" to vertex {}", actualPropertyName, value, string(vertex));
        }

        vertex.addProperty(actualPropertyName, value);
    }
908237
public void loadChoices(String propertyName) {
        if (propertyName == null || propertyName.isEmpty()) {
            loadChoices(DEFAULT_CHOICES);
        } else {
            loadChoices(PropertyUtil.getValues(propertyName, null));
        }
    }
716776
private static void injectComponent(final Component<?> component, final boolean inner) {

        // Retrieve all fields annotated with Link
        for (final Field field : ClassUtility.getAnnotatedFields(component.getClass(), Link.class)) {
            final String keyPart = field.getAnnotation(Link.class).value();
            if (inner) {
                if (InnerComponent.class.isAssignableFrom(field.getType())) {
                    if (keyPart.isEmpty()) {
                        injectInnerComponent(component, field);
                    } else {
                        injectInnerComponent(component, field, keyPart);
                    }
                }
            } else {
                if (Component.class.isAssignableFrom(field.getType())) {
                    if (keyPart.isEmpty()) {
                        injectComponent(component, field);
                    } else {
                        injectComponent(component, field, keyPart);
                    }
                }
            }
        }

    }
1094343
function(propertyName) {
            // could check for DOM component, but this event should only be fired by such an entity!
            // Rather than triggering Invalidate on each of these, we rely on css() triggering that event
            switch (propertyName) {
                case "textAlign":
                    this._textAlign = this._element.style.textAlign;
                    break;
                case "color":
                    // Need to set individual color components, so use method
                    this.textColor(this._element.style.color);
                    break;
                case "fontType":
                    this._textFont.type = this._element.style.fontType;
                    break;
                case "fontWeight":
                    this._textFont.weight = this._element.style.fontWeight;
                    break;
                case "fontSize":
                    this._textFont.size = this._element.style.fontSize;
                    break;
                case "fontFamily":
                    this._textFont.family = this._element.style.fontFamily;
                    break;
                case "fontVariant":
                    this._textFont.variant = this._element.style.fontVariant;
                    break;
                case "lineHeight":
                    this._textFont.lineHeight = this._element.style.lineHeight;
                    break;
            }
        }
1280798
protected <T extends IComponent> void addComponent(Class<T> componentType, T component) {
        components.put(componentType, component);
    }