com.intellij.ui.content.Content Java Examples

@NotNull
static FlutterConsole create(@NotNull Project project, @Nullable Module module) {
  final TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(project);
  builder.setViewer(true);
  if (module != null) {
    builder.addFilter(new FlutterConsoleFilter(module));
  }
  final ConsoleView view = builder.getConsole();

  final SimpleToolWindowPanel panel = new SimpleToolWindowPanel(false, true);
  panel.setContent(view.getComponent());

  final String title = module != null ? "[" + module.getName() + "] Flutter" : "Flutter";
  final Content content = ContentFactory.SERVICE.getInstance().createContent(panel.getComponent(), title, true);
  Disposer.register(content, view);

  return new FlutterConsole(view, content, project, module);
}
 

@Override
public void contentAdded(ContentManagerEvent event) {
  final Content content = event.getContent();
  final ContentTabLabel tab;
  if (content instanceof TabbedContent) {
    tab = new TabbedContentTabLabel((TabbedContent)content, this);
  }
  else {
    tab = new ContentTabLabel(content, this);
  }
  myTabs.add(event.getIndex(), tab);
  myContent2Tabs.put(content, tab);
  if (content instanceof DnDTarget) {
    DnDTarget target = (DnDTarget)content;
    DnDSupport.createBuilder(tab).setDropHandler(target).setTargetChecker(target).setCleanUpOnLeaveCallback(target::cleanUpOnLeave).install();
  }
}
 

public static void addAdditionalConsoleEditorActions(final ConsoleView console, final Content consoleContent) {
    final DefaultActionGroup consoleActions = new DefaultActionGroup();
        for (AnAction action : console.createConsoleActions()) {
            consoleActions.add(action);
        }

    consoleContent.setActions(consoleActions, ActionPlaces.RUNNER_TOOLBAR, console.getComponent());
}
 

private void showTodo(TodoCheckinHandlerWorker worker) {
  String title = "For commit (" + DateFormatUtil.formatDateTime(System.currentTimeMillis()) + ")";
  ServiceManager.getService(myProject, TodoView.class).addCustomTodoView(new TodoTreeBuilderFactory() {
    @Override
    public TodoTreeBuilder createTreeBuilder(JTree tree, Project project) {
      return new CustomChangelistTodosTreeBuilder(tree, myProject, title, worker.inOneList());
    }
  }, title, new TodoPanelSettings(myConfiguration.myTodoPanelSettings));

  ApplicationManager.getApplication().invokeLater(() -> {
    ToolWindowManager manager = ToolWindowManager.getInstance(myProject);
    if (manager != null) {
      ToolWindow window = manager.getToolWindow("TODO");
      if (window != null) {
        window.show(() -> {
          ContentManager cm = window.getContentManager();
          Content[] contents = cm.getContents();
          if (contents.length > 0) {
            cm.setSelectedContent(contents[contents.length - 1], true);
          }
        });
      }
    }
  }, ModalityState.NON_MODAL, myProject.getDisposed());
}
 

public void setAutoTestEnabled(@Nonnull RunContentDescriptor descriptor, @Nonnull ExecutionEnvironment environment, boolean enabled) {
  Content content = descriptor.getAttachedContent();
  if (content != null) {
    if (enabled) {
      myEnabledRunProfiles.add(environment.getRunProfile());
      myWatcher.activate();
    }
    else {
      myEnabledRunProfiles.remove(environment.getRunProfile());
      if (!hasEnabledAutoTests()) {
        myWatcher.deactivate();
      }
      ProcessHandler processHandler = descriptor.getProcessHandler();
      if (processHandler != null) {
        clearRestarterListener(processHandler);
      }
    }
  }
}
 

private void updateTarget() {
    targetPanel.setLayout(new GridLayout(0, 1, 0, 0));
    if (IMWindowFactory.getDefault() == null || IMWindowFactory.getDefault().getProject() == null) {
        return;
    }
    ToolWindow window = ToolWindowManager.getInstance(IMWindowFactory.getDefault().getProject())
        .getToolWindow(IMWindowFactory.TOOL_WINDOW_ID);
    if (window != null) {
        Content[] contents = window.getContentManager().getContents();
        if (contents != null) {
            for (Content content : contents) {
                if (content.getComponent() != null && content.getComponent() instanceof IMPanel) {
                    IMPanel panel = (IMPanel)content.getComponent();
                    List<IMChatConsole> chats = panel.getConsoleList();
                    if (!chats.isEmpty()) {
                        targetPanel.add(new GroupPanel(content.getDisplayName(), chats));
                    }
                }
            }
        }
    }
}
 

