platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowImpl.java

   1 package com.intellij.openapi.wm.impl;
   2
   3 import com.intellij.ide.impl.ContentManagerWatcher;
   4 import com.intellij.openapi.actionSystem.ActionGroup;
   5 import com.intellij.openapi.application.ApplicationManager;
   6 import com.intellij.openapi.components.ServiceManager;
   7 import com.intellij.openapi.util.ActionCallback;
   8 import com.intellij.openapi.wm.ToolWindowAnchor;
   9 import com.intellij.openapi.wm.ToolWindowFactory;
  10 import com.intellij.openapi.wm.ToolWindowType;
  11 import com.intellij.openapi.wm.ex.ToolWindowEx;
  12 import com.intellij.openapi.wm.impl.content.ToolWindowContentUi;
  13 import com.intellij.ui.content.Content;
  14 import com.intellij.ui.content.ContentFactory;
  15 import com.intellij.ui.content.ContentManager;
  16 import com.intellij.ui.content.impl.ContentImpl;
  17 import org.jetbrains.annotations.Nullable;
  18
  19 import javax.swing.*;
  20 import java.awt.*;
  21 import java.beans.PropertyChangeListener;
  22 import java.beans.PropertyChangeSupport;
  23
  24 /**
  25  * @author Anton Katilin
  26  * @author Vladimir Kondratyev
  27  */
  28 public final class ToolWindowImpl implements ToolWindowEx {
  29   private final PropertyChangeSupport myChangeSupport;
  30   private final ToolWindowManagerImpl myToolWindowManager;
  31   private final String myId;
  32   private final JComponent myComponent;
  33   private boolean myAvailable;
  34   private final ContentManager myContentManager;
  35   private Icon myIcon = null;
  36
  37   private static final Content EMPTY_CONTENT = new ContentImpl(new JLabel(), "", false);
  38   private final ToolWindowContentUi myContentUI;
  39
  40   private InternalDecorator myDecorator;
  41
  42   private boolean myHideOnEmptyContent = false;
  43   private boolean myPlaceholderMode;
  44   private ToolWindowFactory myContentFactory;
  45
  46   private ActionCallback myActivation = new ActionCallback.Done();
  47
  48   ToolWindowImpl(final ToolWindowManagerImpl toolWindowManager, final String id, boolean canCloseContent, @Nullable final JComponent component) {
  49     myToolWindowManager = toolWindowManager;
  50     myChangeSupport = new PropertyChangeSupport(this);
  51     myId = id;
  52     myAvailable = true;
  53
  54     final ContentFactory contentFactory = ServiceManager.getService(ContentFactory.class);
  55     myContentUI = new ToolWindowContentUi(this);
  56     myContentManager =
  57       contentFactory.createContentManager(myContentUI, canCloseContent, toolWindowManager.getProject());
  58
  59     if (component != null) {
  60       final Content content = contentFactory.createContent(component, "", false);
  61       myContentManager.addContent(content);
  62       myContentManager.setSelectedContent(content, false);
  63     }
  64
  65     myComponent = myContentManager.getComponent();
  66   }
  67
  68   public final void addPropertyChangeListener(final PropertyChangeListener l) {
  69     myChangeSupport.addPropertyChangeListener(l);
  70   }
  71
  72   public final void removePropertyChangeListener(final PropertyChangeListener l) {
  73     myChangeSupport.removePropertyChangeListener(l);
  74   }
  75
  76   public final void activate(final Runnable runnable) {
  77     activate(runnable, true);
  78   }
  79
  80   public void activate(@Nullable final Runnable runnable, final boolean autoFocusContents) {
  81     activate(runnable, autoFocusContents, true);
  82   }
  83
  84   public void activate(@Nullable final Runnable runnable, boolean autoFocusContents, boolean forced) {
  85     ApplicationManager.getApplication().assertIsDispatchThread();
  86     myToolWindowManager.activateToolWindow(myId, forced, autoFocusContents);
  87
  88     if (runnable != null) {
  89       getActivation().doWhenDone(new Runnable() {
  90         public void run() {
  91           myToolWindowManager.invokeLater(runnable);
  92         }
  93       });
  94     }
  95   }
  96
  97   public final boolean isActive() {
  98     ApplicationManager.getApplication().assertIsDispatchThread();
  99     return myToolWindowManager.isToolWindowActive(myId);
 100   }
 101
 102   public final void show(final Runnable runnable) {
 103     ApplicationManager.getApplication().assertIsDispatchThread();
 104     myToolWindowManager.showToolWindow(myId);
 105     if (runnable != null) {
 106       getActivation().doWhenDone(new Runnable() {
 107         public void run() {
 108           myToolWindowManager.invokeLater(runnable);
 109         }
 110       });
 111     }
 112   }
 113
 114   public final void hide(final Runnable runnable) {
 115     ApplicationManager.getApplication().assertIsDispatchThread();
 116     myToolWindowManager.hideToolWindow(myId, false);
 117     if (runnable != null) {
 118       myToolWindowManager.invokeLater(runnable);
 119     }
 120   }
 121
 122   public final boolean isVisible() {
 123     ApplicationManager.getApplication().assertIsDispatchThread();
 124     return myToolWindowManager.isToolWindowVisible(myId);
 125   }
 126
 127   public final ToolWindowAnchor getAnchor() {
 128     ApplicationManager.getApplication().assertIsDispatchThread();
 129     return myToolWindowManager.getToolWindowAnchor(myId);
 130   }
 131
 132   public final void setAnchor(final ToolWindowAnchor anchor, final Runnable runnable) {
 133     ApplicationManager.getApplication().assertIsDispatchThread();
 134     myToolWindowManager.setToolWindowAnchor(myId, anchor);
 135     if (runnable != null) {
 136       myToolWindowManager.invokeLater(runnable);
 137     }
 138   }
 139
 140   public boolean isSplitMode() {
 141     ApplicationManager.getApplication().assertIsDispatchThread();
 142     return myToolWindowManager.isSplitMode(myId);
 143   }
 144
 145   public void setSplitMode(final boolean isSideTool, @Nullable final Runnable runnable) {
 146     ApplicationManager.getApplication().assertIsDispatchThread();
 147     myToolWindowManager.setSideTool(myId, isSideTool);
 148     if (runnable != null) {
 149       myToolWindowManager.invokeLater(runnable);
 150     }
 151   }
 152
 153   public final void setAutoHide(final boolean state) {
 154     ApplicationManager.getApplication().assertIsDispatchThread();
 155     myToolWindowManager.setToolWindowAutoHide(myId, state);
 156   }
 157
 158   public final boolean isAutoHide() {
 159     ApplicationManager.getApplication().assertIsDispatchThread();
 160     return myToolWindowManager.isToolWindowAutoHide(myId);
 161   }
 162
 163   public final boolean isFloating() {
 164     ApplicationManager.getApplication().assertIsDispatchThread();
 165     return myToolWindowManager.isToolWindowFloating(myId);
 166   }
 167
 168   public final ToolWindowType getType() {
 169     ApplicationManager.getApplication().assertIsDispatchThread();
 170     return myToolWindowManager.getToolWindowType(myId);
 171   }
 172
 173   public final void setType(final ToolWindowType type, final Runnable runnable) {
 174     ApplicationManager.getApplication().assertIsDispatchThread();
 175     myToolWindowManager.setToolWindowType(myId, type);
 176     if (runnable != null) {
 177       myToolWindowManager.invokeLater(runnable);
 178     }
 179   }
 180
 181   public final ToolWindowType getInternalType() {
 182     ApplicationManager.getApplication().assertIsDispatchThread();
 183     return myToolWindowManager.getToolWindowInternalType(myId);
 184   }
 185
 186   public final void setAvailable(final boolean available, final Runnable runnable) {
 187     ApplicationManager.getApplication().assertIsDispatchThread();
 188     final Boolean oldAvailable = myAvailable ? Boolean.TRUE : Boolean.FALSE;
 189     myAvailable = available;
 190     myChangeSupport.firePropertyChange(PROP_AVAILABLE, oldAvailable, myAvailable ? Boolean.TRUE : Boolean.FALSE);
 191     if (runnable != null) {
 192       myToolWindowManager.invokeLater(runnable);
 193     }
 194   }
 195
 196   public void installWatcher(ContentManager contentManager) {
 197     new ContentManagerWatcher(this, contentManager);
 198   }
 199
 200   /**
 201    * @return <code>true</code> if the component passed into constructor is not instance of
 202    *         <code>ContentManager</code> class. Otherwise it delegates the functionality to the
 203    *         passed content manager.
 204    */
 205   public final boolean isAvailable() {
 206     ApplicationManager.getApplication().assertIsDispatchThread();
 207     return myAvailable && myComponent != null;
 208   }
 209
 210   public final JComponent getComponent() {
 211     return myComponent;
 212   }
 213
 214   public ContentManager getContentManager() {
 215     return myContentManager;
 216   }
 217
 218   public ToolWindowContentUi getContentUI() {
 219     return myContentUI;
 220   }
 221
 222   public final Icon getIcon() {
 223     ApplicationManager.getApplication().assertIsDispatchThread();
 224     return myIcon;
 225     //return getSelectedContent().getIcon();
 226   }
 227
 228   public final String getId() {
 229     return myId;
 230   }
 231
 232   public final String getTitle() {
 233     ApplicationManager.getApplication().assertIsDispatchThread();
 234     return getSelectedContent().getDisplayName();
 235   }
 236
 237   public final void setIcon(final Icon icon) {
 238     ApplicationManager.getApplication().assertIsDispatchThread();
 239     final Icon oldIcon = getIcon();
 240     getSelectedContent().setIcon(icon);
 241     myIcon = icon;
 242     myChangeSupport.firePropertyChange(PROP_ICON, oldIcon, icon);
 243   }
 244
 245   public final void setTitle(final String title) {
 246     ApplicationManager.getApplication().assertIsDispatchThread();
 247     final String oldTitle = getTitle();
 248     getSelectedContent().setDisplayName(title);
 249     myChangeSupport.firePropertyChange(PROP_TITLE, oldTitle, title);
 250   }
 251
 252   private Content getSelectedContent() {
 253     final Content selected = getContentManager().getSelectedContent();
 254     return selected != null ? selected : EMPTY_CONTENT;
 255   }
 256
 257   public void setDecorator(final InternalDecorator decorator) {
 258     myDecorator = decorator;
 259   }
 260
 261   public void fireActivated() {
 262     if (myDecorator != null) {
 263       myDecorator.fireActivated();
 264     }
 265   }
 266
 267   public void fireHidden() {
 268     if (myDecorator != null) {
 269       myDecorator.fireHidden();
 270     }
 271   }
 272
 273   public void fireHiddenSide() {
 274     if (myDecorator != null) {
 275       myDecorator.fireHiddenSide();
 276     }
 277   }
 278
 279
 280   public ToolWindowManagerImpl getToolWindowManager() {
 281     return myToolWindowManager;
 282   }
 283
 284   @Nullable
 285   public ActionGroup getPopupGroup() {
 286     return myDecorator != null ? myDecorator.createPopupGroup() : null;
 287   }
 288
 289   public void setDefaultState(@Nullable final ToolWindowAnchor anchor, @Nullable final ToolWindowType type, @Nullable final Rectangle floatingBounds) {
 290     myToolWindowManager.setDefaultState(this, anchor, type, floatingBounds);
 291   }
 292
 293   public void setToHideOnEmptyContent(final boolean hideOnEmpty) {
 294     myHideOnEmptyContent = hideOnEmpty;
 295   }
 296
 297   public boolean isToHideOnEmptyContent() {
 298     return myHideOnEmptyContent;
 299   }
 300
 301   public boolean isDisposed() {
 302     return myContentManager.isDisposed();
 303   }
 304
 305   public boolean isPlaceholderMode() {
 306     return myPlaceholderMode;
 307   }
 308
 309   public void setPlaceholderMode(final boolean placeholderMode) {
 310     myPlaceholderMode = placeholderMode;
 311   }
 312
 313   public ActionCallback getActivation() {
 314     return myActivation;
 315   }
 316
 317   public ActionCallback setActivation(ActionCallback activation) {
 318     if (myActivation != null && !myActivation.isProcessed() && !myActivation.equals(activation)) {
 319       myActivation.setRejected();
 320     }
 321
 322     myActivation = activation;
 323     return myActivation;
 324   }
 325
 326   public void setContentFactory(ToolWindowFactory contentFactory) {
 327     myContentFactory = contentFactory;
 328   }
 329
 330   public void ensureContentInitialized() {
 331     if (myContentFactory != null) {
 332       getContentManager().removeAllContents(false);
 333       myContentFactory.createToolWindowContent(myToolWindowManager.getProject(), this);
 334       myContentFactory = null;
 335     }
 336   }
 337 }