Creates a fully configured text editor with the given initial value

@param parent
@param initialValue
@return the configured text editor
518863
protected Text createText(Composite parent, String initialValue)
	{
		Text t = SWTFactory.createText(parent, SWT.SINGLE | SWT.BORDER, 1);
		t.setText(initialValue);
		return t;
	}
1349947
def createEditor(self, parent, option, index):
        
        logger.debug("ConfigItemDelegate.createEditor, parent: {!r}".format(parent.objectName()))
        assert index.isValid(), "sanity check failed: invalid index"

        cti = index.model().getItem(index)
        editor = cti.createEditor(self, parent, option)
        return editor
736914
protected void createAgentNameEditor(Composite parent, String text) {
		final Group group = SWTFactory.createGroup(parent, text, 2, 1, GridData.FILL_HORIZONTAL);
		this.agentNameTextField = SWTFactory.createSingleText(group, 1);
		this.agentNameTextField.addModifyListener(new ModifyListener() {
			@SuppressWarnings("synthetic-access")
			@Override
			public void modifyText(ModifyEvent event) {
				SARLAgentMainLaunchConfigurationTab.this.lastAgentNameError = null;
				updateLaunchConfigurationDialog();
			}
		});
		ControlAccessibleListener.addListener(this.agentNameTextField, group.getText());
		this.agentNameSearchButton = createPushButton(group, Messages.MainLaunchConfigurationTab_1, null);
		this.agentNameSearchButton.addSelectionListener(new SelectionListener() {
			@Override
			public void widgetDefaultSelected(SelectionEvent event) {
				//
			}

			@Override
			public void widgetSelected(SelectionEvent event) {
				handleAgentNameSearchButtonSelected();
			}
		});
	}
88861
private static IIOMetadataNode getOrCreateChildNode(IIOMetadataNode parentNode, String name)
    {
        NodeList nodeList = parentNode.getElementsByTagName(name);
        if (nodeList.getLength() > 0)
        {
            return (IIOMetadataNode) nodeList.item(0);
        }
        IIOMetadataNode childNode = new IIOMetadataNode(name);
        parentNode.appendChild(childNode);
        return childNode;
    }
1204263
protected void createLaunchOptionEditor(Composite parent, String text) {
		final Group group = SWTFactory.createGroup(parent, text, 1, 1, GridData.FILL_HORIZONTAL);
		this.showLogoOptionButton = createCheckButton(group, Messages.MainLaunchConfigurationTab_14);
		this.showLogoOptionButton.addSelectionListener(this.defaultListener);
		this.showLogInfoButton = createCheckButton(group, Messages.MainLaunchConfigurationTab_15);
		this.showLogInfoButton.addSelectionListener(this.defaultListener);
		this.offlineButton = createCheckButton(group, Messages.MainLaunchConfigurationTab_16);
		this.offlineButton.addSelectionListener(this.defaultListener);
		this.enableAssertionsInRunModeButton = createCheckButton(group, Messages.SARLMainLaunchConfigurationTab_2);
		this.enableAssertionsInRunModeButton.addSelectionListener(this.defaultListener);
		this.enableAssertionsInDebugModeButton = createCheckButton(group, Messages.SARLMainLaunchConfigurationTab_1);
		this.enableAssertionsInDebugModeButton.addSelectionListener(this.defaultListener);
		this.runInEclipseButton = createCheckButton(group, Messages.SARLMainLaunchConfigurationTab_0);
		this.runInEclipseButton.addSelectionListener(this.defaultListener);
	}
1061623
def createEditor(self, parent, column, operator, value):
        
        editor = super(EnumPlugin, self).createEditor(parent,
                                                      column,
                                                      operator,
                                                      value)
        
        editor.setEnum(column.enum())
        if operator in ('contains', 'does not contain'):
            editor.setCheckable(True)
        
        editor.setCurrentValue(value)
        return editor
1001779
def createEditor(self, delegate, parent, option):
        
        return ChoiceCtiEditor(self, delegate, parent=parent)
