Java ToolWindowAnchor.LEFT屬性代碼示例

@Override
public Insets getBorderInsets(Component c) {
  Stripe stripe = (Stripe)c;
  ToolWindowAnchor anchor = stripe.getAnchor();

  Insets result = new Insets(0, 0, 0, 0);
  final int off = UIUtil.isUnderDarcula() ? 1 : 0;
  if (anchor == ToolWindowAnchor.LEFT) {
    result.top = 1;
    result.right = 1 + off;
  }
  else if (anchor == ToolWindowAnchor.RIGHT) {
    result.left = 1 + off;
    result.top = 1;
  }
  else if (anchor == ToolWindowAnchor.TOP) {
    result.bottom = 0;
    //result.bottom = 1;
    result.top = 1;
  }
  else {
    result.top = 1 + off;
  }

  return result;
}
 

@Override
protected void paintComponent(final Graphics g) {
  super.paintComponent(g);
  if (!myFinishingDrop && isDroppingButton() && myDragButton.getParent() != this) {
    g.setColor(getBackground().brighter());
    g.fillRect(0, 0, getWidth(), getHeight());
  }
  if (UIUtil.isUnderDarcula()) return;
  ToolWindowAnchor anchor = getAnchor();
  g.setColor(new Color(255, 255, 255, 40));
  Rectangle r = getBounds();
  if (anchor == ToolWindowAnchor.LEFT || anchor == ToolWindowAnchor.RIGHT) {
    g.drawLine(0, 0, 0, r.height);
    g.drawLine(r.width - 2, 0, r.width - 2, r.height);
  }
  else {
    g.drawLine(0, 1, r.width, 1);
    g.drawLine(0, r.height - 1, r.width, r.height - 1);
  }
}
 

/**
 * Sets (docks) specified component to the specified anchor.
 */
private void setComponent(final JComponent component, final ToolWindowAnchor anchor, final float weight) {
  if (ToolWindowAnchor.TOP == anchor) {
    myVerticalSplitter.setFirstComponent(component);
    myVerticalSplitter.setFirstSize((int)(myLayeredPane.getHeight() * weight));
  }
  else if (ToolWindowAnchor.LEFT == anchor) {
    myHorizontalSplitter.setFirstComponent(component);
    myHorizontalSplitter.setFirstSize((int)(myLayeredPane.getWidth() * weight));
  }
  else if (ToolWindowAnchor.BOTTOM == anchor) {
    myVerticalSplitter.setLastComponent(component);
    myVerticalSplitter.setLastSize((int)(myLayeredPane.getHeight() * weight));
  }
  else if (ToolWindowAnchor.RIGHT == anchor) {
    myHorizontalSplitter.setLastComponent(component);
    myHorizontalSplitter.setLastSize((int)(myLayeredPane.getWidth() * weight));
  }
  else {
    LOG.error("unknown anchor: " + anchor);
  }
}
 

private JComponent getComponentAt(ToolWindowAnchor anchor) {
  if (ToolWindowAnchor.TOP == anchor) {
    return myVerticalSplitter.getFirstComponent();
  }
  else if (ToolWindowAnchor.LEFT == anchor) {
    return myHorizontalSplitter.getFirstComponent();
  }
  else if (ToolWindowAnchor.BOTTOM == anchor) {
    return myVerticalSplitter.getLastComponent();
  }
  else if (ToolWindowAnchor.RIGHT == anchor) {
    return myHorizontalSplitter.getLastComponent();
  }
  else {
    LOG.error("unknown anchor: " + anchor);
    return null;
  }
}
 

@Nullable
Stripe getStripeFor(String id) {
  ToolWindow window = myManager.getToolWindow(id);
  if (window == null) {
    return null;
  }

  final ToolWindowAnchor anchor = myManager.getToolWindow(id).getAnchor();
  if (ToolWindowAnchor.TOP == anchor) {
    return myTopStripe;
  }
  else if (ToolWindowAnchor.BOTTOM == anchor) {
    return myBottomStripe;
  }
  else if (ToolWindowAnchor.LEFT == anchor) {
    return myLeftStripe;
  }
  else if (ToolWindowAnchor.RIGHT == anchor) {
    return myRightStripe;
  }

  throw new IllegalArgumentException("Anchor=" + anchor);
}
 

public final void run() {
  try {
    final ToolWindowAnchor anchor = myInfo.getAnchor();
    if (ToolWindowAnchor.TOP == anchor) {
      myTopStripe.addButton(myButton, myComparator);
    }
    else if (ToolWindowAnchor.LEFT == anchor) {
      myLeftStripe.addButton(myButton, myComparator);
    }
    else if (ToolWindowAnchor.BOTTOM == anchor) {
      myBottomStripe.addButton(myButton, myComparator);
    }
    else if (ToolWindowAnchor.RIGHT == anchor) {
      myRightStripe.addButton(myButton, myComparator);
    }
    else {
      LOG.error("unknown anchor: " + anchor);
    }
    validate();
    repaint();
  }
  finally {
    finish();
  }
}
 