@Nullable
@Override
public ConsoleView getConsoleView() {
    ORToolWindowProvider windowProvider = ORToolWindowProvider.getInstance(project);
    ToolWindow duneToolWindow = windowProvider.getDuneToolWindow();
    Content windowContent = duneToolWindow.getContentManager().getContent(0);
    if (windowContent == null) {
        return null;
    }
    SimpleToolWindowPanel component = (SimpleToolWindowPanel) windowContent.getComponent();
    JComponent panelComponent = component.getComponent();
    if (panelComponent == null) {
        return null;
    }
    return (ConsoleView) panelComponent.getComponent(0);
}
 

/**
 * Creats the tool window content
 * @param toolWindow
 */
public void createToolWindowContent(@NotNull ToolWindow toolWindow) {
    //Create runner UI layout
    RunnerLayoutUi.Factory factory = RunnerLayoutUi.Factory.getInstance(project);
    RunnerLayoutUi layoutUi = factory.create("", "", "session", project);

    // Adding actions
    DefaultActionGroup group = new DefaultActionGroup();
    layoutUi.getOptions().setLeftToolbar(group, ActionPlaces.UNKNOWN);

    Content console = layoutUi.createContent(EmbeddedLinuxJVMToolWindowFactory.ID, consoleView.getComponent(), "", null, null);
    AnAction[] consoleActions = consoleView.createConsoleActions();
    for (AnAction action : consoleActions) {
        if (!shouldIgnoreAction(action)) {
            group.add(action);
        }
    }
    layoutUi.addContent(console, 0, PlaceInGrid.right, false);

    JComponent layoutComponent = layoutUi.getComponent();
    myConsolePanel.add(layoutComponent, BorderLayout.CENTER);
    Content content = ContentFactory.SERVICE.getInstance().createContent(layoutComponent, null, true);
    toolWindow.getContentManager().addContent(content);
}
 

@Override
public void initFacet() {

    ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
            ToolWindowManager manager = ToolWindowManager.getInstance(MuleFacet.this.getModule().getProject());
            List<String> ids = Arrays.asList(manager.getToolWindowIds());

            if (manager.getToolWindow("Global Configs") == null && !ids.contains("Global Configs")) {

                try {
                    ToolWindow toolWindow = manager.registerToolWindow("Global Configs", true, ToolWindowAnchor.LEFT, false);
                    toolWindow.setIcon(MuleIcons.MuleIcon);

                    GlobalConfigsToolWindowPanel toolWindowPanel = new GlobalConfigsToolWindowPanel(MuleFacet.this.getModule().getProject());
                    ContentFactory contentFactory = ContentFactory.SERVICE.getInstance();
                    Content content = contentFactory.createContent(toolWindowPanel, "", true);
                    toolWindow.getContentManager().addContent(content);
                } catch (Exception e) {
                    logger.error("Unable to initialize toolWindow: ", e);
                }
            }
        }
    });
}
 

private Content getOrCreateConsoleContent(final ContentManager contentManager) {
  final String displayName = VcsBundle.message("vcs.console.toolwindow.display.name");
  Content content = contentManager.findContent(displayName);
  if (content == null) {
    releaseConsole();

    myConsole = TextConsoleBuilderFactory.getInstance().createBuilder(myProject).getConsole();

    JPanel panel = new JPanel(new BorderLayout());
    panel.add(myConsole.getComponent(), BorderLayout.CENTER);

    ActionToolbar toolbar = ActionManager.getInstance()
            .createActionToolbar("VcsManager", new DefaultActionGroup(myConsole.createConsoleActions()), false);
    panel.add(toolbar.getComponent(), BorderLayout.WEST);

    content = ContentFactory.getInstance().createContent(panel, displayName, true);
    content.setDisposer(myConsoleDisposer);
    contentManager.addContent(content);

    for (Pair<String, ConsoleViewContentType> pair : myPendingOutput) {
      printToConsole(pair.first, pair.second);
    }
    myPendingOutput.clear();
  }
  return content;
}
 

@Nullable
public static DocumentationComponent getActiveDocComponent(@Nonnull Project project) {
  DocumentationManager documentationManager = DocumentationManager.getInstance(project);
  DocumentationComponent component;
  JBPopup hint = documentationManager.getDocInfoHint();
  if (hint != null) {
    component = (DocumentationComponent)((AbstractPopup)hint).getComponent();
  }
  else if (documentationManager.hasActiveDockedDocWindow()) {
    ToolWindow toolWindow = ToolWindowManager.getInstance(project).getToolWindow(ToolWindowId.DOCUMENTATION);
    Content selectedContent = toolWindow == null ? null : toolWindow.getContentManager().getSelectedContent();
    component = selectedContent == null ? null : (DocumentationComponent)selectedContent.getComponent();
  }
  else {
    component = EditorMouseHoverPopupManager.getInstance().getDocumentationComponent();
  }
  return component;
}
 

