Java ToolWindowAnchor.RIGHT屬性代碼示例

@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;
  }
}
 

private static Icon getHideToolWindowIcon(ToolWindow toolWindow) {
  ToolWindowAnchor anchor = toolWindow.getAnchor();
  if (anchor == ToolWindowAnchor.BOTTOM) {
    return AllIcons.General.HideDownPart;
  }
  else if (anchor == ToolWindowAnchor.RIGHT) {
    return AllIcons.General.HideRightPart;
  }

  return AllIcons.General.HideLeftPart;
}
 

private static Icon getHideIcon(ToolWindow toolWindow) {
  ToolWindowAnchor anchor = toolWindow.getAnchor();
  if (anchor == ToolWindowAnchor.BOTTOM) {
    return AllIcons.General.HideDown;
  }
  else if (anchor == ToolWindowAnchor.RIGHT) {
    return AllIcons.General.HideRight;
  }

  return AllIcons.General.HideLeft;
}
 

private static Icon getHideToolWindowHoveredIcon(ToolWindow toolWindow) {
  ToolWindowAnchor anchor = toolWindow.getAnchor();
  if (anchor == ToolWindowAnchor.BOTTOM) {
    return AllIcons.General.HideDownPartHover;
  }
  else if (anchor == ToolWindowAnchor.RIGHT) {
    return AllIcons.General.HideRightPartHover;
  }

  return AllIcons.General.HideLeftPartHover;
}
 

private static Icon getHideHoveredIcon(ToolWindow toolWindow) {
  ToolWindowAnchor anchor = toolWindow.getAnchor();
  if (anchor == ToolWindowAnchor.BOTTOM) {
    return AllIcons.General.HideDownHover;
  }
  else if (anchor == ToolWindowAnchor.RIGHT) {
    return AllIcons.General.HideRightHover;
  }

  return AllIcons.General.HideLeftHover;
}
 

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;
  }
}
 

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);
    }
  }
}