public final void setBoundsInPaletteLayer(final Component component, final ToolWindowAnchor anchor, float weight) {
  if (weight < .0f) {
    weight = WindowInfoImpl.DEFAULT_WEIGHT;
  }
  else if (weight > 1.0f) {
    weight = 1.0f;
  }
  if (ToolWindowAnchor.TOP == anchor) {
    component.setBounds(0, 0, getWidth(), (int)(getHeight() * weight + .5f));
  }
  else if (ToolWindowAnchor.LEFT == anchor) {
    component.setBounds(0, 0, (int)(getWidth() * weight + .5f), getHeight());
  }
  else if (ToolWindowAnchor.BOTTOM == anchor) {
    final int height = (int)(getHeight() * weight + .5f);
    component.setBounds(0, getHeight() - height, getWidth(), height);
  }
  else if (ToolWindowAnchor.RIGHT == anchor) {
    final int width = (int)(getWidth() * weight + .5f);
    component.setBounds(getWidth() - width, 0, width, getHeight());
  }
  else {
    LOG.error("unknown anchor " + anchor);
  }
}
 

private boolean is(boolean first) {
  Container parent = getParent();
  if (parent == null) return false;
  
  int max = first ? Integer.MAX_VALUE : 0;
  ToolWindowAnchor anchor = getAnchor();
  Component c = null;
  int count = parent.getComponentCount();
  for (int i = 0; i < count; i++) {
    Component component = parent.getComponent(i);
    if (!component.isVisible()) continue;
    Rectangle r = component.getBounds();
    if (anchor == ToolWindowAnchor.LEFT || anchor == ToolWindowAnchor.RIGHT) {
      if (first && max > r.y || !first && max < r.y) {
        max = r.y;
        c = component;
      }
    } else {
      if (first && max > r.x || !first && max < r.x) {
        max = r.x;
        c = component;
      }
    }
  }
  
  
  return c == this;
}
 

public Dimension getPreferredSize(final JComponent c){
  final AnchoredButton button=(AnchoredButton)c;
  final Dimension dim=super.getPreferredSize(button);

  dim.width=(int)(JBUI.scale(4) + dim.width*1.1f);
  dim.height+= JBUI.scale(2);

  final ToolWindowAnchor anchor=button.getAnchor();
  if(ToolWindowAnchor.LEFT==anchor||ToolWindowAnchor.RIGHT==anchor){
    return new Dimension(dim.height,dim.width);
  } else{
    return dim;
  }
}
 

public final void runMovement() {
  if (!isShowing()) {
    return;
  }
  final int distance;
  final Rectangle bounds = getBounds();
  if (myAnchor == ToolWindowAnchor.LEFT || myAnchor == ToolWindowAnchor.RIGHT) {
    distance = bounds.width;
  }
  else {
    distance = bounds.height;
  }
  int count = 0;
  myOffset = 0;
  paintImmediately(0, 0, getWidth(), getHeight());//first paint requires more time than next ones
  final long startTime = System.currentTimeMillis();


  while (true) {
    paintImmediately(0, 0, getWidth(), getHeight());
    final long timeSpent = System.currentTimeMillis() - startTime;
    count++;
    if (timeSpent >= myDesiredTimeToComplete) break;
    final double onePaintTime = (double)timeSpent / count;
    int iterations = (int)((myDesiredTimeToComplete - timeSpent) / onePaintTime);
    iterations = Math.max(1, iterations);
    myOffset += (distance - myOffset) / iterations;
  }
}
 

private void stretch(ToolWindow wnd, int value) {
  Pair<Resizer, Component> pair = findResizerAndComponent(wnd);
  if (pair == null) return;

  boolean vertical = wnd.getAnchor() == ToolWindowAnchor.TOP || wnd.getAnchor() == ToolWindowAnchor.BOTTOM;
  int actualSize = (vertical ? pair.second.getHeight() : pair.second.getWidth()) + value;
  boolean first = wnd.getAnchor() == ToolWindowAnchor.LEFT  || wnd.getAnchor() == ToolWindowAnchor.TOP;
  int maxValue = vertical ? myVerticalSplitter.getMaxSize(first) : myHorizontalSplitter.getMaxSize(first);
  int minValue = vertical ? myVerticalSplitter.getMinSize(first) : myHorizontalSplitter.getMinSize(first);;

  pair.first.setSize(Math.max(minValue, Math.min(maxValue, actualSize)));
}
 

