platform/platform-impl/src/com/intellij/ui/TabbedPaneWrapper.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.ui;
  17
  18 import com.intellij.openapi.Disposable;
  19 import com.intellij.openapi.actionSystem.DataProvider;
  20 import com.intellij.openapi.actionSystem.IdeActions;
  21 import com.intellij.openapi.application.ex.ApplicationEx;
  22 import com.intellij.openapi.application.ex.ApplicationManagerEx;
  23 import com.intellij.openapi.project.Project;
  24 import com.intellij.openapi.wm.ex.IdeFocusTraversalPolicy;
  25 import com.intellij.ui.tabs.JBTabs;
  26 import com.intellij.util.IJSwingUtilities;
  27 import org.jetbrains.annotations.NotNull;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import javax.swing.*;
  31 import javax.swing.event.ChangeListener;
  32 import java.awt.*;
  33 import java.awt.event.MouseListener;
  34
  35 /**
  36  * @author Anton Katilin
  37  * @author Vladimir Kondratyev
  38  */
  39 public class TabbedPaneWrapper  {
  40   private static final PrevNextActionsDescriptor DEFAULT_SHORTCUTS = new PrevNextActionsDescriptor(IdeActions.ACTION_NEXT_TAB, IdeActions.ACTION_PREVIOUS_TAB);
  41   protected TabbedPane myTabbedPane;
  42   protected JComponent myTabbedPaneHolder;
  43
  44   private TabFactory myFactory;
  45
  46   protected TabbedPaneWrapper(boolean construct) {
  47     if (construct) {
  48       init(SwingConstants.TOP, DEFAULT_SHORTCUTS, new JTabbedPaneFactory(this));
  49     }
  50   }
  51
  52   public TabbedPaneWrapper(@NotNull Disposable parentDisposable) {
  53     this(SwingConstants.TOP, DEFAULT_SHORTCUTS, parentDisposable);
  54   }
  55
  56   /**
  57    * Creates tabbed pane wrapper with specified tab placement
  58    *
  59    * @param tabPlacement tab placement. It one of the <code>SwingConstants.TOP</code>,
  60    * <code>SwingConstants.LEFT</code>, <code>SwingConstants.BOTTOM</code> or
  61    * <code>SwingConstants.RIGHT</code>.
  62    */
  63   public TabbedPaneWrapper(int tabPlacement, PrevNextActionsDescriptor installKeyboardNavigation, @NotNull Disposable parentDisposable) {
  64     final TabFactory factory;
  65     if (SwingConstants.BOTTOM == tabPlacement || SwingConstants.TOP == tabPlacement) {
  66       factory = new JBTabsFactory(this, null, parentDisposable);
  67     } else {
  68       factory = new JTabbedPaneFactory(this);
  69     }
  70
  71     init(tabPlacement, installKeyboardNavigation, factory);
  72   }
  73
  74   void init(int tabPlacement, PrevNextActionsDescriptor installKeyboardNavigation, TabFactory tabbedPaneFactory) {
  75     myFactory = tabbedPaneFactory;
  76
  77     myTabbedPane = createTabbedPane(tabPlacement);
  78     myTabbedPane.putClientProperty(TabbedPaneWrapper.class, myTabbedPane);
  79     myTabbedPane.setKeyboardNavigation(installKeyboardNavigation);
  80
  81     myTabbedPaneHolder = createTabbedPaneHolder();
  82     myTabbedPaneHolder.add(myTabbedPane.getComponent(), BorderLayout.CENTER);
  83     myTabbedPaneHolder.setFocusCycleRoot(true);
  84     myTabbedPaneHolder.setFocusTraversalPolicy(new _MyFocusTraversalPolicy());
  85
  86     assertIsDispatchThread();
  87   }
  88
  89   public boolean isDisposed() {
  90     return myTabbedPane != null && myTabbedPane.isDisposed();
  91   }
  92
  93   private void assertIsDispatchThread() {
  94     final ApplicationEx application = ApplicationManagerEx.getApplicationEx();
  95     if (application != null){
  96       application.assertIsDispatchThread(myTabbedPane.getComponent());
  97     }
  98   }
  99
 100   public final void addChangeListener(final ChangeListener listener){
 101     assertIsDispatchThread();
 102     myTabbedPane.addChangeListener(listener);
 103   }
 104
 105   public final void removeChangeListener(final ChangeListener listener){
 106     assertIsDispatchThread();
 107     myTabbedPane.removeChangeListener(listener);
 108   }
 109
 110   protected TabbedPaneHolder createTabbedPaneHolder() {
 111     return myFactory.createTabbedPaneHolder();
 112   }
 113
 114   public final JComponent getComponent() {
 115     assertIsDispatchThread();
 116     return myTabbedPaneHolder;
 117   }
 118
 119   /**
 120    * @see javax.swing.JTabbedPane#addTab(java.lang.String, javax.swing.Icon, java.awt.Component, java.lang.String)
 121    */
 122   public final synchronized void addTab(final String title, final Icon icon, final JComponent component, final String tip) {
 123     insertTab(title, icon, component, tip, myTabbedPane.getTabCount());
 124   }
 125
 126   public final synchronized void addTab(final String title, final JComponent component) {
 127     insertTab(title, null, component, null, myTabbedPane.getTabCount());
 128   }
 129
 130   public synchronized void insertTab(final String title, final Icon icon, final JComponent component, final String tip, final int index) {
 131     myTabbedPane.insertTab(title, icon, createTabWrapper(component), tip, index);
 132   }
 133
 134   protected TabWrapper createTabWrapper(JComponent component) {
 135     return myFactory.createTabWrapper(component);
 136   }
 137
 138   protected TabbedPane createTabbedPane(final int tabPlacement) {
 139     return myFactory.createTabbedPane(tabPlacement);
 140   }
 141
 142   /**
 143    * @see javax.swing.JTabbedPane#setTabPlacement
 144    */
 145   public final void setTabPlacement(final int tabPlacement) {
 146     assertIsDispatchThread();
 147     myTabbedPane.setTabPlacement(tabPlacement);
 148   }
 149
 150   public final void addMouseListener(final MouseListener listener) {
 151     assertIsDispatchThread();
 152     myTabbedPane.addMouseListener(listener);
 153   }
 154
 155   public final synchronized int getSelectedIndex() {
 156     return myTabbedPane.getSelectedIndex();
 157   }
 158
 159   /**
 160    * @see javax.swing.JTabbedPane#getSelectedComponent()
 161    */
 162   public final synchronized JComponent getSelectedComponent() {
 163     // Workaround for JDK 6 bug
 164     final TabWrapper tabWrapper = myTabbedPane.getTabCount() > 0 ? (TabWrapper)myTabbedPane.getSelectedComponent():null;
 165     return tabWrapper != null ? tabWrapper.getComponent() : null;
 166   }
 167
 168   public final void setSelectedIndex(final int index) {
 169     setSelectedIndex(index, true);
 170   }
 171
 172   public final void setSelectedIndex(final int index, boolean requestFocus) {
 173     assertIsDispatchThread();
 174
 175     final boolean hadFocus = IJSwingUtilities.hasFocus2(myTabbedPaneHolder);
 176     myTabbedPane.setSelectedIndex(index);
 177     if (hadFocus && requestFocus) {
 178       myTabbedPaneHolder.requestFocus();
 179     }
 180   }
 181
 182   public final void setSelectedComponent(final JComponent component){
 183     assertIsDispatchThread();
 184
 185     final int index=indexOfComponent(component);
 186     if(index==-1){
 187       throw new IllegalArgumentException("component not found in tabbed pane wrapper");
 188     }
 189     setSelectedIndex(index);
 190   }
 191
 192   public final synchronized void removeTabAt(final int index) {
 193     assertIsDispatchThread();
 194
 195     final boolean hadFocus = IJSwingUtilities.hasFocus2(myTabbedPaneHolder);
 196     final TabWrapper wrapper = getWrapperAt(index);
 197     try {
 198       myTabbedPane.removeTabAt(index);
 199       if (myTabbedPane.getTabCount() == 0) {
 200         // to clear BasicTabbedPaneUI.visibleComponent field
 201         myTabbedPane.revalidate();
 202       }
 203       if (hadFocus) {
 204         myTabbedPaneHolder.requestFocus();
 205       }
 206     }
 207     finally {
 208       wrapper.dispose();
 209     }
 210   }
 211
 212   public final synchronized int getTabCount() {
 213     return myTabbedPane.getTabCount();
 214   }
 215
 216   public final Color getForegroundAt(final int index){
 217     assertIsDispatchThread();
 218     return myTabbedPane.getForegroundAt(index);
 219   }
 220
 221   /**
 222    * @see javax.swing.JTabbedPane#setForegroundAt(int, java.awt.Color)
 223    */
 224   public final void setForegroundAt(final int index,final Color color){
 225     assertIsDispatchThread();
 226     myTabbedPane.setForegroundAt(index,color);
 227   }
 228
 229   /**
 230    * @see javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)
 231    */
 232   public final synchronized JComponent getComponentAt(final int i) {
 233     return getWrapperAt(i).getComponent();
 234   }
 235
 236   private TabWrapper getWrapperAt(final int i) {
 237     return (TabWrapper)myTabbedPane.getComponentAt(i);
 238   }
 239
 240   public final void setTitleAt(final int index, final String title) {
 241     assertIsDispatchThread();
 242     myTabbedPane.setTitleAt(index, title);
 243   }
 244
 245   public final void setToolTipTextAt(final int index, final String toolTipText) {
 246     assertIsDispatchThread();
 247     myTabbedPane.setToolTipTextAt(index, toolTipText);
 248   }
 249
 250   /**
 251    * @see javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)
 252    */
 253   public final synchronized void setComponentAt(final int index, final JComponent component) {
 254     assertIsDispatchThread();
 255     myTabbedPane.setComponentAt(index, createTabWrapper(component));
 256   }
 257
 258   /**
 259    * @see javax.swing.JTabbedPane#setIconAt(int, javax.swing.Icon)
 260    */
 261   public final void setIconAt(final int index, final Icon icon) {
 262     assertIsDispatchThread();
 263     myTabbedPane.setIconAt(index, icon);
 264   }
 265
 266   public final void setEnabledAt(final int index, final boolean enabled) {
 267     assertIsDispatchThread();
 268     myTabbedPane.setEnabledAt(index, enabled);
 269   }
 270
 271   /**
 272    * @see javax.swing.JTabbedPane#indexOfComponent(java.awt.Component)
 273    */
 274   public final synchronized int indexOfComponent(final JComponent component) {
 275     for (int i=0; i < myTabbedPane.getTabCount(); i++) {
 276       final JComponent c = getWrapperAt(i).getComponent();
 277       if (c == component) {
 278         return i;
 279       }
 280     }
 281     return -1;
 282   }
 283
 284   /**
 285    * @see javax.swing.JTabbedPane#getTabLayoutPolicy
 286    */
 287   public final synchronized int getTabLayoutPolicy(){
 288     return myTabbedPane.getTabLayoutPolicy();
 289   }
 290
 291   /**
 292    * @see javax.swing.JTabbedPane#setTabLayoutPolicy
 293    */
 294   public final synchronized void setTabLayoutPolicy(final int policy){
 295     myTabbedPane.setTabLayoutPolicy(policy);
 296     final int index=myTabbedPane.getSelectedIndex();
 297     if(index!=-1){
 298       myTabbedPane.scrollTabToVisible(index);
 299     }
 300   }
 301
 302   /**
 303    * @deprecated Keyboard navigation is installed/deinstalled automatically. This method does nothing now.
 304    */
 305   public final void installKeyboardNavigation(){
 306   }
 307
 308   /**
 309    * @deprecated Keyboard navigation is installed/deinstalled automatically. This method does nothing now.
 310    */
 311   public final void uninstallKeyboardNavigation(){
 312   }
 313
 314   public final String getTitleAt(final int i) {
 315     return myTabbedPane.getTitleAt(i);
 316   }
 317
 318   public void setSelectedTitle(@Nullable final String title) {
 319     if (title == null) return;
 320
 321     for (int i = 0; i < myTabbedPane.getTabCount(); i++) {
 322       final String each = myTabbedPane.getTitleAt(i);
 323       if (title.equals(each)) {
 324         myTabbedPane.setSelectedIndex(i);
 325         break;
 326       }
 327     }
 328   }
 329
 330   @Nullable
 331   public String getSelectedTitle() {
 332     return getSelectedIndex() < 0 ? null : getTitleAt(getSelectedIndex());
 333   }
 334
 335   public void removeAll() {
 336     myTabbedPane.removeAll();
 337   }
 338
 339   public static final class TabWrapper extends JPanel implements DataProvider{
 340     private JComponent myComponent;
 341
 342     boolean myCustomFocus = true;
 343
 344     public TabWrapper(@NotNull final JComponent component) {
 345       super(new BorderLayout());
 346       myComponent = component;
 347       add(component, BorderLayout.CENTER);
 348     }
 349
 350     /*
 351      * Make possible to search down for DataProviders
 352      */
 353     public Object getData(final String dataId) {
 354       if(myComponent instanceof DataProvider){
 355         return ((DataProvider)myComponent).getData(dataId);
 356       } else {
 357         return null;
 358       }
 359     }
 360
 361     public JComponent getComponent() {
 362       return myComponent;
 363     }
 364
 365     /**
 366      * TabWrappers are never reused so we can fix the leak in some LAF's TabbedPane UI by cleanuping ourselves.
 367      */
 368     public void dispose() {
 369       if (myComponent != null) {
 370         remove(myComponent);
 371         myComponent = null;
 372       }
 373     }
 374
 375     public boolean requestDefaultFocus() {
 376       if (!myCustomFocus) return super.requestDefaultFocus();
 377       if (myComponent == null) return false; // Just in case someone requests the focus when we're already removed from the Swing tree.
 378       final JComponent preferredFocusedComponent = IdeFocusTraversalPolicy.getPreferredFocusedComponent(myComponent);
 379       if (preferredFocusedComponent != null) {
 380         if (!preferredFocusedComponent.requestFocusInWindow()) {
 381           preferredFocusedComponent.requestFocus();
 382         }
 383         return true;
 384       } else {
 385         return myComponent.requestDefaultFocus();
 386       }
 387     }
 388
 389     public void requestFocus() {
 390       if (!myCustomFocus) {
 391         super.requestFocus();
 392       } else {
 393         requestDefaultFocus();
 394       }
 395     }
 396
 397     public boolean requestFocusInWindow() {
 398       if (!myCustomFocus) return super.requestFocusInWindow();
 399       return requestDefaultFocus();
 400     }
 401   }
 402
 403   private final class _MyFocusTraversalPolicy extends IdeFocusTraversalPolicy{
 404     public final Component getDefaultComponentImpl(final Container focusCycleRoot) {
 405       final JComponent component=getSelectedComponent();
 406       if(component!=null){
 407         return IdeFocusTraversalPolicy.getPreferredFocusedComponent(component, this);
 408       }else{
 409         return null;
 410       }
 411     }
 412   }
 413
 414   protected static class TabbedPaneHolder extends JPanel {
 415
 416     private final TabbedPaneWrapper myWrapper;
 417
 418     protected TabbedPaneHolder(TabbedPaneWrapper wrapper) {
 419       super(new BorderLayout());
 420       myWrapper = wrapper;
 421     }
 422
 423     public boolean requestDefaultFocus() {
 424       final JComponent preferredFocusedComponent = IdeFocusTraversalPolicy.getPreferredFocusedComponent(myWrapper.myTabbedPane.getComponent());
 425       if (preferredFocusedComponent != null) {
 426         if (!preferredFocusedComponent.requestFocusInWindow()) {
 427           preferredFocusedComponent.requestFocus();
 428         }
 429         return true;
 430       } else {
 431         return super.requestDefaultFocus();
 432       }
 433     }
 434
 435     public final void requestFocus() {
 436       requestDefaultFocus();
 437     }
 438
 439     public final boolean requestFocusInWindow() {
 440       return requestDefaultFocus();
 441     }
 442
 443     public void updateUI() {
 444       super.updateUI();
 445       if (myWrapper != null) {
 446         myWrapper.myTabbedPane.updateUI();
 447       }
 448     }
 449   }
 450
 451   public static TabbedPaneWrapper get(JTabbedPane tabs) {
 452     return (TabbedPaneWrapper)tabs.getClientProperty(TabbedPaneWrapper.class);
 453   }
 454
 455   private interface TabFactory {
 456     TabbedPane createTabbedPane(int tabPlacement);
 457     TabbedPaneHolder createTabbedPaneHolder();
 458     TabWrapper createTabWrapper(JComponent component);
 459   }
 460
 461   private static class JTabbedPaneFactory implements TabFactory {
 462     private final TabbedPaneWrapper myWrapper;
 463
 464     private JTabbedPaneFactory(TabbedPaneWrapper wrapper) {
 465       myWrapper = wrapper;
 466     }
 467
 468     public TabbedPane createTabbedPane(int tabPlacement) {
 469       return new TabbedPaneImpl(tabPlacement);
 470     }
 471
 472     public TabbedPaneHolder createTabbedPaneHolder() {
 473       return new TabbedPaneHolder(myWrapper);
 474     }
 475
 476     public TabWrapper createTabWrapper(JComponent component) {
 477       return new TabWrapper(component);
 478     }
 479   }
 480
 481   private static class JBTabsFactory implements TabFactory {
 482
 483     private final Project myProject;
 484     private final Disposable myParent;
 485     private final TabbedPaneWrapper myWrapper;
 486
 487     private JBTabsFactory(TabbedPaneWrapper wrapper, Project project, @NotNull Disposable parent) {
 488       myWrapper = wrapper;
 489       myProject = project;
 490       myParent = parent;
 491     }
 492
 493     public TabbedPane createTabbedPane(int tabPlacement) {
 494       return new JBTabsPaneImpl(myProject, tabPlacement, myParent);
 495     }
 496
 497     public TabbedPaneHolder createTabbedPaneHolder() {
 498       return new TabbedPaneHolder(myWrapper) {
 499         @Override
 500         public boolean requestDefaultFocus() {
 501           getTabs().requestFocus();
 502           return true;
 503         }
 504
 505       };
 506     }
 507
 508     public TabWrapper createTabWrapper(JComponent component) {
 509       final TabWrapper tabWrapper = new TabWrapper(component);
 510       tabWrapper.myCustomFocus = false;
 511       return tabWrapper;
 512     }
 513
 514     public JBTabs getTabs() {
 515       return ((JBTabsPaneImpl)myWrapper.myTabbedPane).getTabs();
 516     }
 517
 518     public void dispose() {
 519     }
 520   }
 521
 522   public static class AsJBTabs extends TabbedPaneWrapper {
 523     public AsJBTabs(@Nullable Project project, int tabPlacement, PrevNextActionsDescriptor installKeyboardNavigation, @NotNull Disposable parent) {
 524       super(false);
 525       init(tabPlacement, installKeyboardNavigation, new JBTabsFactory(this, project, parent));
 526     }
 527
 528     public JBTabs getTabs() {
 529       return ((JBTabsPaneImpl)myTabbedPane).getTabs();
 530     }
 531   }
 532
 533   public static class AsJTabbedPane extends TabbedPaneWrapper {
 534     public AsJTabbedPane(int tabPlacement) {
 535       super(false);
 536       init(tabPlacement, DEFAULT_SHORTCUTS, new JTabbedPaneFactory(this));
 537     }
 538   }
 539
 540 }