Parent widget calls this whenever the user edits channel info.
774522
def edit_channel_info(self, new_ch_name, ch_dct):
        
        self.ch_name = new_ch_name
        self.dct = ch_dct
        if ch_dct['type'] == 'analog':
            fmter = fmt.green
        else:
            fmter = fmt.blue
        self.ch_name_label.setText(fmt.b(fmter(self.ch_name)))
        self.generateToolTip()
1321951
def on_channel_open(self, channel):
        
        self._logger.debug('Channel opened')
        self._channel = channel
        self._channel.parent_client = self
        self.add_on_channel_close_callback()
        self.setup_exchange(self._exchange)
1294245
def tvBrowserHazard_selection_changed(self):
        """"""
        (is_compatible, desc) = self.get_layer_description_from_browser(
            'hazard')
        self.lblDescribeBrowserHazLayer.setText(desc)
        self.lblDescribeBrowserHazLayer.setEnabled(is_compatible)
        self.parent.pbnNext.setEnabled(is_compatible)
50334
def create_widget(self):
        
        d = self.declaration
        self.widget = EditText(self.get_context(), None,
                               d.style or "@attr/editTextStyle")
71070
void afterHtmlUpdate() {

        if (m_overlayTimer != null) {
            m_overlayTimer.cancel();
            m_overlayTimer = null;
        }
        m_runningUpdate = false;
        List<Element> elements = CmsEntityBackend.getInstance().getAttributeElements(
            m_parentEntity,
            m_attributeHandler.getAttributeName(),
            m_formParent.getElement());
        if (m_popupClosed) {
            // the form popup has already been closed, reinitialize the editing widgets for updated HTML
            CmsInlineEditOverlay.updateCurrentOverlayPosition();
            if (m_requireShowPopup) {
                if (elements.size() > m_attributeIndex) {
                    m_referenceElement = elements.get(m_attributeIndex);
                }
                showEditPopup(null);
                m_hasChanges = true;
            } else {
                CmsInlineEditOverlay.getRootOverlay().clearButtonPanel();
                m_htmlUpdateHandler.reinitWidgets(m_formParent);
            }

        } else {
            if (m_referenceElement != null) {
                CmsInlineEditOverlay.removeLastOverlay();
            }
            if (elements.size() > m_attributeIndex) {
                m_referenceElement = elements.get(m_attributeIndex);
                CmsInlineEditOverlay.addOverlayForElement(m_referenceElement);
            } else {
                m_referenceElement = m_formParent.getElement();
                CmsInlineEditOverlay.addOverlayForElement(m_referenceElement);
            }
        }
        // schedule to update the ovelay position
        m_overlayTimer = new Timer() {

            /** Timer run counter. */
            private int m_timerRuns;

            /**
             * @see com.google.gwt.user.client.Timer#run()
             */
            @Override
            public void run() {

                CmsInlineEditOverlay.updateCurrentOverlayPosition();
                if (m_timerRuns > 3) {
                    cancel();
                }
                m_timerRuns++;
            }
        };
        m_overlayTimer.scheduleRepeating(100);
    }
607750
protected void detectDirtyFields(Widget parent) {
        if (parent instanceof HasWidgets) {
            for (Widget widget : (HasWidgets) parent) {
                if (widget instanceof HasValue) {
                    HasValue valueWidget = (HasValue) widget;
                    registrations.add(valueWidget.addValueChangeHandler(event -> {
                        if (valueWidget.getValue() != null && ! valueWidget.getValue().equals("")) {
                            setDirty(true);
                        }
                    }));
                } else {
                    if (propagateToChildren) {
                        detectDirtyFields(widget);
                    }
                }
            }
        }
    }
483299
def createEditor(self, delegate, parent, option):
        
        return FloatCtiEditor(self, delegate, parent=parent)
1143852
def on_edit_grid(self, event):
        """"""
        if not self.changes:
            self.changes = {event.Row}
        else:
            self.changes.add(event.Row)
        #self.changes = True
        try:
            editor = event.GetControl()
            editor.Bind(wx.EVT_KEY_DOWN, self.onEditorKey)
        except AttributeError:
            # if it's a EVT_GRID_EDITOR_SHOWN, it doesn't have the GetControl method
            pass
