Restart button click handler
504903
function () {
                    HealthLogger.sendAnalyticsData(
                        autoUpdateEventNames.AUTOUPDATE_DOWNLOAD_COMPLETE_USER_CLICK_RESTART,
                        "autoUpdate",
                        "installNotification",
                        "installNow ",
                        "click"
                    );
                    detachUpdateBarBtnHandlers();
                    initiateUpdateProcess(statusObj.installerPath, statusObj.logFilePath, statusObj.installStatusFilePath);
                }
1336887
@EventListener
    public void handleRefreshEvent(final RefreshRemoteApplicationEvent event) {
        LOGGER.trace("Received event [{}]", event);
        configurationPropertiesEnvironmentManager.rebindCasConfigurationProperties(this.applicationContext);
    }
838734
public void restartListener(String _url) {
    if (getConfig().setListenerURL(_url)) {
      if (_server != null)
        _server.shutdownNow();
      try {
        startListener();
      } catch (IOException | URISyntaxException e) {
        Console.severe("Unable to start services.");
        e.printStackTrace();
      }
    }
  }
158592
public void restart() {
		if (frames.size() == 0) {
			return;
		}
		stopped = false;
		currentFrame = 0;
		nextChange = (int) (((Frame) frames.get(0)).duration / speed);
		firstUpdate = true;
		lastUpdate = 0;
	}
1220838
protected void onClickSave() {

        Timer timer = new Timer() {

            @Override
            public void run() {

                m_aliasList.clearValidationErrors();
                m_aliasValidationStatus = VALIDATION_RUNNING;
                m_propertyValidationStatus = VALIDATION_RUNNING;
                m_aliasList.validate(new Runnable() {

                    public void run() {

                        m_aliasValidationStatus = !m_aliasList.hasValidationErrors()
                        ? VALIDATION_OK
                        : VALIDATION_FAILED;
                        update(true);

                    }
                });
                m_propertyEditor.getForm().validateAndSubmit();
            }
        };
        // slight delay so that the validation doesn't interfere with validations triggered by the change event
        timer.schedule(20);
    }
584085
def on_click(self, handler):
        ''' 

        '''
        self.on_event(ButtonClick, handler)
        self.on_event(MenuItemClick, handler)
1351955
function restartOnProcess( index ) {
  log( 'Attempting to restart ' + index + '...' );

  // generate delegate function to pass with proper contexts.
  var startRequest = (function(context, index) {
    return function(cb) {
        startForeverWithIndex.call(context, index, cb);
    };
  }(this, index));

  done = this.async();
  findProcessWithIndex( index, function(process) {
    if(typeof process !== 'undefined') {
      log(forever.format(true,[process]));
      forever.restart(index, false);
      done();
    }
    else {
      log(index + ' not found in list of processes in forever. Starting new instance...');
      startRequest(done);
    }
  });
}
647469
function _fireResume()
        {
            exec(
                    function ()
                    {
                        window.console.log(JS_HANDLE
                                + ": fired resume event to native plugin");
                    },
                    _logError,
                    CDV_HANDLE,
                    CDV_HANDLE_ACTIONS.APP_RESUMED,
                    []
            );
        }
349839
function onButtonEvent(e) {
      var target = e.target;
      var confirmButton = domCache.confirmButton,
          cancelButton = domCache.cancelButton;
      var targetedConfirm = confirmButton && (confirmButton === target || confirmButton.contains(target));
      var targetedCancel = cancelButton && (cancelButton === target || cancelButton.contains(target));

      switch (e.type) {
        case 'click':
          // Clicked 'confirm'
          if (targetedConfirm && constructor.isVisible()) {
            _this.disableButtons();

            if (innerParams.input) {
              var inputValue = getInputValue();

              if (innerParams.inputValidator) {
                _this.disableInput();

                var validationPromise = Promise.resolve().then(function () {
                  return innerParams.inputValidator(inputValue, innerParams.extraParams);
                });

                if (innerParams.expectRejections) {
                  validationPromise.then(function () {
                    _this.enableButtons();

                    _this.enableInput();

                    confirm(inputValue);
                  }, function (validationMessage) {
                    _this.enableButtons();

                    _this.enableInput();

                    if (validationMessage) {
                      _this.showValidationMessage(validationMessage);
                    }
                  });
                } else {
                  validationPromise.then(function (validationMessage) {
                    _this.enableButtons();

                    _this.enableInput();

                    if (validationMessage) {
                      _this.showValidationMessage(validationMessage);
                    } else {
                      confirm(inputValue);
                    }
                  }, function (error$$1) {
                    return errorWith(error$$1);
                  });
                }
              } else {
                confirm(inputValue);
              }
            } else {
              confirm(true);
            } // Clicked 'cancel'

          } else if (targetedCancel && constructor.isVisible()) {
            _this.disableButtons();

            dismissWith(constructor.DismissReason.cancel);
          }

          break;

        default:
      }
    }