1031045
@SuppressWarnings("unchecked")
    private void initialize(Document document, String editorUri) {

        m_parameters.clear();

        // get the root element of the configuration
        Element rootElement = document.getRootElement();

        // set the label of the editor
        setEditorLabel(rootElement.elementText(N_LABEL));

        // set the widget editor class if available
        String widgetClass = rootElement.elementText(N_WIDGETEDITOR);
        if (CmsStringUtil.isNotEmpty(widgetClass)) {
            setWidgetEditor(widgetClass);
        }

        // set the URI of the editor
        setEditorUri(editorUri);

        // create the map of valid resource types
        Iterator<Element> i = rootElement.element(N_RESOURCETYPES).elementIterator(N_TYPE);
        Map<String, String[]> resTypes = new HashMap<String, String[]>();
        while (i.hasNext()) {
            Element currentType = i.next();
            float ranking;
            String name = currentType.elementText(N_NAME);
            if (CmsStringUtil.isEmpty(name)) {
                logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_NAME_0), null);
                continue;
            }
            try {
                ranking = Float.parseFloat(currentType.elementText(N_RANKING));
            } catch (Throwable t) {
                logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_RANKING_1, name), t);
                continue;
            }
            String mapTo = currentType.elementText(N_MAPTO);
            if (CmsStringUtil.isEmpty(mapTo)) {
                mapTo = null;
            }
            resTypes.put(name, new String[] {"" + ranking, mapTo});
        }
        // add the additional resource types
        i = rootElement.element(N_RESOURCETYPES).elementIterator(N_CLASS);
        while (i.hasNext()) {
            Element currentClass = i.next();
            String name = currentClass.elementText(N_NAME);
            List<String> assignedTypes = new ArrayList<String>();
            try {
                // get the editor type matcher class
                I_CmsEditorTypeMatcher matcher = (I_CmsEditorTypeMatcher)Class.forName(name).newInstance();
                assignedTypes = matcher.getAdditionalResourceTypes();
            } catch (Throwable t) {
                logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_CLASS_1, name), t);
                continue;
            }
            float ranking;
            try {
                ranking = Float.parseFloat(currentClass.elementText(N_RANKING));
            } catch (Throwable t) {
                logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_RANKING_1, name), t);
                continue;
            }
            String mapTo = currentClass.elementText(N_MAPTO);
            if ("".equals(mapTo)) {
                mapTo = null;
            }
            // now loop through all types found and add them
            Iterator<String> j = assignedTypes.iterator();
            while (j.hasNext()) {
                String typeName = j.next();
                resTypes.put(typeName, new String[] {"" + ranking, mapTo});
            }
        }

        setResourceTypes(resTypes);

        // create the list of user agents & compiled patterns for editor
        i = document.getRootElement().element(N_USERAGENTS).elementIterator(N_AGENT);
        List<Pattern> pattern = new ArrayList<Pattern>();
        List<String> userAgents = new ArrayList<String>();
        while (i.hasNext()) {
            Element currentAgent = i.next();
            String agentName = currentAgent.getText();
            if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(agentName)) {
                userAgents.add(agentName);
                try {
                    pattern.add(Pattern.compile(agentName));
                } catch (PatternSyntaxException e) {
                    logConfigurationError(
                        Messages.get().getBundle().key(Messages.ERR_COMPILE_EDITOR_REGEX_1, agentName),
                        e);
                }
            } else {
                logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_USERAGENT_DEF_0), null);
            }
        }
        setBrowserPattern(pattern);
        setUserAgentsRegEx(userAgents);

        Element paramsElement = (Element)(document.getRootElement().selectSingleNode(N_PARAMS));
        if (paramsElement != null) {
            List<?> params = paramsElement.selectNodes(N_PARAM);
            for (Object paramObj : params) {
                Element paramElement = (Element)paramObj;
                String name = paramElement.attributeValue(A_NAME);
                String value = paramElement.getText();
                m_parameters.put(name, value);
            }
        }
    }
905789
final void internalReset(long initialValue) {
		Cell[] as = cells;
		base = initialValue;
		if (as != null) {
			int n = as.length;
			for (int i = 0; i < n; ++i) {
				Cell a = as[i];
				if (a != null) a.value = initialValue;
			}
		}
	}
898744
public static void setInitialsThumb(Context context, TextView initialsView, String fullName) {
        char initial1 = '\u0000';
        char initial2 = '\u0000';
        if (fullName != null) {
            String[] nameParts = fullName.split(" ");
            if (nameParts[0].length() > 0) {
                initial1 = nameParts[0].charAt(0);
            }
            if (nameParts.length > 1) {
                initial2 = nameParts[nameParts.length - 1].charAt(0);
            }
        }
        setColorForInitialsThumb(initialsView, initial1 + initial2);
        initialsView.setText(initial1 + "" + initial2);
        initialsView.setTextColor(Color.WHITE);
    }
