xdebugger/impl/com/intellij/xdebugger/impl/ui/DebuggerLogConsoleManagerBase.java

   1 package com.intellij.xdebugger.impl.ui;
   2
   3 import com.intellij.diagnostic.logging.AdditionalTabComponent;
   4 import com.intellij.diagnostic.logging.DebuggerLogConsoleManager;
   5 import com.intellij.diagnostic.logging.LogConsoleImpl;
   6 import com.intellij.diagnostic.logging.LogFilesManager;
   7 import com.intellij.execution.configurations.RunConfigurationBase;
   8 import com.intellij.execution.configurations.RunProfile;
   9 import com.intellij.execution.process.ProcessHandler;
  10 import com.intellij.execution.runners.ExecutionEnvironment;
  11 import com.intellij.execution.ui.RunContentDescriptor;
  12 import com.intellij.execution.ui.RunnerLayoutUi;
  13 import com.intellij.openapi.Disposable;
  14 import com.intellij.openapi.project.Project;
  15 import com.intellij.openapi.ui.ComponentWithActions;
  16 import com.intellij.openapi.util.Comparing;
  17 import com.intellij.openapi.util.Disposer;
  18 import com.intellij.openapi.util.IconLoader;
  19 import com.intellij.openapi.util.Ref;
  20 import com.intellij.ui.content.Content;
  21 import com.intellij.ui.content.ContentManagerAdapter;
  22 import com.intellij.ui.content.ContentManagerEvent;
  23 import com.intellij.ui.content.ContentManagerListener;
  24 import org.jetbrains.annotations.NonNls;
  25 import org.jetbrains.annotations.NotNull;
  26
  27 import javax.swing.*;
  28 import java.io.File;
  29 import java.util.HashMap;
  30 import java.util.Map;
  31
  32 /**
  33  * @author nik
  34  */
  35 public abstract class DebuggerLogConsoleManagerBase implements DebuggerLogConsoleManager, Disposable {
  36   private final Map<AdditionalTabComponent, Content> myAdditionalContent = new HashMap<AdditionalTabComponent, Content>();
  37   private final Map<AdditionalTabComponent, ContentManagerListener> myContentListeners =
  38     new HashMap<AdditionalTabComponent, ContentManagerListener>();
  39   private final Project myProject;
  40   private final LogFilesManager myManager;
  41   protected ExecutionEnvironment myEnvironment;
  42   private final Icon DEFAULT_TAB_COMPONENT_ICON = IconLoader.getIcon("/fileTypes/text.png");
  43
  44   public DebuggerLogConsoleManagerBase(Project project) {
  45     myProject = project;
  46     myManager = new LogFilesManager(project, this);
  47   }
  48
  49   public abstract RunContentDescriptor getRunContentDescriptor();
  50
  51   public abstract RunnerLayoutUi getUi();
  52
  53   protected void registerFileMatcher(final RunProfile runConfiguration) {
  54     if (runConfiguration instanceof RunConfigurationBase) {
  55       myManager.registerFileMatcher((RunConfigurationBase)runConfiguration);
  56     }
  57   }
  58
  59   protected void initLogConsoles(final RunProfile runConfiguration, final ProcessHandler processHandler) {
  60     if (runConfiguration instanceof RunConfigurationBase && ((RunConfigurationBase)runConfiguration).needAdditionalConsole()) {
  61       myManager.initLogConsoles((RunConfigurationBase)runConfiguration, processHandler);
  62     }
  63   }
  64
  65   // TODO[oleg]: talk to nick
  66   public void setEnvironment(@NotNull final ExecutionEnvironment env) {
  67     myEnvironment = env;
  68   }
  69
  70   public void addLogConsole(final String name, final String path, final long skippedContent, Icon icon) {
  71     final Ref<Content> content = new Ref<Content>();
  72
  73     final LogConsoleImpl log = new LogConsoleImpl(myProject, new File(path), skippedContent, name, false) {
  74       public boolean isActive() {
  75         final Content logContent = content.get();
  76         return logContent != null && logContent.isSelected();
  77       }
  78     };
  79     log.attachStopLogConsoleTrackingListener(getRunContentDescriptor().getProcessHandler());
  80     // Attach custom log handlers
  81     if (myEnvironment != null && myEnvironment.getRunProfile() instanceof RunConfigurationBase) {
  82       ((RunConfigurationBase)myEnvironment.getRunProfile()).customizeLogConsole(log);
  83     }
  84
  85     content.set(addLogComponent(log, icon));
  86     final ContentManagerAdapter l = new ContentManagerAdapter() {
  87       public void selectionChanged(final ContentManagerEvent event) {
  88         log.activate();
  89       }
  90     };
  91     myContentListeners.put(log, l);
  92     getUi().addListener(l, this);
  93   }
  94
  95   public void addLogConsole(String name, String path, long skippedContent) {
  96     addLogConsole(name, path, skippedContent, DEFAULT_TAB_COMPONENT_ICON);
  97   }
  98
  99   public void removeLogConsole(final String path) {
 100     LogConsoleImpl componentToRemove = null;
 101     for (AdditionalTabComponent tabComponent : myAdditionalContent.keySet()) {
 102       if (tabComponent instanceof LogConsoleImpl) {
 103         final LogConsoleImpl console = (LogConsoleImpl)tabComponent;
 104         if (Comparing.strEqual(console.getPath(), path)) {
 105           componentToRemove = console;
 106           break;
 107         }
 108       }
 109     }
 110     if (componentToRemove != null) {
 111       getUi().removeListener(myContentListeners.remove(componentToRemove));
 112       removeAdditionalTabComponent(componentToRemove);
 113     }
 114   }
 115
 116   public void addAdditionalTabComponent(final AdditionalTabComponent tabComponent, final String id) {
 117     addLogComponent(tabComponent);
 118   }
 119
 120   private void addLogComponent(AdditionalTabComponent component) {
 121     addLogComponent(component, DEFAULT_TAB_COMPONENT_ICON);
 122   }
 123
 124   private Content addLogComponent(final AdditionalTabComponent tabComponent, Icon icon) {
 125     @NonNls final String id = "Log-" + tabComponent.getTabTitle();
 126     final Content logContent = getUi().createContent(id, (ComponentWithActions)tabComponent, tabComponent.getTabTitle(), icon,
 127                                                      tabComponent.getPreferredFocusableComponent());
 128     logContent.setCloseable(false);
 129     logContent.setDescription(tabComponent.getTooltip());
 130     myAdditionalContent.put(tabComponent, logContent);
 131     getUi().addContent(logContent);
 132     Disposer.register(this, new Disposable() {
 133       public void dispose() {
 134         removeAdditionalTabComponent(tabComponent);
 135       }
 136     });
 137
 138     return logContent;
 139   }
 140
 141   public void removeAdditionalTabComponent(AdditionalTabComponent component) {
 142     component.dispose();
 143     final Content content = myAdditionalContent.remove(component);
 144     getUi().removeContent(content, true);
 145   }
 146
 147   protected Project getProject() {
 148     return myProject;
 149   }
 150
 151   public void dispose() {
 152     myManager.unregisterFileMatcher();
 153   }
 154 }