@NotNull
static FlutterConsole create(@NotNull Project project, @Nullable Module module) {
  final TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(project);
  builder.setViewer(true);
  if (module != null) {
    builder.addFilter(new FlutterConsoleFilter(module));
  }
  final ConsoleView view = builder.getConsole();

  final SimpleToolWindowPanel panel = new SimpleToolWindowPanel(false, true);
  panel.setContent(view.getComponent());

  final String title = module != null ? "[" + module.getName() + "] Flutter" : "Flutter";
  final Content content = ContentFactory.SERVICE.getInstance().createContent(panel.getComponent(), title, true);
  Disposer.register(content, view);

  return new FlutterConsole(view, content, project, module);
}
 

/**
 * Turn off debug-only views (variables and frames).
 */
private static void suppressDebugViews(@Nullable RunnerLayoutUi ui) {
  if (ui == null) {
    return;
  }

  for (Content c : ui.getContents()) {
    if (!Objects.equals(c.getTabName(), "Console")) {
      try {
        GuiUtils.runOrInvokeAndWait(() -> ui.removeContent(c, false /* dispose? */));
      }
      catch (InvocationTargetException | InterruptedException e) {
        FlutterUtils.warn(LOG, e);
      }
    }
  }
}
 

protected void removeContents(Content notToRemove, final String tabDisplayName) {
  MessageView messageView = MessageView.SERVICE.getInstance(myProject);
  Content[] contents = messageView.getContentManager().getContents();
  for (Content content : contents) {
    LOG.assertTrue(content != null);
    if (content.isPinned()) continue;
    if (tabDisplayName.equals(content.getDisplayName()) && content != notToRemove) {
      ErrorTreeView listErrorView = (ErrorTreeView)content.getComponent();
      if (listErrorView != null) {
        if (messageView.getContentManager().removeContent(content, true)) {
          content.release();
        }
      }
    }
  }
}
 

@Override
public void showSettings() {
  Content selectedContent = UsageViewContentManager.getInstance(myProject).getSelectedContent(true);
  JComponent component = selectedContent == null ? null : selectedContent.getComponent();
  FindInProjectManager findInProjectManager = FindInProjectManager.getInstance(myProject);
  findInProjectManager.findInProject(DataManager.getInstance().getDataContext(component), myFindModel);
}
 

void add(final Content content) {
  if (myContents.containsKey(content)) return;
  myContents.put(content, null);

  revalidateCell(() -> myTabs.addTab(createTabInfoFor(content)));

  updateSelection(myTabs.getComponent().getRootPane() != null);
}
 

public boolean addVcsTab(@NotNull @NonNls String title,
        @NotNull JComponent component,
        boolean showTab,
        boolean replaceExistingComponent) {
    if (component instanceof Disposable) {
        Disposer.register(this, (Disposable) component);
    }
    final ToolWindow toolW = getToolWindow();
    if (toolW == null) {
        // cannot do anything
        return false;
    }
    final ContentManager contentManager = getToolWindow().getContentManager();
    final Content existingContent = contentManager.findContent(title);
    if (existingContent != null) {
        if (!replaceExistingComponent) {
            contentManager.setSelectedContent(existingContent);
            return true;
        }
        else if (!existingContent.isPinned()) {
            contentManager.removeContent(existingContent, true);
            existingContent.release();
        }
    }

    final Content content = contentManager.getFactory().createContent(component, title, false);
    contentManager.addContent(content);
    if (showTab) {
        getToolWindow().activate(null, false);
    }

    return true;
}
 

@Override
public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {
    DWConsoleService consoleService = ServiceManager.getService(project, DWConsoleService.class);
    ConsoleView consoleView = consoleService.getConsoleView();
    Content content = toolWindow.getContentManager().getFactory().createContent(consoleView.getComponent(), "", true);
    toolWindow.getContentManager().addContent(content);
}
 

@Nullable
private static Content getToolWindowContent(@Nonnull AnActionEvent e) {
  // note to future readers: TW tab "pinned" icon is shown when content.getUserData(TW.SHOW_CONTENT_ICON) is true
  ToolWindow window = e.getData(PlatformDataKeys.TOOL_WINDOW);
  Content result = window != null ? window.getContentManager().getSelectedContent() : null;
  return result != null && result.isPinnable() ? result : null;
}
 

