Emits a signal to update start values on components
974373
def closeEvent(self, event):
        """"""
        self.visibilityChanged.emit(0)
        model = self.paramList.model()
        model.hintRequested.disconnect()
        model.rowsInserted.disconnect()
        model.rowsRemoved.disconnect()
876738
function startListening () {
    if (isBuilt === false) {
      app.listen(
        parseInt(port),
        host,
        () => {
          isBuilt = true
          console.log(chalk.green(`[React Emoji Component SSR] ${host}:${port}`))
        }
      )
    }
  }
987134
@Override
    public void afterInitialized(BaseComponent comp) {
        super.afterInitialized(comp);
        createLabel("default");
        getEventManager().subscribe(EventUtil.STATUS_EVENT, this);
    }
781284
function start() {
    exec(function (a) {
        var tempListeners = listeners.slice(0);
        accel = new Acceleration(a.x, a.y, a.z, a.timestamp);
        for (var i = 0, l = tempListeners.length; i < l; i++) {
            tempListeners[i].win(accel);
        }
    }, function (e) {
        var tempListeners = listeners.slice(0);
        for (var i = 0, l = tempListeners.length; i < l; i++) {
            tempListeners[i].fail(e);
        }
    }, "Accelerometer", "start", []);
    running = true;
}
376586
static void traceComponentUpdated(TraceComponent tc) {
        for (TraceComponentChangeListener listener : registeredListeners.get()) {
            listener.traceComponentUpdated(tc);
        }
    }
1165860
def _trigger_refresh(self, key):
        ""
        if self.top_level:
            self.update(key)
        else:
            self.current_key = None
            self.current_frame = None
963122
def listen_to_event_updates():
    """"""
    def callback(event):
        print('Event:', event)

    client.create_event_subscription(instance='simulator', on_data=callback)

    sleep(5)
791978
def update(self, value):
        
        self.update_internal(value)
        self.emit('changed', self.get_widget_value())
979861
function turnOnListeningAndUpdate(listenToObservable, updateObservable, updateFunction, queue) {
	var onValueOrOnEmitFn;

	// Use either onValue or onEmit depending on which Symbols are on the `observable`
	if (listenToObservable[onValueSymbol]) {
		onValueOrOnEmitFn = canReflect.onValue;
	} else if (listenToObservable[onEmitSymbol]) {
		onValueOrOnEmitFn = onEmit;
	}

	if (onValueOrOnEmitFn) {
		onValueOrOnEmitFn(listenToObservable, updateFunction, queue);

		//!steal-remove-start
		if(process.env.NODE_ENV !== 'production') {

			// The updateObservable is mutated by listenToObservable
			canReflectDeps.addMutatedBy(updateObservable, listenToObservable);

			// The updateFunction mutates updateObservable
			updateFunction[getChangesSymbol] = function getChangesDependencyRecord() {
				var s = new Set();
				s.add(updateObservable);
				return {
					valueDependencies: s
				};
			};

		}

		//!steal-remove-end
	}
}
1100188
def _trigger_refresh(self, key):
        ""
        # Update if not top-level, batched or an ElementPlot
        if not self.top_level or isinstance(self, GenericElementPlot):
            self.update(key)
924522
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        self.refresh_nodes.emit()
        return True
1330419
public void emit(ComponentInfo componentInfo, EmitInfo info)
    {
        if (this.sessions.size() == 0)
        {
            return;
        }

        Date nowTime = new Date();
        DateFormat format = new SimpleDateFormat(DATE_PATTERN);
        String nowTimeStr = format.format(nowTime);

        Map<String, Object> objectMap = Maps.newHashMap();
        objectMap.put("time", nowTimeStr);
        objectMap.put("component", componentInfo);
        objectMap.put("emitinfo", info);

        String logInfo;
        try
        {
            logInfo = this.mapper.writeValueAsString(objectMap);
        }
        catch (JsonProcessingException ex)
        {
            String msgFormat = "Event convert failed. Skip log output. : ComponentInfo={0}, EmitInfo={1}";
            String message = MessageFormat.format(msgFormat, componentInfo,
                    ToStringBuilder.reflectionToString(info, ToStringStyle.SHORT_PREFIX_STYLE));
            logger.warn(message, ex);
            return;
        }

        for (Entry<String, Session> entry : this.sessions.entrySet())
        {
            entry.getValue().getAsyncRemote().sendText(logInfo, this.handler);
        }
    }
