platform/platform-api/src/com/intellij/openapi/ui/ThreeComponentsSplitter.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.openapi.ui;

 import com.intellij.icons.AllIcons;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.Weighted;
 import com.intellij.openapi.wm.IdeGlassPane;
 import com.intellij.openapi.wm.IdeGlassPaneUtil;
 import com.intellij.ui.ClickListener;
 import com.intellij.ui.UIBundle;
 import com.intellij.util.ui.update.Activatable;
 import com.intellij.util.ui.update.UiNotifyConnector;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;

 /**
  * @author Vladimir Kondratyev
  */
 public class ThreeComponentsSplitter extends JPanel implements Disposable {
   private int myDividerWidth;
   /**
    *                        /------/
    *                        |  1   |
    * This is vertical split |------|
    *                        |  2   |
    *                        /------/
    *
    *                          /-------/
    *                          |   |   |
    * This is horizontal split | 1 | 2 |
    *                          |   |   |
    *                          /-------/
    */
   private boolean myVerticalSplit;
   private boolean myHonorMinimumSize = false;

   private final Divider myFirstDivider;
   private final Divider myLastDivider;

   @Nullable private JComponent myFirstComponent;
   @Nullable private JComponent myInnerComponent;
   @Nullable private JComponent myLastComponent;

   private int myFirstSize = 10;
   private int myLastSize = 10;

   private boolean myShowDividerControls;
   private int myDividerZone;


   /**
    * Creates horizontal split with proportion equals to .5f
    */
   public ThreeComponentsSplitter() {
     this(false);
   }


   public ThreeComponentsSplitter(boolean vertical) {
     myVerticalSplit = vertical;
     myShowDividerControls = false;
     myFirstDivider = new Divider(true);
     Disposer.register(this, myFirstDivider);
     myLastDivider = new Divider(false);
     Disposer.register(this, myLastDivider);

     myDividerWidth = 7;
     setOpaque(false);
     add(myFirstDivider);
     add(myLastDivider);
   }

   public void setShowDividerControls(boolean showDividerControls) {
     myShowDividerControls = showDividerControls;
     setOrientation(myVerticalSplit);
   }

   public void setDividerMouseZoneSize(int size) {
     myDividerZone = size;
   }

   public boolean isHonorMinimumSize() {
     return myHonorMinimumSize;
   }

   public void setHonorComponentsMinimumSize(boolean honorMinimumSize) {
     myHonorMinimumSize = honorMinimumSize;
   }

   public boolean isVisible() {
     return super.isVisible() && (firstVisible() || innerVisible() || lastVisible());
   }

   private boolean lastVisible() {
     return !Splitter.isNull(myLastComponent) && myLastComponent.isVisible();
   }

   private boolean innerVisible() {
     return !Splitter.isNull(myInnerComponent) && myInnerComponent.isVisible();
   }

   private boolean firstVisible() {
     return !Splitter.isNull(myFirstComponent) && myFirstComponent.isVisible();
   }

   private int visibleDividersCount() {
     int count = 0;
     if (firstDividerVisible()) count++;
     if (lastDividerVisible()) count++;
     return count;
   }

   private boolean firstDividerVisible() {
     return firstVisible() && innerVisible() || firstVisible() && lastVisible() && !innerVisible();
   }

   private boolean lastDividerVisible() {
     return innerVisible() && lastVisible();
   }

   public Dimension getMinimumSize() {
     if (isHonorMinimumSize()) {
       final int dividerWidth = getDividerWidth();
       final Dimension firstSize = myFirstComponent != null ? myFirstComponent.getMinimumSize() : new Dimension(0, 0);
       final Dimension lastSize = myLastComponent != null ? myLastComponent.getMinimumSize() : new Dimension(0, 0);
       final Dimension innerSize = myInnerComponent != null ? myInnerComponent.getMinimumSize() : new Dimension(0, 0);
       if (getOrientation()) {
         int width = Math.max(firstSize.width, Math.max(lastSize.width, innerSize.width));
         int height = visibleDividersCount() * dividerWidth;
         height += firstSize.height;
         height += lastSize.height;
         height += innerSize.height;
         return new Dimension(width, height);
       }
       else {
         int heigth = Math.max(firstSize.height, Math.max(lastSize.height, innerSize.height));
         int width = visibleDividersCount() * dividerWidth;
         width += firstSize.width;
         width += lastSize.width;
         width += innerSize.width;
         return new Dimension(width, heigth);
       }
     }
     return super.getMinimumSize();
   }

   public void doLayout() {
     final int width = getWidth();
     final int height = getHeight();

     Rectangle firstRect = new Rectangle();
     Rectangle firstDividerRect = new Rectangle();
     Rectangle lastDividerRect = new Rectangle();
     Rectangle lastRect = new Rectangle();
     Rectangle innerRect = new Rectangle();
     final int componentSize = getOrientation() ? height : width;
     int dividerWidth = getDividerWidth();
     int dividersCount = visibleDividersCount();

     int firstCompontSize;
     int lastComponentSize;
     int innerComponentSize;
     if(componentSize <= dividersCount * dividerWidth) {
       firstCompontSize = 0;
       lastComponentSize = 0;
       innerComponentSize = 0;
       dividerWidth = componentSize;
     }
     else {
       firstCompontSize = getFirstSize();
       lastComponentSize = getLastSize();
       int sizeLack = firstCompontSize + lastComponentSize - (componentSize - dividersCount * dividerWidth);
       if (sizeLack > 0) {
         // Lacking size. Reduce first component's size, inner -> empty
         firstCompontSize -= sizeLack;
         innerComponentSize = 0;
       }
       else {
         innerComponentSize = componentSize - dividersCount * dividerWidth - getFirstSize() - getLastSize();
       }

       if (!innerVisible()) {
         lastComponentSize += innerComponentSize;
         innerComponentSize = 0;
         if (!lastVisible()) {
           firstCompontSize = componentSize;
         }
       }
     }

     if (getOrientation()) {
       int space = firstCompontSize;
       firstRect.setBounds(0, 0, width, firstCompontSize);
       if (firstDividerVisible()) {
         firstDividerRect.setBounds(0, space, width, dividerWidth);
         space += dividerWidth;
       }

       innerRect.setBounds(0, space, width, innerComponentSize);
       space += innerComponentSize;

       if (lastDividerVisible()) {
         lastDividerRect.setBounds(0, space, width, dividerWidth);
         space += dividerWidth;
       }

       lastRect.setBounds(0, space, width, lastComponentSize);
     }
     else {
       int space = firstCompontSize;
       firstRect.setBounds(0, 0, firstCompontSize, height);

       if (firstDividerVisible()) {
         firstDividerRect.setBounds(space, 0, dividerWidth, height);
         space += dividerWidth;
       }

       innerRect.setBounds(space, 0, innerComponentSize, height);
       space += innerComponentSize;

       if (lastDividerVisible()) {
         lastDividerRect.setBounds(space, 0, dividerWidth, height);
         space += dividerWidth;
       }

       lastRect.setBounds(space, 0, lastComponentSize, height);
     }

     myFirstDivider.setVisible(firstDividerVisible());
     myFirstDivider.setBounds(firstDividerRect);
     myFirstDivider.doLayout();

     myLastDivider.setVisible(lastDividerVisible());
     myLastDivider.setBounds(lastDividerRect);
     myLastDivider.doLayout();

     validateIfNeeded(myFirstComponent, firstRect);
     validateIfNeeded(myInnerComponent, innerRect);
     validateIfNeeded(myLastComponent, lastRect);
   }

   private static void validateIfNeeded(final JComponent c, final Rectangle rect) {
     if (!Splitter.isNull(c)) {
       if (!c.getBounds().equals(rect)) {
         c.setBounds(rect);
         c.revalidate();
       }
     } else {
       Splitter.hideNull(c);
     }
   }


   public int getDividerWidth() {
     return myDividerWidth;
   }

   public void setDividerWidth(int width) {
     if (width < 0) {
       throw new IllegalArgumentException("Wrong divider width: " + width);
     }
     if (myDividerWidth != width) {
       myDividerWidth = width;
       doLayout();
       repaint();
     }
   }

   /**
    * @return <code>true</code> if splitter has vertical orientation, <code>false</code> otherwise
    */
   public boolean getOrientation() {
     return myVerticalSplit;
   }

   /**
    * @param verticalSplit <code>true</code> means that splitter will have vertical split
    */
   public void setOrientation(boolean verticalSplit) {
     myVerticalSplit = verticalSplit;
     myFirstDivider.setOrientation(verticalSplit);
     myLastDivider.setOrientation(verticalSplit);
     doLayout();
     repaint();
   }

   @Nullable
   public JComponent getFirstComponent() {
     return myFirstComponent;
   }

   /**
    * Sets component which is located as the "first" splitted area. The method doesn't validate and
    * repaint the splitter. If there is already
    *
    */
   public void setFirstComponent(@Nullable JComponent component) {
     if (myFirstComponent != component) {
       if (myFirstComponent != null) {
         remove(myFirstComponent);
       }
       myFirstComponent = component;
       if (myFirstComponent != null) {
         add(myFirstComponent);
         myFirstComponent.invalidate();
       }
     }
   }

   @Nullable
   public JComponent getLastComponent() {
     return myLastComponent;
   }


   /**
    * Sets component which is located as the "secont" splitted area. The method doesn't validate and
    * repaint the splitter.
    *
    */
   public void setLastComponent(@Nullable JComponent component) {
     if (myLastComponent != component) {
       if (myLastComponent != null) {
         remove(myLastComponent);
       }
       myLastComponent = component;
       if (myLastComponent != null) {
         add(myLastComponent);
         myLastComponent.invalidate();
       }
     }
   }

   @Nullable
   public JComponent getInnerComponent() {
     return myInnerComponent;
   }


   /**
    * Sets component which is located as the "inner" splitted area. The method doesn't validate and
    * repaint the splitter.
    *
    */
   public void setInnerComponent(@Nullable JComponent component) {
     if (myInnerComponent != component) {
       if (myInnerComponent != null) {
         remove(myInnerComponent);
       }
       myInnerComponent = component;
       if (myInnerComponent != null) {
         add(myInnerComponent);
         myInnerComponent.invalidate();
       }
     }
   }

   public void setFirstSize(final int size) {
     myFirstSize = size;
     doLayout();
     repaint();
   }

   public void setLastSize(final int size) {
     myLastSize = size;
     doLayout();
     repaint();
   }

   public int getFirstSize() {
     return firstVisible() ? myFirstSize : 0;
   }

   public int getLastSize() {
     return lastVisible() ? myLastSize : 0;
   }

   @Override
   public void dispose() {
     myLastComponent = null;
     myFirstComponent = null;
     myInnerComponent = null;
     removeAll();
     Container container = getParent();
     if (container != null) {
       container.remove(this);
     }
   }

   private class Divider extends JPanel implements Disposable {
     protected boolean myDragging;
     protected Point myPoint;
     private final boolean myIsFirst;

     private IdeGlassPane myGlassPane;

     private class MyMouseAdapter extends MouseAdapter implements Weighted {
       @Override
       public void mousePressed(MouseEvent e) {
         _processMouseEvent(e);
       }

       @Override
       public void mouseReleased(MouseEvent e) {
         _processMouseEvent(e);
       }

       @Override
       public void mouseMoved(MouseEvent e) {
         _processMouseMotionEvent(e);
       }

       @Override
       public void mouseDragged(MouseEvent e) {
         _processMouseMotionEvent(e);
       }
       @Override
       public double getWeight() {
         return 1;
       }
       private void _processMouseMotionEvent(MouseEvent e) {
         MouseEvent event = getTargetEvent(e);
         if (event == null) {
           myGlassPane.setCursor(null, myListener);
           return;
         }

         processMouseMotionEvent(event);
         if (event.isConsumed()) {
           e.consume();
         }
       }

       private void _processMouseEvent(MouseEvent e) {
         MouseEvent event = getTargetEvent(e);
         if (event == null) {
           myGlassPane.setCursor(null, myListener);
           return;
         }

         processMouseEvent(event);
         if (event.isConsumed()) {
           e.consume();
         }
       }
     }

     private final MouseAdapter myListener = new MyMouseAdapter();


     private MouseEvent getTargetEvent(MouseEvent e) {
       return SwingUtilities.convertMouseEvent(e.getComponent(), e, this);
     }

     private boolean myWasPressedOnMe;

     public Divider(boolean isFirst) {
       super(new GridBagLayout());
       setFocusable(false);
       enableEvents(MouseEvent.MOUSE_EVENT_MASK | MouseEvent.MOUSE_MOTION_EVENT_MASK);
       myIsFirst = isFirst;
       setOrientation(myVerticalSplit);

       new UiNotifyConnector.Once(this, new Activatable.Adapter() {
         @Override
         public void showNotify() {
           init();
         }
       });
     }

     private boolean isInside(Point p) {
       if (!isVisible()) return false;

       if (myVerticalSplit) {
         if (p.x >= 0 && p.x < getWidth()) {
           if (getHeight() > 0) {
             return p.y >= 0 && p.y < getHeight();
           }
           else {
             return p.y >= -myDividerZone / 2 && p.y <= myDividerZone / 2;
           }
         }
       }
       else {
         if (p.y >= 0 && p.y < getHeight()) {
           if (getWidth() > 0) {
             return p.x >= 0 && p.x < getWidth();
           }
           else {
             return p.x >= -myDividerZone / 2 && p.x <= myDividerZone / 2;
           }
         }
       }

       return false;
     }

     private void init() {
       myGlassPane = IdeGlassPaneUtil.find(this);
       myGlassPane.addMouseMotionPreprocessor(myListener, this);
       myGlassPane.addMousePreprocessor(myListener, this);
     }

     public void dispose() {
     }

     private void setOrientation(boolean isVerticalSplit) {
       removeAll();

       if (!myShowDividerControls) {
         return;
       }

       int xMask = isVerticalSplit ? 1 : 0;
       int yMask = isVerticalSplit ? 0 : 1;

       Icon glueIcon = isVerticalSplit ? AllIcons.General.SplitGlueV : AllIcons.General.SplitCenterH;
       int glueFill = isVerticalSplit ? GridBagConstraints.VERTICAL : GridBagConstraints.HORIZONTAL;
       add(new JLabel(glueIcon),
           new GridBagConstraints(0, 0, 1, 1, 0, 0, isVerticalSplit ? GridBagConstraints.EAST : GridBagConstraints.NORTH, glueFill, new Insets(0, 0, 0, 0), 0, 0));
       JLabel splitDownlabel = new JLabel(isVerticalSplit ? AllIcons.General.SplitDown : AllIcons.General.SplitRight);
       splitDownlabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
       splitDownlabel.setToolTipText(isVerticalSplit ? UIBundle.message("splitter.down.tooltip.text") : UIBundle
         .message("splitter.right.tooltip.text"));
       new ClickListener() {
         @Override
         public boolean onClick(@NotNull MouseEvent e, int clickCount) {
           if (myInnerComponent != null) {
             final int income = myVerticalSplit ? myInnerComponent.getHeight() : myInnerComponent.getWidth();
             if (myIsFirst) {
               setFirstSize(myFirstSize + income);
             }
             else {
               setLastSize(myLastSize + income);
             }
           }
           return true;
         }
       }.installOn(splitDownlabel);

       add(splitDownlabel,
           new GridBagConstraints(isVerticalSplit ? 1 : 0,
                                  isVerticalSplit ? 0 : 5,
                                  1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
       //
       add(new JLabel(glueIcon),
           new GridBagConstraints(2 * xMask, 2 * yMask, 1, 1, 0, 0, GridBagConstraints.CENTER, glueFill, new Insets(0, 0, 0, 0), 0, 0));
       JLabel splitCenterlabel = new JLabel(isVerticalSplit ? AllIcons.General.SplitCenterV : AllIcons.General.SplitCenterH);
       splitCenterlabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
       splitCenterlabel.setToolTipText(UIBundle.message("splitter.center.tooltip.text"));
       new ClickListener() {
         @Override
         public boolean onClick(@NotNull MouseEvent e, int clickCount) {
           center();
           return true;
         }
       }.installOn(splitCenterlabel);
       add(splitCenterlabel,
           new GridBagConstraints(3 * xMask, 3 * yMask, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
       add(new JLabel(glueIcon),
           new GridBagConstraints(4 * xMask, 4 * yMask, 1, 1, 0, 0, GridBagConstraints.CENTER, glueFill, new Insets(0, 0, 0, 0), 0, 0));
       //
       JLabel splitUpLabel = new JLabel(isVerticalSplit ? AllIcons.General.SplitUp : AllIcons.General.SplitLeft);
       splitUpLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
       splitUpLabel.setToolTipText(isVerticalSplit ? UIBundle.message("splitter.up.tooltip.text") : UIBundle
         .message("splitter.left.tooltip.text"));
       new ClickListener() {
         @Override
         public boolean onClick(@NotNull MouseEvent e, int clickCount) {
           if (myInnerComponent != null) {
             final int income = myVerticalSplit ? myInnerComponent.getHeight() : myInnerComponent.getWidth();
             if (myIsFirst) {
               setFirstSize(myFirstSize + income);
             }
             else {
               setLastSize(myLastSize + income);
             }
           }
           return true;
         }
       }.installOn(splitUpLabel);

       add(splitUpLabel,
           new GridBagConstraints(isVerticalSplit ? 5 : 0,
                                  isVerticalSplit ? 0 : 1,
                                  1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
       add(new JLabel(glueIcon),
           new GridBagConstraints(6 * xMask, 6 * yMask, 1, 1, 0, 0,
                                  isVerticalSplit ? GridBagConstraints.WEST : GridBagConstraints.SOUTH, glueFill, new Insets(0, 0, 0, 0), 0, 0));
     }

     private void center() {
       if (myInnerComponent != null) {
         final int total = myFirstSize + (myVerticalSplit ? myInnerComponent.getHeight() : myInnerComponent.getWidth());
         if (myIsFirst) {
           setFirstSize(total / 2);
         }
         else {
           setLastSize(total / 2);
         }
       }
     }

     protected void processMouseMotionEvent(MouseEvent e) {
       super.processMouseMotionEvent(e);

       if (!isShowing()) return;

       if (MouseEvent.MOUSE_DRAGGED == e.getID() && myWasPressedOnMe) {
         myDragging = true;
         setCursor(getResizeCursor());
         myGlassPane.setCursor(getResizeCursor(), myListener);

         myPoint = SwingUtilities.convertPoint(this, e.getPoint(), ThreeComponentsSplitter.this);
         if (getOrientation()) {
           if (getHeight() > 0 || myDividerZone > 0) {
             if (myIsFirst) {
               setFirstSize(Math.max(getMinSize(myFirstComponent), myPoint.y));
             }
             else {
               setLastSize(Math.max(getMinSize(myLastComponent), ThreeComponentsSplitter.this.getHeight() - myPoint.y - getDividerWidth()));
             }
           }
         }
         else {
           if (getWidth() > 0 || myDividerZone > 0) {
             if (myIsFirst) {
               setFirstSize(Math.max(getMinSize(myFirstComponent), myPoint.x));
             }
             else {
               setLastSize(Math.max(getMinSize(myLastComponent), ThreeComponentsSplitter.this.getWidth() - myPoint.x - getDividerWidth()));
             }
           }
         }
         ThreeComponentsSplitter.this.doLayout();
       } else if (MouseEvent.MOUSE_MOVED == e.getID()) {
         if (myGlassPane != null) {
           if (isInside(e.getPoint())) {
             myGlassPane.setCursor(getResizeCursor(), myListener);
             e.consume();
           } else {
             myGlassPane.setCursor(null, myListener);
           }
         }
       }

       if (myWasPressedOnMe) {
         e.consume();
       }
     }

     private int getMinSize(JComponent component) {
       if (isHonorMinimumSize()) {
         if (component != null && myFirstComponent != null && myFirstComponent.isVisible() && myLastComponent != null && myLastComponent.isVisible()) {
           if (getOrientation()) {
             return component.getMinimumSize().height;
           }
           else {
             return component.getMinimumSize().width;
           }
         }
       }
       return 0;
     }

     protected void processMouseEvent(MouseEvent e) {
       super.processMouseEvent(e);
       if (!isShowing()) {
         return;
       }
       switch (e.getID()) {
         case MouseEvent.MOUSE_ENTERED:
           setCursor(getResizeCursor());
           break;
         case MouseEvent.MOUSE_EXITED:
           if (!myDragging) {
             setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
           }
           break;
         case MouseEvent.MOUSE_PRESSED:
           if (isInside(e.getPoint())) {
             myWasPressedOnMe = true;
             myGlassPane.setCursor(getResizeCursor(), myListener);
             e.consume();
           } else {
             myWasPressedOnMe = false;
           }
           break;
         case MouseEvent.MOUSE_RELEASED:
           if (myWasPressedOnMe) {
             e.consume();
           }
           if (isInside(e.getPoint())) {
             myGlassPane.setCursor(getResizeCursor(), myListener);
           }
           myWasPressedOnMe = false;
           myDragging = false;
           myPoint = null;
           break;
         case MouseEvent.MOUSE_CLICKED:
           if (e.getClickCount() == 2) {
             center();
           }
           break;
       }
     }
   }

   private Cursor getResizeCursor() {
     return getOrientation() ? Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR) : Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
   }
 }
	/*
	* Copyright 2000-2014 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.openapi.ui;

	import com.intellij.icons.AllIcons;
	import com.intellij.openapi.Disposable;
	import com.intellij.openapi.util.Disposer;
	import com.intellij.openapi.util.Weighted;
	import com.intellij.openapi.wm.IdeGlassPane;
	import com.intellij.openapi.wm.IdeGlassPaneUtil;
	import com.intellij.ui.ClickListener;
	import com.intellij.ui.UIBundle;
	import com.intellij.util.ui.update.Activatable;
	import com.intellij.util.ui.update.UiNotifyConnector;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import javax.swing.*;
	import java.awt.*;
	import java.awt.event.MouseAdapter;
	import java.awt.event.MouseEvent;

	/**
	* @author Vladimir Kondratyev
	*/
	public class ThreeComponentsSplitter extends JPanel implements Disposable {
	private int myDividerWidth;
	/**
	* /------/
	* \| 1 \|
	* This is vertical split \|------\|
	* \| 2 \|
	* /------/
	*
	* /-------/
	* \| \| \|
	* This is horizontal split \| 1 \| 2 \|
	* \| \| \|
	* /-------/
	*/
	private boolean myVerticalSplit;
	private boolean myHonorMinimumSize = false;

	private final Divider myFirstDivider;
	private final Divider myLastDivider;

	@Nullable private JComponent myFirstComponent;
	@Nullable private JComponent myInnerComponent;
	@Nullable private JComponent myLastComponent;

	private int myFirstSize = 10;
	private int myLastSize = 10;

	private boolean myShowDividerControls;
	private int myDividerZone;


	/**
	* Creates horizontal split with proportion equals to .5f
	*/
	public ThreeComponentsSplitter() {
	this(false);
	}


	public ThreeComponentsSplitter(boolean vertical) {
	myVerticalSplit = vertical;
	myShowDividerControls = false;
	myFirstDivider = new Divider(true);
	Disposer.register(this, myFirstDivider);
	myLastDivider = new Divider(false);
	Disposer.register(this, myLastDivider);

	myDividerWidth = 7;
	setOpaque(false);
	add(myFirstDivider);
	add(myLastDivider);
	}

	public void setShowDividerControls(boolean showDividerControls) {
	myShowDividerControls = showDividerControls;
	setOrientation(myVerticalSplit);
	}

	public void setDividerMouseZoneSize(int size) {
	myDividerZone = size;
	}

	public boolean isHonorMinimumSize() {
	return myHonorMinimumSize;
	}

	public void setHonorComponentsMinimumSize(boolean honorMinimumSize) {
	myHonorMinimumSize = honorMinimumSize;
	}

	public boolean isVisible() {
	return super.isVisible() && (firstVisible() \|\| innerVisible() \|\| lastVisible());
	}

	private boolean lastVisible() {
	return !Splitter.isNull(myLastComponent) && myLastComponent.isVisible();
	}

	private boolean innerVisible() {
	return !Splitter.isNull(myInnerComponent) && myInnerComponent.isVisible();
	}

	private boolean firstVisible() {
	return !Splitter.isNull(myFirstComponent) && myFirstComponent.isVisible();
	}

	private int visibleDividersCount() {
	int count = 0;
	if (firstDividerVisible()) count++;
	if (lastDividerVisible()) count++;
	return count;
	}

	private boolean firstDividerVisible() {
	return firstVisible() && innerVisible() \|\| firstVisible() && lastVisible() && !innerVisible();
	}

	private boolean lastDividerVisible() {
	return innerVisible() && lastVisible();
	}

	public Dimension getMinimumSize() {
	if (isHonorMinimumSize()) {
	final int dividerWidth = getDividerWidth();
	final Dimension firstSize = myFirstComponent != null ? myFirstComponent.getMinimumSize() : new Dimension(0, 0);
	final Dimension lastSize = myLastComponent != null ? myLastComponent.getMinimumSize() : new Dimension(0, 0);
	final Dimension innerSize = myInnerComponent != null ? myInnerComponent.getMinimumSize() : new Dimension(0, 0);
	if (getOrientation()) {
	int width = Math.max(firstSize.width, Math.max(lastSize.width, innerSize.width));
	int height = visibleDividersCount() * dividerWidth;
	height += firstSize.height;
	height += lastSize.height;
	height += innerSize.height;
	return new Dimension(width, height);
	}
	else {
	int heigth = Math.max(firstSize.height, Math.max(lastSize.height, innerSize.height));
	int width = visibleDividersCount() * dividerWidth;
	width += firstSize.width;
	width += lastSize.width;
	width += innerSize.width;
	return new Dimension(width, heigth);
	}
	}
	return super.getMinimumSize();
	}

	public void doLayout() {
	final int width = getWidth();
	final int height = getHeight();

	Rectangle firstRect = new Rectangle();
	Rectangle firstDividerRect = new Rectangle();
	Rectangle lastDividerRect = new Rectangle();
	Rectangle lastRect = new Rectangle();
	Rectangle innerRect = new Rectangle();
	final int componentSize = getOrientation() ? height : width;
	int dividerWidth = getDividerWidth();
	int dividersCount = visibleDividersCount();

	int firstCompontSize;
	int lastComponentSize;
	int innerComponentSize;
	if(componentSize <= dividersCount * dividerWidth) {
	firstCompontSize = 0;
	lastComponentSize = 0;
	innerComponentSize = 0;
	dividerWidth = componentSize;
	}
	else {
	firstCompontSize = getFirstSize();
	lastComponentSize = getLastSize();
	int sizeLack = firstCompontSize + lastComponentSize - (componentSize - dividersCount * dividerWidth);
	if (sizeLack > 0) {
	// Lacking size. Reduce first component's size, inner -> empty
	firstCompontSize -= sizeLack;
	innerComponentSize = 0;
	}
	else {
	innerComponentSize = componentSize - dividersCount * dividerWidth - getFirstSize() - getLastSize();
	}

	if (!innerVisible()) {
	lastComponentSize += innerComponentSize;
	innerComponentSize = 0;
	if (!lastVisible()) {
	firstCompontSize = componentSize;
	}
	}
	}

	if (getOrientation()) {
	int space = firstCompontSize;
	firstRect.setBounds(0, 0, width, firstCompontSize);
	if (firstDividerVisible()) {
	firstDividerRect.setBounds(0, space, width, dividerWidth);
	space += dividerWidth;
	}

	innerRect.setBounds(0, space, width, innerComponentSize);
	space += innerComponentSize;

	if (lastDividerVisible()) {
	lastDividerRect.setBounds(0, space, width, dividerWidth);
	space += dividerWidth;
	}

	lastRect.setBounds(0, space, width, lastComponentSize);
	}
	else {
	int space = firstCompontSize;
	firstRect.setBounds(0, 0, firstCompontSize, height);

	if (firstDividerVisible()) {
	firstDividerRect.setBounds(space, 0, dividerWidth, height);
	space += dividerWidth;
	}

	innerRect.setBounds(space, 0, innerComponentSize, height);
	space += innerComponentSize;

	if (lastDividerVisible()) {
	lastDividerRect.setBounds(space, 0, dividerWidth, height);
	space += dividerWidth;
	}

	lastRect.setBounds(space, 0, lastComponentSize, height);
	}

	myFirstDivider.setVisible(firstDividerVisible());
	myFirstDivider.setBounds(firstDividerRect);
	myFirstDivider.doLayout();

	myLastDivider.setVisible(lastDividerVisible());
	myLastDivider.setBounds(lastDividerRect);
	myLastDivider.doLayout();

	validateIfNeeded(myFirstComponent, firstRect);
	validateIfNeeded(myInnerComponent, innerRect);
	validateIfNeeded(myLastComponent, lastRect);
	}

	private static void validateIfNeeded(final JComponent c, final Rectangle rect) {
	if (!Splitter.isNull(c)) {
	if (!c.getBounds().equals(rect)) {
	c.setBounds(rect);
	c.revalidate();
	}
	} else {
	Splitter.hideNull(c);
	}
	}


	public int getDividerWidth() {
	return myDividerWidth;
	}

	public void setDividerWidth(int width) {
	if (width < 0) {
	throw new IllegalArgumentException("Wrong divider width: " + width);
	}
	if (myDividerWidth != width) {
	myDividerWidth = width;
	doLayout();
	repaint();
	}
	}

	/**
	* @return <code>true</code> if splitter has vertical orientation, <code>false</code> otherwise
	*/
	public boolean getOrientation() {
	return myVerticalSplit;
	}

	/**
	* @param verticalSplit <code>true</code> means that splitter will have vertical split
	*/
	public void setOrientation(boolean verticalSplit) {
	myVerticalSplit = verticalSplit;
	myFirstDivider.setOrientation(verticalSplit);
	myLastDivider.setOrientation(verticalSplit);
	doLayout();
	repaint();
	}

	@Nullable
	public JComponent getFirstComponent() {
	return myFirstComponent;
	}

	/**
	* Sets component which is located as the "first" splitted area. The method doesn't validate and
	* repaint the splitter. If there is already
	*
	*/
	public void setFirstComponent(@Nullable JComponent component) {
	if (myFirstComponent != component) {
	if (myFirstComponent != null) {
	remove(myFirstComponent);
	}
	myFirstComponent = component;
	if (myFirstComponent != null) {
	add(myFirstComponent);
	myFirstComponent.invalidate();
	}
	}
	}

	@Nullable
	public JComponent getLastComponent() {
	return myLastComponent;
	}


	/**
	* Sets component which is located as the "secont" splitted area. The method doesn't validate and
	* repaint the splitter.
	*
	*/
	public void setLastComponent(@Nullable JComponent component) {
	if (myLastComponent != component) {
	if (myLastComponent != null) {
	remove(myLastComponent);
	}
	myLastComponent = component;
	if (myLastComponent != null) {
	add(myLastComponent);
	myLastComponent.invalidate();
	}
	}
	}

	@Nullable
	public JComponent getInnerComponent() {
	return myInnerComponent;
	}


	/**
	* Sets component which is located as the "inner" splitted area. The method doesn't validate and
	* repaint the splitter.
	*
	*/
	public void setInnerComponent(@Nullable JComponent component) {
	if (myInnerComponent != component) {
	if (myInnerComponent != null) {
	remove(myInnerComponent);
	}
	myInnerComponent = component;
	if (myInnerComponent != null) {
	add(myInnerComponent);
	myInnerComponent.invalidate();
	}
	}
	}

	public void setFirstSize(final int size) {
	myFirstSize = size;
	doLayout();
	repaint();
	}

	public void setLastSize(final int size) {
	myLastSize = size;
	doLayout();
	repaint();
	}

	public int getFirstSize() {
	return firstVisible() ? myFirstSize : 0;
	}

	public int getLastSize() {
	return lastVisible() ? myLastSize : 0;
	}

	@Override
	public void dispose() {
	myLastComponent = null;
	myFirstComponent = null;
	myInnerComponent = null;
	removeAll();
	Container container = getParent();
	if (container != null) {
	container.remove(this);
	}
	}

	private class Divider extends JPanel implements Disposable {
	protected boolean myDragging;
	protected Point myPoint;
	private final boolean myIsFirst;

	private IdeGlassPane myGlassPane;

	private class MyMouseAdapter extends MouseAdapter implements Weighted {
	@Override
	public void mousePressed(MouseEvent e) {
	_processMouseEvent(e);
	}

	@Override
	public void mouseReleased(MouseEvent e) {
	_processMouseEvent(e);
	}

	@Override
	public void mouseMoved(MouseEvent e) {
	_processMouseMotionEvent(e);
	}

	@Override
	public void mouseDragged(MouseEvent e) {
	_processMouseMotionEvent(e);
	}
	@Override
	public double getWeight() {
	return 1;
	}
	private void _processMouseMotionEvent(MouseEvent e) {
	MouseEvent event = getTargetEvent(e);
	if (event == null) {
	myGlassPane.setCursor(null, myListener);
	return;
	}

	processMouseMotionEvent(event);
	if (event.isConsumed()) {
	e.consume();
	}
	}

	private void _processMouseEvent(MouseEvent e) {
	MouseEvent event = getTargetEvent(e);
	if (event == null) {
	myGlassPane.setCursor(null, myListener);
	return;
	}

	processMouseEvent(event);
	if (event.isConsumed()) {
	e.consume();
	}
	}
	}

	private final MouseAdapter myListener = new MyMouseAdapter();


	private MouseEvent getTargetEvent(MouseEvent e) {
	return SwingUtilities.convertMouseEvent(e.getComponent(), e, this);
	}

	private boolean myWasPressedOnMe;

	public Divider(boolean isFirst) {
	super(new GridBagLayout());
	setFocusable(false);
	enableEvents(MouseEvent.MOUSE_EVENT_MASK \| MouseEvent.MOUSE_MOTION_EVENT_MASK);
	myIsFirst = isFirst;
	setOrientation(myVerticalSplit);

	new UiNotifyConnector.Once(this, new Activatable.Adapter() {
	@Override
	public void showNotify() {
	init();
	}
	});
	}

	private boolean isInside(Point p) {
	if (!isVisible()) return false;

	if (myVerticalSplit) {
	if (p.x >= 0 && p.x < getWidth()) {
	if (getHeight() > 0) {
	return p.y >= 0 && p.y < getHeight();
	}
	else {
	return p.y >= -myDividerZone / 2 && p.y <= myDividerZone / 2;
	}
	}
	}
	else {
	if (p.y >= 0 && p.y < getHeight()) {
	if (getWidth() > 0) {
	return p.x >= 0 && p.x < getWidth();
	}
	else {
	return p.x >= -myDividerZone / 2 && p.x <= myDividerZone / 2;
	}
	}
	}

	return false;
	}

	private void init() {
	myGlassPane = IdeGlassPaneUtil.find(this);
	myGlassPane.addMouseMotionPreprocessor(myListener, this);
	myGlassPane.addMousePreprocessor(myListener, this);
	}

	public void dispose() {
	}

	private void setOrientation(boolean isVerticalSplit) {
	removeAll();

	if (!myShowDividerControls) {
	return;
	}

	int xMask = isVerticalSplit ? 1 : 0;
	int yMask = isVerticalSplit ? 0 : 1;

	Icon glueIcon = isVerticalSplit ? AllIcons.General.SplitGlueV : AllIcons.General.SplitCenterH;
	int glueFill = isVerticalSplit ? GridBagConstraints.VERTICAL : GridBagConstraints.HORIZONTAL;
	add(new JLabel(glueIcon),
	new GridBagConstraints(0, 0, 1, 1, 0, 0, isVerticalSplit ? GridBagConstraints.EAST : GridBagConstraints.NORTH, glueFill, new Insets(0, 0, 0, 0), 0, 0));
	JLabel splitDownlabel = new JLabel(isVerticalSplit ? AllIcons.General.SplitDown : AllIcons.General.SplitRight);
	splitDownlabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
	splitDownlabel.setToolTipText(isVerticalSplit ? UIBundle.message("splitter.down.tooltip.text") : UIBundle
	.message("splitter.right.tooltip.text"));
	new ClickListener() {
	@Override
	public boolean onClick(@NotNull MouseEvent e, int clickCount) {
	if (myInnerComponent != null) {
	final int income = myVerticalSplit ? myInnerComponent.getHeight() : myInnerComponent.getWidth();
	if (myIsFirst) {
	setFirstSize(myFirstSize + income);
	}
	else {
	setLastSize(myLastSize + income);
	}
	}
	return true;
	}
	}.installOn(splitDownlabel);

	add(splitDownlabel,
	new GridBagConstraints(isVerticalSplit ? 1 : 0,
	isVerticalSplit ? 0 : 5,
	1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
	//
	add(new JLabel(glueIcon),
	new GridBagConstraints(2 * xMask, 2 * yMask, 1, 1, 0, 0, GridBagConstraints.CENTER, glueFill, new Insets(0, 0, 0, 0), 0, 0));
	JLabel splitCenterlabel = new JLabel(isVerticalSplit ? AllIcons.General.SplitCenterV : AllIcons.General.SplitCenterH);
	splitCenterlabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
	splitCenterlabel.setToolTipText(UIBundle.message("splitter.center.tooltip.text"));
	new ClickListener() {
	@Override
	public boolean onClick(@NotNull MouseEvent e, int clickCount) {
	center();
	return true;
	}
	}.installOn(splitCenterlabel);
	add(splitCenterlabel,
	new GridBagConstraints(3 * xMask, 3 * yMask, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
	add(new JLabel(glueIcon),
	new GridBagConstraints(4 * xMask, 4 * yMask, 1, 1, 0, 0, GridBagConstraints.CENTER, glueFill, new Insets(0, 0, 0, 0), 0, 0));
	//
	JLabel splitUpLabel = new JLabel(isVerticalSplit ? AllIcons.General.SplitUp : AllIcons.General.SplitLeft);
	splitUpLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
	splitUpLabel.setToolTipText(isVerticalSplit ? UIBundle.message("splitter.up.tooltip.text") : UIBundle
	.message("splitter.left.tooltip.text"));
	new ClickListener() {
	@Override
	public boolean onClick(@NotNull MouseEvent e, int clickCount) {
	if (myInnerComponent != null) {
	final int income = myVerticalSplit ? myInnerComponent.getHeight() : myInnerComponent.getWidth();
	if (myIsFirst) {
	setFirstSize(myFirstSize + income);
	}
	else {
	setLastSize(myLastSize + income);
	}
	}
	return true;
	}
	}.installOn(splitUpLabel);

	add(splitUpLabel,
	new GridBagConstraints(isVerticalSplit ? 5 : 0,
	isVerticalSplit ? 0 : 1,
	1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
	add(new JLabel(glueIcon),
	new GridBagConstraints(6 * xMask, 6 * yMask, 1, 1, 0, 0,
	isVerticalSplit ? GridBagConstraints.WEST : GridBagConstraints.SOUTH, glueFill, new Insets(0, 0, 0, 0), 0, 0));
	}

	private void center() {
	if (myInnerComponent != null) {
	final int total = myFirstSize + (myVerticalSplit ? myInnerComponent.getHeight() : myInnerComponent.getWidth());
	if (myIsFirst) {
	setFirstSize(total / 2);
	}
	else {
	setLastSize(total / 2);
	}
	}
	}

	protected void processMouseMotionEvent(MouseEvent e) {
	super.processMouseMotionEvent(e);

	if (!isShowing()) return;

	if (MouseEvent.MOUSE_DRAGGED == e.getID() && myWasPressedOnMe) {
	myDragging = true;
	setCursor(getResizeCursor());
	myGlassPane.setCursor(getResizeCursor(), myListener);

	myPoint = SwingUtilities.convertPoint(this, e.getPoint(), ThreeComponentsSplitter.this);
	if (getOrientation()) {
	if (getHeight() > 0 \|\| myDividerZone > 0) {
	if (myIsFirst) {
	setFirstSize(Math.max(getMinSize(myFirstComponent), myPoint.y));
	}
	else {
	setLastSize(Math.max(getMinSize(myLastComponent), ThreeComponentsSplitter.this.getHeight() - myPoint.y - getDividerWidth()));
	}
	}
	}
	else {
	if (getWidth() > 0 \|\| myDividerZone > 0) {
	if (myIsFirst) {
	setFirstSize(Math.max(getMinSize(myFirstComponent), myPoint.x));
	}
	else {
	setLastSize(Math.max(getMinSize(myLastComponent), ThreeComponentsSplitter.this.getWidth() - myPoint.x - getDividerWidth()));
	}
	}
	}
	ThreeComponentsSplitter.this.doLayout();
	} else if (MouseEvent.MOUSE_MOVED == e.getID()) {
	if (myGlassPane != null) {
	if (isInside(e.getPoint())) {
	myGlassPane.setCursor(getResizeCursor(), myListener);
	e.consume();
	} else {
	myGlassPane.setCursor(null, myListener);
	}
	}
	}

	if (myWasPressedOnMe) {
	e.consume();
	}
	}

	private int getMinSize(JComponent component) {
	if (isHonorMinimumSize()) {
	if (component != null && myFirstComponent != null && myFirstComponent.isVisible() && myLastComponent != null && myLastComponent.isVisible()) {
	if (getOrientation()) {
	return component.getMinimumSize().height;
	}
	else {
	return component.getMinimumSize().width;
	}
	}
	}
	return 0;
	}

	protected void processMouseEvent(MouseEvent e) {
	super.processMouseEvent(e);
	if (!isShowing()) {
	return;
	}
	switch (e.getID()) {
	case MouseEvent.MOUSE_ENTERED:
	setCursor(getResizeCursor());
	break;
	case MouseEvent.MOUSE_EXITED:
	if (!myDragging) {
	setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
	}
	break;
	case MouseEvent.MOUSE_PRESSED:
	if (isInside(e.getPoint())) {
	myWasPressedOnMe = true;
	myGlassPane.setCursor(getResizeCursor(), myListener);
	e.consume();
	} else {
	myWasPressedOnMe = false;
	}
	break;
	case MouseEvent.MOUSE_RELEASED:
	if (myWasPressedOnMe) {
	e.consume();
	}
	if (isInside(e.getPoint())) {
	myGlassPane.setCursor(getResizeCursor(), myListener);
	}
	myWasPressedOnMe = false;
	myDragging = false;
	myPoint = null;
	break;
	case MouseEvent.MOUSE_CLICKED:
	if (e.getClickCount() == 2) {
	center();
	}
	break;
	}
	}
	}

	private Cursor getResizeCursor() {
	return getOrientation() ? Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR) : Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
	}
	}