platform/platform-impl/src/com/intellij/openapi/wm/impl/ActiveStack.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 java.util.Iterator;
  19 import java.util.Stack;
  20
  21 /**
  22  * Actually this class represent two stacks.
  23  * 1. Stack of <code>id</code>s of active tool windows. This stack is used for reactivation of tool window
  24  * after the another tool window was closed. This stack is cleared every time you active the editor.
  25  * 2. Permanent stack. It is the same as the first one, but it's not cleared when editor is being
  26  * activated. It used to provide id of last active tool window.
  27  *
  28  * @author Vladimir Kondratyev
  29  */
  30 final class ActiveStack {
  31   /**
  32    * Contains <code>id</code>s of tool window that were activated. This stack
  33    * is cleared each time when editor is being activated.
  34    */
  35   private final Stack<String> myStack;
  36   /**
  37    * This stack is not cleared when editor is being activated. It means its "long"
  38    * persistence.
  39    */
  40   private final Stack<String> myPersistentStack;
  41
  42   /**
  43    * Creates enabled window stack.
  44    */
  45   ActiveStack() {
  46     myStack = new Stack<String>();
  47     myPersistentStack = new Stack<String>();
  48   }
  49
  50   /**
  51    * Clears stack but doesn't affect long persistence stack.
  52    */
  53   void clear() {
  54     myStack.clear();
  55   }
  56
  57   /**
  58    * Return whether the stack of active (not persistent) <code>id</code>s is empty or not.
  59    */
  60   boolean isEmpty() {
  61     return myStack.isEmpty();
  62   }
  63
  64   String pop() {
  65     return myStack.pop();
  66   }
  67
  68   String peek() {
  69     return myStack.peek();
  70   }
  71
  72   void push(final String id) {
  73     remove(id, true);
  74     myStack.push(id);
  75     myPersistentStack.push(id);
  76   }
  77
  78   int getPersistentSize() {
  79     return myPersistentStack.size();
  80   }
  81
  82   /**
  83    * Peeks element at the persistent stack. <code>0</code> means the top of the stack.
  84    */
  85   String peekPersistent(final int index) {
  86     return myPersistentStack.get(myPersistentStack.size() - index - 1);
  87   }
  88
  89   /**
  90    * Removes specified <code>ID</code> from stack.
  91    *
  92    * @param id                   <code>ID</code> to be removed.
  93    * @param removePersistentAlso if <code>true</code> then clears last active <code>ID</code>
  94    *                             if it's the last active <code>ID</code>.
  95    */
  96   void remove(final String id, final boolean removePersistentAlso) {
  97     for (Iterator i = myStack.iterator(); i.hasNext();) {
  98       if (id.equals(i.next())) {
  99         i.remove();
 100       }
 101     }
 102     if (removePersistentAlso) {
 103       for (Iterator i = myPersistentStack.iterator(); i.hasNext();) {
 104         if (id.equals(i.next())) {
 105           i.remove();
 106         }
 107       }
 108     }
 109   }
 110 }