1070136
def _start(self):
        """"""

        # TODO : make an update method instead

        last_call = 42
        while self._focus:
            sleep(1 / 100)

            mouse = pygame.mouse.get_pos()
            last_value = self.get()
            self.value_px = mouse[0]

            # we do not need to do anything when it the same value
            if self.get() == last_value:
                continue

            if last_call + self.interval / 1000 < time():
                last_call = time()
                self.func(self.get())
1225588
def setup_signals(self, ):
        
        prjlvl = self.prjbrws.get_level(0)
        prjlvl.new_root.connect(self.update_browsers)
        for rb in self._releasetype_button_mapping.values():
            rb.toggled.connect(self.releasetype_btn_toggled)

        shotdesclvl = self.shotbrws.get_level(3)
        shotselcb = partial(self.selection_changed,
                            source=self.shotbrws,
                            update=self.shotverbrws,
                            commentbrowser=self.shotcommentbrws,
                            mapper=self.shot_info_mapper)
        shotdesclvl.new_root.connect(shotselcb)
        shotverlvl = self.shotverbrws.get_level(0)
        shotverlvl.new_root.connect(self.shot_ver_sel_changed)
        shotmappercb = partial(self.set_mapper_index, mapper=self.shot_info_mapper)
        shotverlvl.new_root.connect(shotmappercb)
        shotverlvl.new_root.connect(partial(self.shotcommentbrws.set_root, 0))

        assetdesclvl = self.assetbrws.get_level(3)
        assetselcb = partial(self.selection_changed,
                             source=self.assetbrws,
                             update=self.assetverbrws,
                             commentbrowser=self.assetcommentbrws,
                             mapper=self.asset_info_mapper)
        assetdesclvl.new_root.connect(assetselcb)
        assetverlvl = self.assetverbrws.get_level(0)
        assetverlvl.new_root.connect(self.asset_ver_sel_changed)
        assetmappercb = partial(self.set_mapper_index, mapper=self.asset_info_mapper)
        assetverlvl.new_root.connect(assetmappercb)
        assetverlvl.new_root.connect(partial(self.assetcommentbrws.set_root, 0))

        self.current_pb.clicked.connect(self.set_to_current)
        self.asset_open_path_tb.clicked.connect(self.open_asset_path)
        self.shot_open_path_tb.clicked.connect(self.open_shot_path)
        self.refresh_tb.clicked.connect(self.refresh)
752585
def notify_change(self, change):
        """"""
        # Send the state to the frontend before the user-registered callbacks
        # are called.
        name = change['name']
        if self.comm is not None and self.comm.kernel is not None:
            # Make sure this isn't information that the front-end just sent us.
            if name in self.keys and self._should_send_property(name, getattr(self, name)):
                # Send new state to front-end
                self.send_state(key=name)
        super(Widget, self).notify_change(change)
1018178
public void signal(Signal signal, CmsUUID id) {

        getStatus(id).handleSignal(signal);
        runSelectionChangeAction();
    }
1142005
def update_on_event(self, e):
        """"""
        if e.type == QUIT:
            self.running = False

        elif e.type == KEYDOWN:
            if e.key == K_ESCAPE:
                self.running = False

            elif e.key == K_F4 and e.mod & KMOD_ALT:  # Alt+F4 --> quits
                self.running = False

        elif e.type == VIDEORESIZE:
            self.SCREEN_SIZE = e.size
            self.screen = self.new_screen()