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

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