StartEditor Method.
760564
public ScreenComponent startEditor(Field fldProperties, boolean bAllowAppending, Map<String,Object> mapKeyDescriptions)
    {
        this.setPropertiesField(fldProperties);
        BaseApplication application = ((BaseApplication)((PropertiesField)fldProperties).getRecord().getRecordOwner().getTask().getApplication());
        BasePanel screenParent = Screen.makeWindow(application);
        GridScreen screen = (GridScreen)this.makeScreen(null, screenParent, ScreenConstants.DISPLAY_MODE, mapKeyDescriptions);
        screen.setAppending(bAllowAppending);
        
        ((PropertiesField)fldProperties).getRecord().addDependentScreen(screen);
        
        return screen;
    }
492611
def start(self):
        """"""
        error, output = None, None
        try:
            time.sleep(0.1)
            output = self.method(*self.args, **self.kwargs)
        except Exception as err:
            logger.debug(str((self.method.__module__, self.method.__name__,
                              err)))
            error = str(err)
            error = error.replace('(', '')
            error = error.replace(')', '')
#            try:
#                error = err[0]
#            except Exception:
#                try:
#                    error = err.message
#                except Exception as err2:
#                    error = ''

        self.sig_finished.emit(self, output, str(error))
        self._is_finished = True
236208
public void start() {

        ClassDoc[] classDocs = mRootDoc.getClasses();

        for (int i = 0; i < classDocs.length; i++) {

            ClassDoc classDoc = classDocs[i];
            if (!accept(classDoc)) {
                continue;
            }

            try {
                generateBeanInfo(classDoc);
            }
            catch (RuntimeException e) {
                throw e;
            }
            catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e.toString());
            }
        }
    }
207750
public function on_start()
    {
        $this->registerServiceProvider();
        $this->registerParsers();
        $this->app->make('director')->addSubscriber($this->app->make(EventSubscriber::class));
        if ($this->app->isRunThroughCommandLineInterface()) {
            $this->registerCLICommands();
        } else {
            $this->registerAssets();
            $this->registerRoutes();
        }
    }
717246
@Override
    public void startOfProcess() {
        String previousBaseIndent = baseIndent.substring(INDENT_LENGTH);
        builder.append(previousBaseIndent).append("HierarchyWrapper{\n");
        processFirstOtherContent = true;
    }
192580
public void startMonitor() {
        logger.info("Starting Directory Update Monitor");
        try {
            monitor.start();
        } catch (IllegalStateException e) {
            logger.info("File alteration monitor is already started: " + e.getMessage());
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }
1102916
public void setStart(final double START) {
        if (null == start) {
            _start = START;
            fireSectionEvent(UPDATE_EVENT);
        } else {
            start.set(START);
        }
    }
1033900
public void startUp() {
        sendConsoleMessage(Level.INFO, getLanguageManager().getString("loading_account_manager"));
        accountManager = new AccountManager();
        //addMetricsGraph("Multiworld", getConfigurationManager().isMultiWorld());
        startMetrics();
        sendConsoleMessage(Level.INFO, getLanguageManager().getString("account_manager_loaded"));
        eventManager = new EventManager();
        initializeWorldGroup();
    }
1048952
public void start() {
    input.messageHandler(new Handler<Object>() {
      @Override
      public void handle(Object message) {
        output.send(message);
        pumped++;
      }
    });
  }
813456
public void start()
  {
    if (! getLifecycle().toStarting()) {
      startListeners();
      return;
    }
    
    //sendAddLoaderEvent();

    //bind();
    
    try {
      make();
    } catch (Exception e) {
      log().log(Level.WARNING, e.toString(), e);
      e.printStackTrace();
    }

    startListeners();

    getLifecycle().toActive();
    
    if (isAdminEnable()) {
      Thread thread = Thread.currentThread();
      ClassLoader loader = thread.getContextClassLoader();
      
      try {
        thread.setContextClassLoader(this);
      
        //_admin = new EnvironmentAdmin(this);
        //_admin.register();
      } finally {
        thread.setContextClassLoader(loader);
      }
    }
  }
787714
def _start(self):
        """"""
        if len(self._queue) == 1:
            thread = self._queue.popleft()
            thread.start()
            self._timer.start()
1201467
public void start()
    {
        pen.start();
        try
        {
            cache.start();
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            Throwables.propagate(e);
        }
    }
510010
function (editor) {
        var self = this, editors = self.editors;

        // Add named and index editor instance
        editors[editor.id] = editor;
        editors.push(editor);

        toggleGlobalEvents(editors, true);

        // Doesn't call setActive method since we don't want
        // to fire a bunch of activate/deactivate calls while initializing
        self.activeEditor = editor;

        self.fire('AddEditor', { editor: editor });

        if (!beforeUnloadDelegate) {
          beforeUnloadDelegate = function () {
            self.fire('BeforeUnload');
          };

          DOM.bind(window, 'beforeunload', beforeUnloadDelegate);
        }

        return editor;
      }
201398
def start_output (self):
        """"""
        super(TextLogger, self).start_output()
        if self.has_part('intro'):
            self.write_intro()
        self.flush()
1132221
def _launch_editor(starting_text=''):
    ""
    # TODO: What is a reasonable default for windows? Does this approach even
    # make sense on windows?
    editor = os.environ.get('EDITOR', 'vim')

    with tempfile.TemporaryDirectory() as dirname:
        filename = pathlib.Path(dirname) / 'metadata.yml'
        with filename.open(mode='wt') as handle:
            handle.write(starting_text)
        subprocess.call([editor, filename])

        with filename.open(mode='rt') as handle:
            text = handle.read()
    return text
194758
def OnGridEditorCreated(self, event):
        """"""

        editor = event.GetControl()
        editor.Bind(wx.EVT_KILL_FOCUS, self.OnGridEditorClosed)

        event.Skip()
508269
private void start()
    {
    try
      {
      // Initialize filter.
      initializeFilter( getFilterInput(), getFilterOutput());

      // Start filter thread.
      failure_ = null;
      thread_ = new Thread( this, String.valueOf( this));
      thread_.start();
      }
    catch( Exception e)
      {
      throw new RuntimeException( "Can't start filtering", e);
      } 
    }