543415
void onMouseClicked(final MouseEvent event) {

        LOGGER.debug("Start button clicked => Call Comparison Service");

        // Clear out the table view
        model().object().pLastResult().clear();

        // Call service to populate it again
        model().returnData(ComparatorService.class,
                           ComparatorService.DO_COMPARE,
                           WBuilder.waveData(JRebirthWaves.PROGRESS_BAR, view().getProgressBar()),
                           WBuilder.waveData(JRebirthWaves.TASK_TITLE, view().getProgressTitle()),
                           WBuilder.waveData(JRebirthWaves.TASK_MESSAGE, view().getProgressMessage()),
                           WBuilder.waveData(ComparatorService.SOURCE, model().object().sourcePath()),
                           WBuilder.waveData(ComparatorService.TARGET, model().object().targetPath()));

    }
514717
@UiHandler("m_cancelButton")
    void cancelAction(ClickEvent event) {

        m_clipboard.reloadFavorites();
        m_buttonEditingPanel.setVisible(false);
        m_buttonUsePanel.setVisible(true);
    }
380320
def _enter_handler(self, event):
        """"""
        iid = self.current_iid
        if iid is None or iid == self.active:
            return
        self.update_state(iid, "hover")
946340
def start_clicker( button, waitTime= 9, user_input=nil)
      # get a handle if one exists
      hwnd = @browser.enabled_popup(waitTime)
      if (hwnd)  # yes there is a popup
        w = WinClicker.new
        if ( user_input )
          w.setTextValueForFileNameField( hwnd, "#{user_input}" )
        end
        # I put this in to see the text being input it is not necessary to work
        sleep 3
        # "OK" or whatever the name on the button is
        w.clickWindowsButton_hwnd( hwnd, "#{button}" )
        #
        # this is just cleanup
        w = nil
      end
    end
144657
def on_click(self, event):
        
        index = event["index"]
        button = event["button"]

        if index not in self._control_states.keys():
            if button == self.button_toggle:
                index = "toggle"
            elif button == self.button_stop:
                index = "stop"
            elif button == self.button_next:
                index = "next"
            elif button == self.button_previous:
                index = "previous"
            else:
                return
        elif button != 1:
            return

        try:
            control_state = self._control_states.get(index)
            if self._player and self._get_button_state(control_state):
                getattr(self._player, self._control_states[index]["action"])()
        except GError as err:
            self.py3.log(str(err).split(":", 1)[-1])
362162
@UiHandler("m_okButton")
    protected void onClickOk(ClickEvent e) {

        changeState(State.validationRunning);
        final String newName = getValue();
        CmsRpcAction<String> validate = new CmsRpcAction<String>() {

            @Override
            public void execute() {

                start(200, false);
                CmsCoreProvider.getVfsService().renameResource(m_structureId, newName, this);
            }

            @Override
            public void onFailure(Throwable t) {

                super.onFailure(t);
                changeState(State.validationUnknown);
            }

            @Override
            protected void onResponse(String result) {

                stop(false);
                if (result == null) {
                    close();
                    if (m_renameCallback != null) {
                        m_renameCallback.onSuccess(newName);
                    }
                } else {
                    changeState(State.validationFailed);
                    setValidationError(result);
                }
            }

        };
        validate.execute();

    }
609933
def restart
      invoke :stop, :all => input[:all], :apps => input[:apps]

      line unless quiet?

      input[:apps].each do |app|
        unless input[:command].nil?
          app.command = input[:command]
        end
        app.update!
      end

      invoke :start, :all => input[:all], :apps => input[:apps],
        :debug_mode => input[:debug_mode]
    end
23077
async def restart(request: web.Request) -> web.Response:
    
    async with request.app[RESTART_LOCK_NAME]:
        asyncio.get_event_loop().call_later(1, _do_restart)
    return web.json_response({'message': 'Restarting in 1s'},
                             status=200)