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 = new JLabel("W");
  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     ToolWindowManager mgr = ToolWindowManager.getInstance(project);
  67
  68     ToolWindow window = myToolWindow;
  69
  70     if (window != null || mgr.getActiveToolWindowId() != null) {
  71       if (window == null) {
  72         window = mgr.getToolWindow(mgr.getActiveToolWindowId());
  73       }
  74
  75       if (window == null || !window.isAvailable() || !window.isVisible() || window.getType() == ToolWindowType.FLOATING) {
  76         setDisabled(e);
  77         return;
  78       }
  79
  80       update(e, window, mgr);
  81       if (e.getPresentation().isEnabled()) {
  82         myLastWindow = window;
  83         myLastManager = mgr;
  84       }
  85       else {
  86         setDisabled(e);
  87       }
  88     }
  89     else {
  90       setDisabled(e);
  91     }
  92   }
  93
  94   private void setDisabled(AnActionEvent e) {
  95     e.getPresentation().setEnabled(false);
  96     myLastWindow = null;
  97     myLastManager = null;
  98   }
  99
 100   protected abstract void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr);
 101
 102   @Override
 103   public final void actionPerformed(AnActionEvent e) {
 104     actionPerformed(e, myLastWindow, myLastManager);
 105   }
 106
 107   @Nullable
 108   private ToolWindowScrollable getScrollable(ToolWindow wnd, boolean isHorizontalStretchingOffered) {
 109     KeyboardFocusManager mgr = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 110
 111     Component eachComponent = mgr.getFocusOwner();
 112     ToolWindowScrollable scrollable = null;
 113     while (eachComponent != null) {
 114       if (!SwingUtilities.isDescendingFrom(eachComponent, wnd.getComponent())) break;
 115
 116       if (eachComponent instanceof ToolWindowScrollable) {
 117         ToolWindowScrollable eachScrollable = (ToolWindowScrollable)eachComponent;
 118         if (isHorizontalStretchingOffered) {
 119           if (eachScrollable.isHorizontalScrollingNeeded()) {
 120             scrollable = eachScrollable;
 121             break;
 122           }
 123         } else {
 124           if (eachScrollable.isVerticalScrollingNeeded()) {
 125             scrollable = eachScrollable;
 126             break;
 127           }
 128         }
 129       }
 130
 131       eachComponent = eachComponent.getParent();
 132     }
 133
 134     if (scrollable == null) {
 135       scrollable = new DefaultToolWindowScrollable();
 136     }
 137
 138     if (isHorizontalStretchingOffered && scrollable.isHorizontalScrollingNeeded()) return scrollable;
 139     if (!isHorizontalStretchingOffered && scrollable.isVerticalScrollingNeeded()) return scrollable;
 140
 141     return null;
 142   }
 143
 144   protected abstract void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr);
 145
 146   protected void stretch(ToolWindow wnd, boolean isHorizontalStretching, boolean isIncrementAction) {
 147     ToolWindowScrollable scrollable = getScrollable(wnd, isHorizontalStretching);
 148     if (scrollable == null) return;
 149
 150     ToolWindowAnchor anchor = wnd.getAnchor();
 151     if (isHorizontalStretching && !anchor.isHorizontal()) {
 152       incWidth(wnd, scrollable.getNextHorizontalScroll(), (anchor == ToolWindowAnchor.LEFT) == isIncrementAction);
 153     } else if (!isHorizontalStretching && anchor.isHorizontal()) {
 154       incHeight(wnd, scrollable.getNextVerticalScroll(), (anchor == ToolWindowAnchor.TOP) != isIncrementAction);
 155     }
 156   }
 157
 158   private void incWidth(ToolWindow wnd, int value, boolean isPositive) {
 159     ((ToolWindowEx)wnd).stretchWidth(isPositive ? value : -value);
 160   }
 161
 162   private void incHeight(ToolWindow wnd, int value, boolean isPositive) {
 163     ((ToolWindowEx)wnd).stretchHeight(isPositive ? value : -value);
 164   }
 165
 166   public static class Left extends ResizeToolWindowAction {
 167
 168     public Left() {
 169     }
 170
 171     public Left(String text) {
 172       super(text);
 173     }
 174
 175     public Left(String text, String description, Icon icon) {
 176       super(text, description, icon);
 177     }
 178
 179     public Left(ToolWindow toolWindow, JComponent c) {
 180       super(toolWindow, "ResizeToolWindowLeft", c);
 181     }
 182
 183     @Override
 184     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 185       event.getPresentation().setEnabled(!window.getAnchor().isHorizontal());
 186     }
 187
 188     @Override
 189     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 190       stretch(wnd, true, false);
 191     }
 192   }
 193
 194   public static class Right extends ResizeToolWindowAction {
 195
 196     public Right() {
 197     }
 198
 199     public Right(String text) {
 200       super(text);
 201     }
 202
 203     public Right(String text, String description, Icon icon) {
 204       super(text, description, icon);
 205     }
 206
 207     public Right(ToolWindow toolWindow, JComponent c) {
 208       super(toolWindow, "ResizeToolWindowRight", c);
 209     }
 210
 211     @Override
 212     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 213       event.getPresentation().setEnabled(!window.getAnchor().isHorizontal());
 214     }
 215
 216     @Override
 217     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 218       stretch(wnd, true, true);
 219     }
 220   }
 221
 222   public static class Up extends ResizeToolWindowAction {
 223
 224     public Up() {
 225     }
 226
 227     public Up(String text) {
 228       super(text);
 229     }
 230
 231     public Up(String text, String description, Icon icon) {
 232       super(text, description, icon);
 233     }
 234
 235     public Up(ToolWindow toolWindow, JComponent c) {
 236       super(toolWindow, "ResizeToolWindowUp", c);
 237     }
 238
 239     @Override
 240     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 241       event.getPresentation().setEnabled(window.getAnchor().isHorizontal());
 242     }
 243
 244     @Override
 245     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 246       stretch(wnd, false, true);
 247     }
 248   }
 249
 250   public static class Down extends ResizeToolWindowAction {
 251
 252     public Down() {
 253     }
 254
 255     public Down(String text) {
 256       super(text);
 257     }
 258
 259     public Down(String text, String description, Icon icon) {
 260       super(text, description, icon);
 261     }
 262
 263     public Down(ToolWindow toolWindow, JComponent c) {
 264       super(toolWindow, "ResizeToolWindowDown", c);
 265     }
 266
 267     @Override
 268     protected void update(AnActionEvent event, ToolWindow window, ToolWindowManager mgr) {
 269       event.getPresentation().setEnabled(window.getAnchor().isHorizontal());
 270     }
 271
 272     @Override
 273     protected void actionPerformed(AnActionEvent e, ToolWindow wnd, ToolWindowManager mgr) {
 274       stretch(wnd, false, false);
 275     }
 276   }
 277
 278   private class DefaultToolWindowScrollable implements ToolWindowScrollable {
 279
 280     public boolean isHorizontalScrollingNeeded() {
 281       return true;
 282     }
 283
 284     public int getNextHorizontalScroll() {
 285       return myScrollHelper.getPreferredSize().width * Registry.intValue("ide.windowSystem.hScrollChars");
 286     }
 287
 288     public boolean isVerticalScrollingNeeded() {
 289       return true;
 290     }
 291
 292     public int getNextVerticalScroll() {
 293       return myScrollHelper.getPreferredSize().height * Registry.intValue("ide.windowSystem.vScrollChars");
 294     }
 295   }
 296 }