public final void paint(final Graphics g) {
  final Rectangle bounds = getBounds();
  if (myAnchor == ToolWindowAnchor.LEFT) {
    if (myDirection == 1) {
      g.setClip(null);
      g.clipRect(myOffset, 0, bounds.width - myOffset, bounds.height);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(0, 0, myOffset, bounds.height);
      UIUtil.drawImage(g, myTopImage, myOffset - bounds.width, 0, null);
    }
    else {
      g.setClip(null);
      g.clipRect(bounds.width - myOffset, 0, myOffset, bounds.height);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(0, 0, bounds.width - myOffset, bounds.height);
      UIUtil.drawImage(g, myTopImage, -myOffset, 0, null);
    }
    myTopImage.flush();
  }
  else if (myAnchor == ToolWindowAnchor.RIGHT) {
    if (myDirection == 1) {
      g.setClip(null);
      g.clipRect(0, 0, bounds.width - myOffset, bounds.height);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(bounds.width - myOffset, 0, myOffset, bounds.height);
      UIUtil.drawImage(g, myTopImage, bounds.width - myOffset, 0, null);
    }
    else {
      g.setClip(null);
      g.clipRect(0, 0, myOffset, bounds.height);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(myOffset, 0, bounds.width - myOffset, bounds.height);
      UIUtil.drawImage(g, myTopImage, myOffset, 0, null);
    }
  }
  else if (myAnchor == ToolWindowAnchor.TOP) {
    if (myDirection == 1) {
      g.setClip(null);
      g.clipRect(0, myOffset, bounds.width, bounds.height - myOffset);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(0, 0, bounds.width, myOffset);
      UIUtil.drawImage(g, myTopImage, 0, -bounds.height + myOffset, null);
    }
    else {
      g.setClip(null);
      g.clipRect(0, bounds.height - myOffset, bounds.width, myOffset);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(0, 0, bounds.width, bounds.height - myOffset);
      UIUtil.drawImage(g, myTopImage, 0, -myOffset, null);
    }
  }
  else if (myAnchor == ToolWindowAnchor.BOTTOM) {
    if (myDirection == 1) {
      g.setClip(null);
      g.clipRect(0, 0, bounds.width, bounds.height - myOffset);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(0, bounds.height - myOffset, bounds.width, myOffset);
      UIUtil.drawImage(g, myTopImage, 0, bounds.height - myOffset, null);
    }
    else {
      g.setClip(null);
      g.clipRect(0, 0, bounds.width, myOffset);
      UIUtil.drawImage(g, myBottomImage, 0, 0, null);
      g.setClip(null);
      g.clipRect(0, myOffset, bounds.width, bounds.height - myOffset);
      UIUtil.drawImage(g, myTopImage, 0, myOffset, null);
    }
  }
}
 

@Nullable
private Pair<Resizer, Component> findResizerAndComponent(ToolWindow wnd) {
  if (!wnd.isVisible()) return null;

  Resizer resizer = null;
  Component cmp = null;

  if (wnd.getType() == ToolWindowType.DOCKED) {
    cmp = getComponentAt(wnd.getAnchor());

    if (cmp != null) {
      if (wnd.getAnchor().isHorizontal()) {
        resizer = myVerticalSplitter.getFirstComponent() == cmp
                  ? new Resizer.Splitter.FirstComponent(myVerticalSplitter)
                  : new Resizer.Splitter.LastComponent(myVerticalSplitter);
      }
      else {
        resizer = myHorizontalSplitter.getFirstComponent() == cmp
                  ? new Resizer.Splitter.FirstComponent(myHorizontalSplitter)
                  : new Resizer.Splitter.LastComponent(myHorizontalSplitter);
      }
    }
  }
  else if (wnd.getType() == ToolWindowType.SLIDING) {
    cmp = wnd.getComponent();
    while (cmp != null) {
      if (cmp.getParent() == myLayeredPane) break;
      cmp = cmp.getParent();
    }

    if (cmp != null) {
      if (wnd.getAnchor() == ToolWindowAnchor.TOP) {
        resizer = new Resizer.LayeredPane.Top(cmp);
      }
      else if (wnd.getAnchor() == ToolWindowAnchor.BOTTOM) {
        resizer = new Resizer.LayeredPane.Bottom(cmp);
      }
      else if (wnd.getAnchor() == ToolWindowAnchor.LEFT) {
        resizer = new Resizer.LayeredPane.Left(cmp);
      }
      else if (wnd.getAnchor() == ToolWindowAnchor.RIGHT) {
        resizer = new Resizer.LayeredPane.Right(cmp);
      }
    }
  }

  return resizer != null ? Pair.create(resizer, cmp) : null;
}
 

@NotNull
@Override
public ToolWindowAnchor getPaletteAnchor() {
  return ToolWindowAnchor.LEFT;
}
 

@Override
protected ToolWindowAnchor getAnchor() {
  return ToolWindowAnchor.LEFT;
}