Set the data for the editor of this delegate to the inputed information.
        
        :param      editor | <QWidget>
                    index  | <QModelIndex>
431778
def setEditorData( self, editor, index ):
        
        item        = self.parent().itemFromIndex(index)
        value       = item.value()
        tree        = self.parent()
        querywidget = tree.parent()
        factory     = querywidget.factory()
        
        factory.setEditorData(editor, value)
427880
def createEditor(self, parent, column, operator, value):
        
        editor = super(ForeignKeyPlugin, self).createEditor(parent,
                                                            column,
                                                            operator,
                                                            value)
        
        if editor is not None:
            editor.setRequired(column.required())
            editor.setMinimumWidth(150)
            
            model = column.referenceModel()
            if model:
                text = model.schema().displayName().lower()
                editor.setHint('any {0}'.format(text))
                
                editor.setRecords(model.select())
                if operator in ('is in', 'is not in'):
                    editor.setCheckable(True)
        
        return editor
1309551
def set_editor(self, editor):
        
        if self._editor is not None:
            try:
                self._editor.offset_calculator.pic_infos_available.disconnect(
                    self._update)
            except (AttributeError, RuntimeError, ReferenceError):
                # see https://github.com/OpenCobolIDE/OpenCobolIDE/issues/89
                pass
        self._editor = weakref.proxy(editor) if editor else editor
        try:
            self._editor.offset_calculator.pic_infos_available.connect(
                self._update)
        except AttributeError:
            pass
483299
def createEditor(self, delegate, parent, option):
        
        return FloatCtiEditor(self, delegate, parent=parent)
665663
def updateEditor( self ):
        
        
        # assignt the rule operators to the choice list
        rule        = self.currentRule()
        operator    = self.currentOperator()
        widget      = self.uiWidgetAREA.widget()
        editorType  = None
        text        = ''
        
        if ( rule ):
            editorType = rule.editorType(operator)
        
        # no change in types
        if ( widget and editorType and type(widget) == editorType ):
            return
            
        elif ( widget ):
            if ( type(widget) != QWidget ):
                text = widget.text()
            
            widget.setParent(None)
            widget.deleteLater()
        
        self.uiWidgetAREA.setWidget(None)
        
        # create the new editor
        if ( editorType ):
            widget = editorType(self)
            
            if ( isinstance(widget, QLineEdit) ):
                terms  = rule.completionTerms()
                if ( not terms ):
                    qwidget = self.queryBuilderWidget()
                    if ( qwidget ):
                        terms = qwidget.completionTerms()
                
                if ( terms ):
                    widget.setCompleter(XQueryCompleter(terms, widget))
            
            self.uiWidgetAREA.setWidget(widget)
            
            if ( type(widget) != QWidget ):
                widget.setText(text)
1193475
def editors(self, value):
        """"""
        warnings.warn(
            _ASSIGNMENT_DEPRECATED_MSG.format("editors", EDITOR_ROLE),
            DeprecationWarning,
        )
        self[EDITOR_ROLE] = value
847252
function initComponents( editor ) {
		// Documented in dataprocessor.js.
		editor.dataProcessor = new CKEDITOR.htmlDataProcessor( editor );

		// Set activeFilter directly to avoid firing event.
		editor.filter = editor.activeFilter = new CKEDITOR.filter( editor );

		loadSkin( editor );
	}
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);
            }
        }
    }
1229699
def createEditor(self, parent, option, index):
        """"""
        # bring up separate window for component parameters
        view = parent.parentWidget()
        component = view.model().data(index)

        if component is not None:
            editor = component.showEditor()
        else:
            print 'delegate data type', type(component)
            raise Exception('UnknownDelegateType')

        # connect editor to update defaults
        editor.attributesSaved.connect(view.updateDefaults)
        editor.attributesSaved.connect(view.somethingChanged)

        if component.name == 'Vocalization':
            # find any associated file auto-parameters
            files = view.model().autoParams().findFileParam(component)
            if files is not None:
                editor.selectMany(files)
            editor.vocalFilesChanged.connect(view.updateVocalAuto)

        return editor
1356062
def setData(self, index, value, role=Qt.EditRole):
        """"""
        if not index.isValid():
            return False
        if index.column() < 3:
            return False
        value = display_to_value(value, self.get_value(index),
                                 ignore_errors=True)
        self.set_value(index, value)
        self.dataChanged.emit(index, index)
        return True
386737
def setValue( self, value ):
        
        if ( self._editor ):
            self._editor.setValue(value)
            return True
        return False
642192
def createEditor(self, delegate, parent, option):
        
        return StringCtiEditor(self, delegate, parent=parent)
1310836
def editorData( self, editor ):
        
        # set the information from a multi-tag edit
        if ( isinstance(editor, XMultiTagEdit) ):
            return editor.tags()
        
        # set the information from a combo box
        elif ( isinstance(editor, QComboBox) ):
            return nativestring(editor.currentText())
        
        # set the information from a line edit
        elif ( isinstance(editor, QLineEdit) ):
            return nativestring(editor.text())
        
        return None
1285327
def createEditor(self, delegate, parent, option):
        
        return SnFloatCtiEditor(self, delegate, self.precision, parent=parent)
187989
def iniedited(self, *args, **kwargs):
        
        self.inimodel.set_index_edited(self.files_lv.currentIndex(), True)
488757
def addComponentEditor(self):
        """"""
        row = self._model.rowCount()

        comp_stack_editor = ExploreComponentEditor()
        self.ui.trackStack.addWidget(comp_stack_editor)

        idx_button = IndexButton(row)
        idx_button.pickMe.connect(self.ui.trackStack.setCurrentIndex)
        self.trackBtnGroup.addButton(idx_button)
        self.ui.trackBtnLayout.addWidget(idx_button)
        self.ui.trackStack.setCurrentIndex(row)

        comp_stack_editor.closePlease.connect(self.removeComponentEditor)

        delay = Silence()
        comp_stack_editor.delaySpnbx.setValue(delay.duration())
        self._model.insertComponent(delay, row,0)

        self._allComponents.append([x() for x in self.stimuli_types if x.explore])
        for stim in self._allComponents[row]:
            editor = wrapComponent(stim).showEditor()
            comp_stack_editor.addWidget(editor, stim.name)

        exvocal = comp_stack_editor.widgetForName("Vocalization")
        if exvocal is not None:
            exvocal.filelistView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)

        initcomp = self._allComponents[row][0]
        self._model.insertComponent(initcomp, row, 1)

        self.buttons.append(idx_button)

        comp_stack_editor.exploreStimTypeCmbbx.currentIndexChanged.connect(lambda x : self.setStimIndex(row, x))
        comp_stack_editor.delaySpnbx.valueChanged.connect(lambda x : self.setDelay(row, x))
        comp_stack_editor.valueChanged.connect(self.valueChanged.emit)
        return comp_stack_editor
416542
def set_managing_editor(self):
        """"""
        try:
            self.managing_editor = self.soup.find('managingeditor').string
        except AttributeError:
            self.managing_editor = None