Java ConsoleView.attachToProcess方法代码示例

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
public void run() {
  FileDocumentManager.getInstance().saveAllDocuments();

  // Use user-provided console if exist. Create new otherwise
  ConsoleView view = (myUserProvidedConsole != null ? myUserProvidedConsole :  createConsole(myProject));
  view.attachToProcess(myProcess);
  if (myAfterCompletion != null) {
    myProcess.addProcessListener(new ProcessAdapter() {
      @Override
      public void processTerminated(ProcessEvent event) {
        SwingUtilities.invokeLater(myAfterCompletion);
      }
    });
  }
  myProcess.startNotify();
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
protected ConsoleView initConsoleUi() {
  ConsoleView consoleView = createConsoleView();
  consoleView.print(myCommandLine.getCommandLineString() + '\n', ConsoleViewContentType.USER_INPUT);
  consoleView.attachToProcess(myProcessHandler);

  JPanel panel = new JPanel(new BorderLayout());

  DefaultActionGroup toolbarActions = new DefaultActionGroup();
  ActionToolbar actionToolbar = ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, toolbarActions, false);
  panel.add(actionToolbar.getComponent(), BorderLayout.WEST);
  panel.add(consoleView.getComponent(), BorderLayout.CENTER);
  actionToolbar.setTargetComponent(panel);

  toolbarActions.addAll(consoleView.createConsoleActions());
  fillToolBarActions(toolbarActions);
  panel.updateUI();

  Executor defaultExecutor = DefaultRunExecutor.getRunExecutorInstance();
  final RunContentDescriptor contentDescriptor = new RunContentDescriptor(consoleView, myProcessHandler, panel, myTitle);
  showConsole(defaultExecutor, contentDescriptor);

  myProcessHandler.addProcessListener(new ConsoleListener(myProject, defaultExecutor, myProcessHandler));
  myProcessHandler.startNotify();
  return consoleView;
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
private void callProtractor() {
    try {
        Config config = Config.getInstance(project);

        if (config == null) {
            return;
        }

        GeneralCommandLine command = getProtractorRunCommand(config);
        Process p = command.createProcess();

        if (project != null) {
            ToolWindowManager manager = ToolWindowManager.getInstance(project);
            String id = "Gherkin Runner";
            TextConsoleBuilderFactory factory = TextConsoleBuilderFactory.getInstance();
            TextConsoleBuilder builder = factory.createBuilder(project);
            ConsoleView view = builder.getConsole();

            ColoredProcessHandler handler = new ColoredProcessHandler(p, command.getPreparedCommandLine());
            handler.startNotify();
            view.attachToProcess(handler);

            ToolWindow window = manager.getToolWindow(id);
            Icon cucumberIcon = IconLoader.findIcon("/resources/icons/cucumber.png");

            if (window == null) {
                window = manager.registerToolWindow(id, true, ToolWindowAnchor.BOTTOM);
                window.setIcon(cucumberIcon);
            }

            ContentFactory cf = window.getContentManager().getFactory();
            Content c = cf.createContent(view.getComponent(), "Run " + (window.getContentManager().getContentCount() + 1), true);

            window.getContentManager().addContent(c);
        }
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
public ExecutionResult execute(@NotNull final Executor executor,
                               @NotNull ProgramRunner runner) throws ExecutionException {
    log.info("execute " + executor.getActionName());

    final ProcessHandler processHandler = startProcess();
    final TextConsoleBuilder builder = getConsoleBuilder();
    final ConsoleView console = builder != null ? builder.getConsole() : null;
    if (console != null) {
        console.attachToProcess(processHandler);
    }

    VirtualFile file = LocalFileSystem.getInstance().findFileByPath(
            ((LuaRunConfigurationParams) getRunConfiguration()).getScriptName());

    final String text;
    if (file != null) {
        final Document document = FileDocumentManager.getInstance().getDocument(file);
        if (document != null) {
            text = document.getText();
        } else
            text = "";
    } else
        text = "";

    if (KahLuaInterpreterWindowFactory.INSTANCE != null) {
        KahLuaInterpreterWindowFactory.WINDOW
                                      .activate(KahLuaInterpreterWindowFactory.INSTANCE.getRunnableExecution(text),
                                              true);
    }

    return new KahluaExecutionResult(console, createActions(console, processHandler, executor));
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
@NotNull
@Override
public ExecutionConsole attachExecutionConsole(@NotNull ExternalSystemTask task,
                                               @NotNull Project project,
                                               @NotNull ExternalSystemRunConfiguration configuration,
                                               @NotNull Executor executor,
                                               @NotNull ExecutionEnvironment env,
                                               @NotNull ProcessHandler processHandler) throws ExecutionException {
  myProcessHandler = processHandler;
  ConsoleView executionConsole = new TextConsoleBuilderImpl(project).getConsole();
  executionConsole.attachToProcess(processHandler);
  return executionConsole;
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
@Override
@NotNull
public ExecutionResult execute(@NotNull final Executor executor, @NotNull final ProgramRunner runner) throws ExecutionException {
  final ProcessHandler processHandler = startProcess();
  final ConsoleView console = createConsole(executor);
  if (console != null) {
    console.attachToProcess(processHandler);
  }
  return new DefaultExecutionResult(console, processHandler, createActions(console, processHandler, executor));
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
@NotNull
protected ConsoleView createAndAttachConsole(Project project, ProcessHandler processHandler, Executor executor)
  throws ExecutionException {
  final ConsoleView consoleView = createConsoleBuilder(project).getConsole();
  consoleView.addMessageFilter(createUrlFilter(processHandler));

  addTracebackFilter(project, consoleView, processHandler);

  consoleView.attachToProcess(processHandler);
  return consoleView;
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
@NotNull
@Override
protected ConsoleView attachConsole(AndroidRunningState state, Executor executor) {
  Project project = getConfigurationModule().getProject();
  final TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(project);
  ConsoleView console = builder.getConsole();
  console.attachToProcess(state.getProcessHandler());
  return console;
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
@NotNull
@Override
public ConsoleView createAndAttach(
    @NotNull Disposable parent, @NotNull ProcessHandler handler, @NotNull Executor executor)
    throws ExecutionException {
  final TextConsoleBuilder builder =
      TextConsoleBuilderFactory.getInstance().createBuilder(project);
  ConsoleView console = builder.getConsole();
  console.attachToProcess(handler);
  return console;
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
@Override
public ConsoleView createAndAttach(Disposable parent, ProcessHandler handler, Executor executor)
    throws ExecutionException {
  switch (configState.getLaunchMethod()) {
    case BLAZE_TEST:
      ConsoleView console = createBlazeTestConsole(executor);
      console.attachToProcess(handler);
      return console;
    case NON_BLAZE:
    case MOBILE_INSTALL:
      return getStockConsoleProvider().createAndAttach(parent, handler, executor);
  }
  throw new AssertionError();
}
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
private static void processConsole(Project project, ProcessHandler processHandler) {
        ConsoleView consoleView = TextConsoleBuilderFactory.getInstance().createBuilder(project).getConsole();
        consoleView.clear();
        consoleView.attachToProcess(processHandler);
        processHandler.startNotify();

        ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(project);
        ToolWindow toolWindow;
        toolWindow = toolWindowManager.getToolWindow(TOOL_ID);

        // if already exist tool window then show it
        if (toolWindow != null) {
            toolWindow.show(null);// TODO add more tabs here?
            return;
        }

        toolWindow = toolWindowManager.registerToolWindow(TOOL_ID, true, ToolWindowAnchor.BOTTOM);
        toolWindow.setTitle("Android....");
        toolWindow.setStripeTitle("Android Console");
        toolWindow.setShowStripeButton(true);
        toolWindow.setIcon(PluginIcons.ICON_TOOL_WINDOW);

        JPanel panel = new JPanel((LayoutManager) new BorderLayout());
        panel.add((Component) consoleView.getComponent(), "Center");

        // Create toolbars
        DefaultActionGroup toolbarActions = new DefaultActionGroup();
        AnAction[]
                consoleActions = consoleView.createConsoleActions();// 必须在 consoleView.getComponent() 调用后组件真正初始化之后调用
        toolbarActions.addAll((AnAction[]) Arrays.copyOf(consoleActions, consoleActions.length));
        toolbarActions.add((AnAction) new StopProcessAction("Stop process", "Stop process", processHandler));
//        toolbarActions.add((AnAction) new CloseAction(defaultExecutor, runDescriptor, project));


        ActionToolbar toolbar = ActionManager.getInstance().createActionToolbar("unknown", (ActionGroup) toolbarActions, false);
        toolbar.setTargetComponent(consoleView.getComponent());
        panel.add((Component) toolbar.getComponent(), "West");

        ContentImpl consoleContent = new ContentImpl(panel, "Build", false);
        consoleContent.setManager(toolWindow.getContentManager());

        toolbarActions.add(new CloseTabAction(consoleContent));

//        addAdditionalConsoleEditorActions(consoleView, consoleContent);
//        consoleComponent.setActions();
        toolWindow.getContentManager().addContent(consoleContent);
        toolWindow.getContentManager().addContent(new ContentImpl(new JButton("Test"), "Build2", false));
        toolWindow.show(null);
    }
 

import com.intellij.execution.ui.ConsoleView; //导入方法依赖的package包/类
PythonScriptCommandLineState toNativeState(ExecutionEnvironment env) throws ExecutionException {
  File executable = env.getCopyableUserData(EXECUTABLE_KEY).get();
  if (executable == null || StringUtil.isEmptyOrSpaces(executable.getPath())) {
    throw new ExecutionException("No blaze output script found");
  }
  PythonRunConfiguration nativeConfig =
      (PythonRunConfiguration)
          PythonConfigurationType.getInstance()
              .getFactory()
              .createTemplateConfiguration(env.getProject());
  nativeConfig.setScriptName(executable.getPath());
  nativeConfig.setAddContentRoots(false);
  nativeConfig.setAddSourceRoots(false);
  nativeConfig.setWorkingDirectory(
      Strings.nullToEmpty(
          getRunfilesPath(executable, WorkspaceRoot.fromProjectSafe(env.getProject()))));

  Sdk sdk = PySdkUtils.getPythonSdk(env.getProject());
  if (sdk == null) {
    throw new ExecutionException("Can't find a Python SDK when debugging a python target.");
  }
  nativeConfig.setModule(null);
  nativeConfig.setSdkHome(sdk.getHomePath());

  BlazePyRunConfigState handlerState =
      configuration.getHandlerStateIfType(BlazePyRunConfigState.class);
  if (handlerState != null) {
    nativeConfig.setScriptParameters(Strings.emptyToNull(getScriptParams(handlerState)));

    EnvironmentVariablesData envState = handlerState.getEnvVarsState().getData();
    nativeConfig.setPassParentEnvs(envState.isPassParentEnvs());
    nativeConfig.setEnvs(envState.getEnvs());
  }
  return new PythonScriptCommandLineState(nativeConfig, env) {
    @Override
    public boolean isDebug() {
      return true;
    }

    @Override
    protected ConsoleView createAndAttachConsole(
        Project project, ProcessHandler processHandler, Executor executor)
        throws ExecutionException {
      ConsoleView consoleView = createConsoleBuilder(project, getSdk()).getConsole();
      consoleView.addMessageFilter(createUrlFilter(processHandler));

      consoleView.attachToProcess(processHandler);
      return consoleView;
    }

    @Override
    protected ProcessHandler doCreateProcess(GeneralCommandLine commandLine)
        throws ExecutionException {
      ProcessHandler handler = super.doCreateProcess(commandLine);
      if (handler instanceof KillableProcessHandler) {
        // SIGINT can cause the JVM to crash, when stopped at a breakpoint (IDEA-167432).
        ((KillableProcessHandler) handler).setShouldKillProcessSoftly(false);
      }
      return handler;
    }
  };
}