@Override
public void createToolWindowContent(@Nonnull Project project, @Nonnull ToolWindow toolWindow) {
  ContentManager contentManager = toolWindow.getContentManager();

  final ServersToolWindowContent serversContent = new ServersToolWindowContent(project);

  Content content = contentManager.getFactory().createContent(serversContent, null, false);
  content.setDisposer(serversContent);
  
  contentManager.addContent(content);
}
 

@Override
public void attract(final Content content, final RunnerLayoutUi ui) {
  if (!myWasAttracted) {
    myWasAttracted = true;
    ui.selectAndFocus(content, myRequestFocus, true, true);
  } else {
    ui.setBouncing(content, true);
  }
}
 

@Override
public void addContent(@Nonnull Content content, int order) {
  myContents.add(order, content);
  Disposer.register(this, content);
  ContentManagerEvent e = new ContentManagerEvent(this, content, myContents.indexOf(content), ContentManagerEvent.ContentOperation.add);
  myDispatcher.getMulticaster().contentAdded(e);
  if (mySelected == null) setSelectedContent(content);
}
 

public void actionPerformed(AnActionEvent e) {
  final Project project = e.getData(PlatformDataKeys.PROJECT);
  if (project == null) return;
  CrucibleManager.getInstance(project).completeReview(myReview.getPermaId());
  final ToolWindow toolWindow = ToolWindowManager.getInstance(project).getToolWindow(CrucibleBundle.message("crucible.toolwindow.id"));
  final ContentManager contentManager = toolWindow.getContentManager();
  final Content foundContent = contentManager.findContent("Details for " + myReview.getPermaId());
  contentManager.removeContent(foundContent, true);

  final Content dash = contentManager.findContent("Dashboard");
  if (dash.getComponent() instanceof CruciblePanel) {
    ((CruciblePanel)dash.getComponent()).getReviewModel().updateModel(CrucibleFilter.ToReview);
  }
}
 

private void createToolWindow(
    Project project, ToolWindowManager wm, BlazeProblemsViewPanel panel) {
  if (project.isDisposed()) {
    return;
  }
  ToolWindow toolWindow =
      wm.registerToolWindow(toolWindowId, false, ToolWindowAnchor.BOTTOM, project, true);
  Content content = ContentFactory.SERVICE.getInstance().createContent(panel, "", false);
  toolWindow.getContentManager().addContent(content);
  Disposer.register(project, () -> toolWindow.getContentManager().removeAllContents(true));
  updateIcon(panel);
}
 

public static boolean isEnabled(ViewContext context, Content[] content, String place) {
  int closeable = 0;
  for (Content c : context.getContentManager().getContents()) {
    if (c.isCloseable()) closeable ++;
  }
  return closeable > 1;
}
 

@Override
public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {
    logger.info("Creating tool window content for test results. " + "@TestResultPanelFactory");

    TestResultsPanel panel = new TestResultsPanel();
    ContentFactory cf = ContentFactory.SERVICE.getInstance();
    Content content = cf.createContent(panel, "", true);
    toolWindow.getContentManager().addContent(content);

    panels.add(panel);
}
 

private Content createWatchesContent(@Nonnull XDebugSessionImpl session) {
  myWatchesView = new XWatchesViewImpl(session, myWatchesInVariables);
  registerView(DebuggerContentInfo.WATCHES_CONTENT, myWatchesView);
  Content watchesContent =
          myUi.createContent(DebuggerContentInfo.WATCHES_CONTENT, myWatchesView.getPanel(), XDebuggerBundle.message("debugger.session.tab.watches.title"),
                             AllIcons.Debugger.Watches, null);
  watchesContent.setCloseable(false);
  return watchesContent;
}
 

@Override
@Nullable
public Object getData(@Nonnull @NonNls final Key<?> dataId) {
  if (ViewContext.CONTEXT_KEY == dataId) {
    return myViewContext;
  }
  else if (ViewContext.CONTENT_KEY == dataId) {
    List<Content> contents = getContents();
    return contents.toArray(new Content[contents.size()]);
  }
  return null;
}
 

@Override
public void contentRemoved(ContentManagerEvent event) {
  Content content = event.getContent();
  if (content instanceof TabbedContent) {
    content.removePropertyChangeListener(this);
  }
}
 

/**
 *   States of contents marked as "lightweight" won't be persisted
 */
public void setLightWeight(Content content) {
  if (myLightWeightIds == null) {
    myLightWeightIds = new HashSet<>();
  }
  myLightWeightIds.add(getOrCreateContentId(content));
}