platform/platform-impl/src/com/intellij/ide/actions/ResizeToolWindowAction.java

   1 /*
   2  * Copyright 2000-2010 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.ide.actions;
  17
  18 import com.intellij.openapi.actionSystem.ActionManager;
  19 import com.intellij.openapi.actionSystem.AnAction;
  20 import com.intellij.openapi.actionSystem.AnActionEvent;
  21 import com.intellij.openapi.actionSystem.PlatformDataKeys;
  22 import com.intellij.openapi.project.DumbAware;
  23 import com.intellij.openapi.project.Project;
  24 import com.intellij.openapi.ui.ShadowAction;
  25 import com.intellij.openapi.util.registry.Registry;
  26 import com.intellij.openapi.wm.*;
  27 import com.intellij.openapi.wm.ex.ToolWindowEx;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import javax.swing.*;
  31 import java.awt.*;
  32
  33 public abstract class ResizeToolWindowAction extends AnAction implements DumbAware {
  34
  35   private ToolWindow myLastWindow;
  36   private ToolWindowManager myLastManager;
  37
  38   protected JLabel myScrollHelper;
  39
  40   private ToolWindow myToolWindow;
  41
  42   protected ResizeToolWindowAction() {
  43   }
  44
  45   protected ResizeToolWindowAction(String text) {
  46     super(text);
  47   }
  48
  49   protected ResizeToolWindowAction(String text, String description, Icon icon) {
  50     super(text, description, icon);
  51   }
  52
  53   protected ResizeToolWindowAction(ToolWindow toolWindow, String originalAction, JComponent c) {
  54     myToolWindow = toolWindow;
  55     new ShadowAction(this, ActionManager.getInstance().getAction(originalAction), c);
  56   }
  57
  58   @Override
  59   public final void update(AnActionEvent e) {
  60     Project project = PlatformDataKeys.PROJECT.getData(e.getDataContext());
  61     if (project == null) {
  62       setDisabled(e);
  63       return;
  64     }
  65
  66     Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
  67     if (owner == null || !(SwingUtilities.getWindowAncestor(owner) instanceof IdeFrame)) {
  68       setDisabled(e);
  69       return;
  70     }
  71
  72
  73     ToolWindowManager mgr = ToolWindowManager.getInstance(project);
  74
  75     ToolWindow window = myToolWindow;
  76
  77     if (window != null || mgr.getActiveToolWindowId() != null) {
  78       if (window == null) {
  79         window = mgr.getToolWindow(mgr.getActiveToolWindowId());
  80       }
  81
  82       if (window == null || !window.isAvailable() || !window.isVisible() || window.getType() == ToolWindowType.FLOATING) {
  83         setDisabled(e);
  84         return;
  85       }
  86
  87       update(e, window, mgr);
  88       if (e.getPresentation().isEnabled()) {
  89         myLastWindow = window;
  90         myLastManager = mgr;
  91       }
  92       else {
  93         setDisabled(e);
  94       }
  95     }
  96     else {
  97       setDisabled(e);
  98     }
  99   }
 100
 101   private void setDisabled(AnActionEvent e) {
 102     e.getPresentation().setEnabled(false);
 103     myLastWindow = null;
 104     myLastManager = null;
 105   }
 106
 107   protected abstract void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr);
 108
 109   @Override
 110   public final void actionPerformed(AnActionEvent e) {
 111     actionPerformed(e, myLastWindow, myLastManager);
 112   }
 113
 114   @Nullable
 115   private ToolWindowScrollable getScrollable(ToolWindow wnd, boolean isHorizontalStretchingOffered) {
 116     KeyboardFocusManager mgr = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 117
 118     Component eachComponent = mgr.getFocusOwner();
 119     ToolWindowScrollable scrollable = null;
 120     while (eachComponent != null) {
 121       if (!SwingUtilities.isDescendingFrom(eachComponent, wnd.getComponent())) break;
 122
 123       if (eachComponent instanceof ToolWindowScrollable) {
 124         ToolWindowScrollable eachScrollable = (ToolWindowScrollable)eachComponent;
 125         if (isHorizontalStretchingOffered) {
 126           if (eachScrollable.isHorizontalScrollingNeeded()) {
 127             scrollable = eachScrollable;
 128             break;
 129           }
 130         } else {
 131           if (eachScrollable.isVerticalScrollingNeeded()) {
 132             scrollable = eachScrollable;
 133             break;
 134           }
 135         }
 136       }
 137
 138       eachComponent = eachComponent.getParent();
 139     }
 140
 141     if (scrollable == null) {
 142       scrollable = new DefaultToolWindowScrollable();
 143     }
 144
 145     if (isHorizontalStretchingOffered && scrollable.isHorizontalScrollingNeeded()) return scrollable;
 146     if (!isHorizontalStretchingOffered && scrollable.isVerticalScrollingNeeded()) return scrollable;
 147
 148     return null;
 149   }
 150
 151   protected abstract void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr);
 152
 153   protected void stretch(ToolWindow wnd, boolean isHorizontalStretching, boolean isIncrementAction) {
 154     ToolWindowScrollable scrollable = getScrollable(wnd, isHorizontalStretching);
 155     if (scrollable == null) return;
 156
 157     ToolWindowAnchor anchor = wnd.getAnchor();
 158     if (isHorizontalStretching && !anchor.isHorizontal()) {
 159       incWidth(wnd, scrollable.getNextHorizontalScroll(), (anchor == ToolWindowAnchor.LEFT) == isIncrementAction);
 160     } else if (!isHorizontalStretching && anchor.isHorizontal()) {
 161       incHeight(wnd, scrollable.getNextVerticalScroll(), (anchor == ToolWindowAnchor.TOP) != isIncrementAction);
 162     }
 163   }
 164
 165   private void incWidth(ToolWindow wnd, int value, boolean isPositive) {
 166     ((ToolWindowEx)wnd).stretchWidth(isPositive ? value : -value);
 167   }
 168
 169   private void incHeight(ToolWindow wnd, int value, boolean isPositive) {
 170     ((ToolWindowEx)wnd).stretchHeight(isPositive ? value : -value);
 171   }
 172
 173   public static class Left extends ResizeToolWindowAction {
 174
 175     public Left() {
 176     }
 177
 178     public Left(String text) {
 179       super(text);
 180     }
 181
 182     public Left(String text, String description, Icon icon) {
 183       super(text, description, icon);
 184     }
 185
 186     public Left(ToolWindow toolWindow, JComponent c) {
 187       super(toolWindow, "ResizeToolWindowLeft", c);
 188     }
 189
 190     @Override
 191     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 192       event.getPresentation().setEnabled(!window.getAnchor().isHorizontal());
 193     }
 194
 195     @Override
 196     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 197       stretch(wnd, true, false);
 198     }
 199   }
 200
 201   public static class Right extends ResizeToolWindowAction {
 202
 203     public Right() {
 204     }
 205
 206     public Right(String text) {
 207       super(text);
 208     }
 209
 210     public Right(String text, String description, Icon icon) {
 211       super(text, description, icon);
 212     }
 213
 214     public Right(ToolWindow toolWindow, JComponent c) {
 215       super(toolWindow, "ResizeToolWindowRight", c);
 216     }
 217
 218     @Override
 219     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 220       event.getPresentation().setEnabled(!window.getAnchor().isHorizontal());
 221     }
 222
 223     @Override
 224     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 225       stretch(wnd, true, true);
 226     }
 227   }
 228
 229   public static class Up extends ResizeToolWindowAction {
 230
 231     public Up() {
 232     }
 233
 234     public Up(String text) {
 235       super(text);
 236     }
 237
 238     public Up(String text, String description, Icon icon) {
 239       super(text, description, icon);
 240     }
 241
 242     public Up(ToolWindow toolWindow, JComponent c) {
 243       super(toolWindow, "ResizeToolWindowUp", c);
 244     }
 245
 246     @Override
 247     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 248       event.getPresentation().setEnabled(window.getAnchor().isHorizontal());
 249     }
 250
 251     @Override
 252     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 253       stretch(wnd, false, true);
 254     }
 255   }
 256
 257   public static class Down extends ResizeToolWindowAction {
 258
 259     public Down() {
 260     }
 261
 262     public Down(String text) {
 263       super(text);
 264     }
 265
 266     public Down(String text, String description, Icon icon) {
 267       super(text, description, icon);
 268     }
 269
 270     public Down(ToolWindow toolWindow, JComponent c) {
 271       super(toolWindow, "ResizeToolWindowDown", c);
 272     }
 273
 274     @Override
 275     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 276       event.getPresentation().setEnabled(window.getAnchor().isHorizontal());
 277     }
 278
 279     @Override
 280     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 281       stretch(wnd, false, false);
 282     }
 283   }
 284
 285   private class DefaultToolWindowScrollable implements ToolWindowScrollable {
 286
 287     public boolean isHorizontalScrollingNeeded() {
 288       return true;
 289     }
 290
 291     public int getNextHorizontalScroll() {
 292       return getReferenceSize().width * Registry.intValue("ide.windowSystem.hScrollChars");
 293     }
 294
 295     public boolean isVerticalScrollingNeeded() {
 296       return true;
 297     }
 298
 299     public int getNextVerticalScroll() {
 300       return getReferenceSize().height * Registry.intValue("ide.windowSystem.vScrollChars");
 301     }
 302   }
 303
 304   private Dimension getReferenceSize() {
 305     if (myScrollHelper == null) {
 306       if (SwingUtilities.isEventDispatchThread()) {
 307         myScrollHelper = new JLabel("W");
 308       } else {
 309         return new Dimension(1, 1);
 310       }
 311     }
 312
 313     return myScrollHelper.getPreferredSize();
 314   }
 315 }