160287
private void fireUserInputChange() {
		if (!internallySettingText && (this.listeners != null)) {
			for (Iterator it = this.listeners.iterator(); it.hasNext();) {
				UserInputListener userInputListener = (UserInputListener) it.next();
				userInputListener.update(this);
			}
		}
	}
976728
def edit( cls, record, parent = None, uifile = '', commit = True ):
        
        # create the dialog
        dlg = QDialog(parent)
        dlg.setWindowTitle('Edit %s' % record.schema().name())
        
        # create the widget
        cls    = record.schema().property('widgetClass', cls)
        
        widget = cls(dlg)
        
        if ( uifile ):
            widget.setUiFile(uifile)
        
        widget.setRecord(record)
        widget.layout().setContentsMargins(0, 0, 0, 0)
        
        # create buttons
        opts = QDialogButtonBox.Save | QDialogButtonBox.Cancel
        btns = QDialogButtonBox(opts, Qt.Horizontal, dlg)
        
        # create layout
        layout = QVBoxLayout()
        layout.addWidget(widget)
        layout.addWidget(btns)
        
        dlg.setLayout(layout)
        dlg.adjustSize()
        
        # create connections
        #btns.accepted.connect(widget.save)
        btns.rejected.connect(dlg.reject)
        widget.saved.connect(dlg.accept)
        
        if ( dlg.exec_() ):
            if commit:
                result = widget.record().commit()
                if 'errored' in result:
                    QMessageBox.information(self.window(),
                                            'Error Committing to Database',
                                            result['errored'])
                    return False
            return True
        return False
1293725
function handleWidgetVisibilityChange( newVisible, previousVisible ) {
               widgetIsVisible = newVisible;
               if( newVisible && previousVisible === false && showContent && options.animationsEnabled ) {
                  startWatchingForContentResizing();
               }
               else {
                  stopWatchingForContentResizing();
               }
            }
923751
public void editOn() {
        editOn = true;

        // Turns off the automatic refresh of all the displayers.
        for (Displayer displayer : displayerCoordinator.getDisplayerList()) {
            displayer.setRefreshOn(false);
        }
    }
787518
function() {
		switch (gui.Type.of(arguments[0])) {
			case 'string':
				this._channelOne.apply(this, arguments);
				break;
			case 'array':
				this._channelAll.apply(this, arguments);
				break;
		}
	}
953072
protected void updateState() {
        final WidgetState.State state;
        if (useParentState() || getFollowParentState()) {
            state = mParent.getState();
        } else {
            state = getState();
        }

        Log.d(Log.SUBSYSTEM.WIDGET, TAG, "updateState(): %s for '%s'", state, getName());
        if (!mLevelInfo.isEmpty() && mLevel >= 0) {
            mLevelInfo.get(mLevel).setState(state);
        }

        boolean updateChildren = isInFollowStateGroup()
                || getChildrenFollowState();
        for (Widget child : getChildren()) {
            if (updateChildren || child.getFollowParentState()) {
                child.updateState();
            }
        }
    }
1109899
def child_added(self, child):
        
        view = child.widget
        if view is not None:
            self.toast.setView(view)
1107038
def save_new_channel(self):
        
        form_info = self.input['form']
        channel = Channel(typ=15, name=form_info['name'],
                          description=form_info['description'],
                          owner_id=form_info['owner_id'])
        channel.blocking_save()
        self.current.task_data['target_channel_key'] = channel.key
430250
void notifyParentChanged(List<ParentChangedEvent> events) {
        for (int i = 0; i < events.size(); ++i) {
            ParentChangedEvent event = events.get(i);
            stateOnlyRemovalQueue.priorityChanged(event.state);
            if (event.state.parent != null && event.state.activeCountForTree != 0) {
                event.state.parent.offerAndInitializePseudoTime(event.state);
                event.state.parent.activeCountChangeForTree(event.state.activeCountForTree);
            }
        }
    }