1239006
protected void setAutocomplete(final String autocompleteValue) {
		final String newValue = Util.empty(autocompleteValue) ? null : autocompleteValue;
		if (!Util.equals(newValue, getAutocomplete())) {
			getOrCreateComponentModel().autocomplete = newValue;
		}
	}
141654
function(parentValue, nameIndex) {

                                            if (nameIndex > defaultPropertyDepth) {
                                                defaultObserve = currentObserve;
                                                defaultReads = currentReads;
                                                defaultPropertyDepth = nameIndex;
                                                defaultScope = scope;

                                                defaultComputeReadings = can.__clearReading();
                                            }
                                        }
103966
private void jTreeDatabaseValueChanged (javax.swing.event.TreeSelectionEvent evt)//GEN-FIRST:event_jTreeDatabaseValueChanged
    {//GEN-HEADEREND:event_jTreeDatabaseValueChanged
        // Add your handling code here:
        Object selectedObject = evt.getPath().getLastPathComponent();
        if (selectedObject instanceof PropertyEditorTarget)
        {
            PropertyEditorTarget p = (PropertyEditorTarget)selectedObject;
            if (p.getPropertyEditorClass() != null)
            {
                try
                {
                    if(!this.hmPropertyEditors.containsKey(p.getPropertyEditorClass()))
                    {
                        this.hmPropertyEditors.put(p.getPropertyEditorClass(), p.getPropertyEditorClass().newInstance());
                    }
                    PropertyEditor propertyEditor = (PropertyEditor)hmPropertyEditors.get(p.getPropertyEditorClass());
                    this.jScrlProperty.setViewportView(propertyEditor);
                    propertyEditor.setEditorTarget(p);
                }
                catch (Throwable t)
                {
                    t.printStackTrace();
                    this.jScrlProperty.setViewportView(null);
                }
            }
            else
            {
                this.jScrlProperty.setViewportView(null);
            }
        }
        else
        {
            this.jScrlProperty.setViewportView(null);
        }
    }
1069043
public static InitialValueFinder newInstance(final FieldNode variable, final Initialisers initialisers,
            final EnhancedClassNode enhancedClassNode) {
        return new InitialValueFinder(checkNotNull(variable), checkNotNull(initialisers),
                checkNotNull(enhancedClassNode));
    }
861336
function init( element, value, bindings ) {
    var $el = $( element );
    var model = value();
    var allBindings = unwrap( bindings() );
    var options = ko.toJS( allBindings.froalaOptions );

    // initialize the editor
    $el.froalaEditor( options || {} );

    // provide froala editor instance for flexibility
    if( allBindings.froalaInstance && ko.isWriteableObservable( allBindings.froalaInstance ) ) {
      allBindings.froalaInstance( $el.data( 'froala.editor' ) );
    }

    // update underlying model whenever editor content changed
    var processUpdateEvent = function (e, editor) {
        if (ko.isWriteableObservable(model)) {
            var editorValue = editor.html.get();
            var current = model();
            if (current !== editorValue) {
                model(editorValue);
            }
        }
    }

    $el.on('froalaEditor.contentChanged', processUpdateEvent);
    $el.on('froalaEditor.paste.after', processUpdateEvent);

    // cleanup editor, when dom node is removed
    ko.utils.domNodeDisposal.addDisposeCallback( element, destroy( element ) );

    // do not handle child nodes
    return { controlsDescendantBindings: true };
  }
494190
public static EntityType create(@NonNull String name, EntityType parent) {
      EntityType toReturn = DynamicEnum.register(new EntityType(name, parent));
      if (toReturn.setParentIfAbsent(parent)) {
         Config.setProperty(toReturn.canonicalName() + ".parent", parent.canonicalName());
      }
      values.add(toReturn);
      return toReturn;
   }
285665
public final ControlPrevalue createNewControlPrevalue() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createNewControlPrevalue");
    ControlPrevalue msg = null;
    try {
      msg = new ControlPrevalueImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createNewControlPrevalue");
    return msg;
  }