private static int getAquaTabbedPaneBaseline(JTabbedPane tp, int height) {
Font font = tp.getFont();
FontMetrics metrics = tp.getFontMetrics(font);
int ascent = metrics.getAscent();
int offset;
switch (tp.getTabPlacement()) {
case JTabbedPane.TOP:
offset = 5;
if (tp.getFont().getSize() > 12) {
offset = 6;
}
int yOffset = 20 - metrics.getHeight();
yOffset /= 2;
return offset + yOffset + ascent - 1;
case JTabbedPane.BOTTOM:
if (tp.getFont().getSize() > 12) {
offset = 6;
} else {
offset = 4;
}
return height - (20 - ((20 - metrics.getHeight()) / 2 + ascent)) - offset;
case JTabbedPane.LEFT:
case JTabbedPane.RIGHT:
// Aqua rotates left/right text, so that there isn't a good
// baseline.
return -1;
}
return -1;
}
public void paintComponent(Graphics g) {
g.setColor(new Color(96, 96, 96));
image.paintIcon(this, g, 1, 1);
FontMetrics fm = g.getFontMetrics();
String[] args = {jEdit.getVersion()};
String version = jEdit.getProperty("about.version", args);
g.drawString(version, (getWidth() - fm.stringWidth(version)) / 2, getHeight() - 5);
g = g.create((getWidth() - maxWidth) / 2, TOP, maxWidth, getHeight() - TOP - BOTTOM);
int height = fm.getHeight();
int firstLine = scrollPosition / height;
int firstLineOffset = height - scrollPosition % height;
int lines = (getHeight() - TOP - BOTTOM) / height;
int y = firstLineOffset;
for (int i = 0; i <= lines; i++) {
if (i + firstLine >= 0 && i + firstLine < text.size()) {
String line = (String) text.get(i + firstLine);
g.drawString(line, (maxWidth - fm.stringWidth(line)) / 2, y);
}
y += fm.getHeight();
}
}
public Rectangle getVisualBounds(JComponent c, int type, int width, int height) {
Rectangle bounds = new Rectangle(0, 0, width, height);
if (type == VisuallyLayoutable.CLIP_BOUNDS) {
return bounds;
}
AbstractButton b = (AbstractButton) c;
if (type == VisuallyLayoutable.COMPONENT_BOUNDS
&& b.getBorder() != null
&& b.isBorderPainted()) {
Border border = b.getBorder();
if (border instanceof BackgroundBorder) {
border = ((BackgroundBorder) border).getBackgroundBorder();
if (border instanceof VisualMargin) {
InsetsUtil.subtractInto(((VisualMargin) border).getVisualMargin(c), bounds);
} else if (border instanceof QuaquaButtonBorder) {
InsetsUtil.subtractInto(((QuaquaButtonBorder) border).getVisualMargin(c), bounds);
}
}
return bounds;
}
String text = b.getText();
boolean isEmpty = (text == null || text.length() == 0);
if (isEmpty) {
text = " ";
}
Icon icon = (b.isEnabled()) ? b.getIcon() : b.getDisabledIcon();
if ((icon == null) && (text == null)) {
return null;
}
FontMetrics fm = c.getFontMetrics(c.getFont());
Insets insets = c.getInsets(viewInsets);
viewR.x = insets.left;
viewR.y = insets.top;
viewR.width = width - (insets.left + insets.right);
viewR.height = height - (insets.top + insets.bottom);
iconR.x = iconR.y = iconR.width = iconR.height = 0;
textR.x = textR.y = textR.width = textR.height = 0;
String clippedText = layoutCL(b, fm, text, icon, viewR, iconR, textR);
Rectangle textBounds = Fonts.getPerceivedBounds(text, c.getFont(), c);
if (isEmpty) {
textBounds.width = 0;
}
int ascent = fm.getAscent();
textR.x += textBounds.x;
textR.width = textBounds.width;
textR.y += ascent + textBounds.y;
textR.height -= fm.getHeight() - textBounds.height;
bounds.setBounds(textR);
return bounds;
}
public ColorPane() {
super();
Font font = new Font("Monospaced", Font.PLAIN, 12);
FontMetrics fm = getFontMetrics(font);
lineHeight = fm.getHeight();
setFont(font);
setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
}
private static int getPanelBaseline(JPanel panel, int height) {
Border border = panel.getBorder();
if (border instanceof TitledBorder) {
TitledBorder titledBorder = (TitledBorder) border;
if (titledBorder.getTitle() != null && !"".equals(titledBorder.getTitle())) {
Font font = titledBorder.getTitleFont();
if (font == null) {
font = panel.getFont();
if (font == null) {
font = new Font("Dialog", Font.PLAIN, 12);
}
}
Border border2 = titledBorder.getBorder();
Insets borderInsets;
if (border2 != null) {
borderInsets = border2.getBorderInsets(panel);
} else {
borderInsets = EMPTY_INSETS;
}
FontMetrics fm = panel.getFontMetrics(font);
int fontHeight = fm.getHeight();
int descent = fm.getDescent();
int ascent = fm.getAscent();
int y = EDGE_SPACING;
int h = height - EDGE_SPACING * 2;
int diff;
switch (((TitledBorder) border).getTitlePosition()) {
case TitledBorder.ABOVE_TOP:
diff = ascent + descent + (Math.max(EDGE_SPACING, TEXT_SPACING * 2) - EDGE_SPACING);
return y + diff - (descent + TEXT_SPACING);
case TitledBorder.TOP:
case TitledBorder.DEFAULT_POSITION:
diff = Math.max(0, ((ascent / 2) + TEXT_SPACING) - EDGE_SPACING);
return (y + diff - descent) + (borderInsets.top + ascent + descent) / 2;
case TitledBorder.BELOW_TOP:
return y + borderInsets.top + ascent + TEXT_SPACING;
case TitledBorder.ABOVE_BOTTOM:
return (y + h) - (borderInsets.bottom + descent + TEXT_SPACING);
case TitledBorder.BOTTOM:
h -= fontHeight / 2;
return ((y + h) - descent) + ((ascent + descent) - borderInsets.bottom) / 2;
case TitledBorder.BELOW_BOTTOM:
h -= fontHeight;
return y + h + ascent + TEXT_SPACING;
}
}
}
return -1;
}
public void run() {
FontMetrics fm = getFontMetrics(getFont());
int max = (text.size() * fm.getHeight());
while (running) {
scrollPosition += 2;
if (scrollPosition > max) scrollPosition = -250;
try {
Thread.sleep(100);
} catch (Exception e) {
}
repaint(getWidth() / 2 - maxWidth, TOP, maxWidth * 2, getHeight() - TOP - BOTTOM);
}
}
public Dimension minimumLayoutSize(Container c) {
// Compute width.
int width = 30;
if (frame.isClosable()) {
width += 21;
}
if (frame.isMaximizable()) {
width += 16 + (frame.isClosable() ? 10 : 4);
}
if (frame.isIconifiable()) {
width += 16 + (frame.isMaximizable() ? 2 : (frame.isClosable() ? 10 : 4));
}
FontMetrics fm = frame.getFontMetrics(getFont());
String frameTitle = frame.getTitle();
int title_w = frameTitle != null ? SwingUtilities2.stringWidth(frame, fm, frameTitle) : 0;
int title_length = frameTitle != null ? frameTitle.length() : 0;
if (title_length > 2) {
int subtitle_w =
SwingUtilities2.stringWidth(frame, fm, frame.getTitle().substring(0, 2) + "...");
width += (title_w < subtitle_w) ? title_w : subtitle_w;
} else {
width += title_w;
}
// Compute height.
int height = 0;
if (isPalette) {
height = paletteTitleHeight;
} else {
int fontHeight = fm.getHeight();
fontHeight += 7;
Icon icon = frame.getFrameIcon();
int iconHeight = 0;
if (icon != null) {
// SystemMenuBar forces the icon to be 16x16 or less.
iconHeight = Math.min(icon.getIconHeight(), 16);
}
iconHeight += 5;
height = Math.max(fontHeight, iconHeight);
}
return new Dimension(width, height);
}
/*
* Determine the Y offset for the current row
*/
private int getOffsetY(int rowStartOffset, FontMetrics fontMetrics) throws BadLocationException {
// Get the bounding rectangle of the row
Rectangle r = component.modelToView(rowStartOffset);
int lineHeight = fontMetrics.getHeight();
int y = r.y + r.height;
int descent = 0;
// The text needs to be positioned above the bottom of the bounding
// rectangle based on the descent of the font(s) contained on the row.
if (r.height == lineHeight) {
// default font is being used
descent = fontMetrics.getDescent();
} else {
// We need to check all the attributes for font changes
if (fonts == null) {
fonts = new HashMap<String, FontMetrics>();
}
Element root = component.getDocument().getDefaultRootElement();
int index = root.getElementIndex(rowStartOffset);
Element line = root.getElement(index);
for (int i = 0; i < line.getElementCount(); i++) {
Element child = line.getElement(i);
AttributeSet as = child.getAttributes();
String fontFamily = (String) as.getAttribute(StyleConstants.FontFamily);
Integer fontSize = (Integer) as.getAttribute(StyleConstants.FontSize);
String key = fontFamily + fontSize;
FontMetrics fm = fonts.get(key);
if (fm == null) {
Font font = new Font(fontFamily, Font.PLAIN, fontSize);
fm = component.getFontMetrics(font);
fonts.put(key, fm);
}
descent = Math.max(descent, fm.getDescent());
}
}
return y - descent;
}
public void paintComponent(Graphics g) {
if (isPalette) {
paintPalette(g);
return;
}
boolean leftToRight = MetalUtils.isLeftToRight(frame);
boolean isSelected = frame.isSelected();
int width = getWidth();
int height = getHeight();
Color background = null;
Color foreground = null;
Color shadow = null;
MetalBumps bumps;
String gradientKey;
if (isSelected) {
if (!MetalLookAndFeel.usingOcean()) {
closeButton.setContentAreaFilled(true);
maxButton.setContentAreaFilled(true);
iconButton.setContentAreaFilled(true);
}
if (selectedBackgroundKey != null) {
background = UIManager.getColor(selectedBackgroundKey);
}
if (background == null) {
background = MetalLookAndFeel.getWindowTitleBackground();
}
if (selectedForegroundKey != null) {
foreground = UIManager.getColor(selectedForegroundKey);
}
if (selectedShadowKey != null) {
shadow = UIManager.getColor(selectedShadowKey);
}
if (shadow == null) {
shadow = MetalLookAndFeel.getPrimaryControlDarkShadow();
}
if (foreground == null) {
foreground = MetalLookAndFeel.getWindowTitleForeground();
}
activeBumps.setBumpColors(
activeBumpsHighlight,
activeBumpsShadow,
UIManager.get("InternalFrame.activeTitleGradient") != null ? null : background);
bumps = activeBumps;
gradientKey = "InternalFrame.activeTitleGradient";
} else {
if (!MetalLookAndFeel.usingOcean()) {
closeButton.setContentAreaFilled(false);
maxButton.setContentAreaFilled(false);
iconButton.setContentAreaFilled(false);
}
background = MetalLookAndFeel.getWindowTitleInactiveBackground();
foreground = MetalLookAndFeel.getWindowTitleInactiveForeground();
shadow = MetalLookAndFeel.getControlDarkShadow();
bumps = inactiveBumps;
gradientKey = "InternalFrame.inactiveTitleGradient";
}
if (!MetalUtils.drawGradient(this, g, gradientKey, 0, 0, width, height, true)) {
g.setColor(background);
g.fillRect(0, 0, width, height);
}
g.setColor(shadow);
g.drawLine(0, height - 1, width, height - 1);
g.drawLine(0, 0, 0, 0);
g.drawLine(width - 1, 0, width - 1, 0);
int titleLength = 0;
int xOffset = leftToRight ? 5 : width - 5;
String frameTitle = frame.getTitle();
Icon icon = frame.getFrameIcon();
if (icon != null) {
if (!leftToRight) xOffset -= icon.getIconWidth();
int iconY = ((height / 2) - (icon.getIconHeight() / 2));
icon.paintIcon(frame, g, xOffset, iconY);
xOffset += leftToRight ? icon.getIconWidth() + 5 : -5;
}
if (frameTitle != null) {
Font f = getFont();
g.setFont(f);
FontMetrics fm = SwingUtilities2.getFontMetrics(frame, g, f);
int fHeight = fm.getHeight();
g.setColor(foreground);
int yOffset = ((height - fm.getHeight()) / 2) + fm.getAscent();
Rectangle rect = new Rectangle(0, 0, 0, 0);
if (frame.isIconifiable()) {
rect = iconButton.getBounds();
} else if (frame.isMaximizable()) {
rect = maxButton.getBounds();
} else if (frame.isClosable()) {
rect = closeButton.getBounds();
}
int titleW;
if (leftToRight) {
if (rect.x == 0) {
rect.x = frame.getWidth() - frame.getInsets().right - 2;
}
titleW = rect.x - xOffset - 4;
frameTitle = getTitle(frameTitle, fm, titleW);
} else {
titleW = xOffset - rect.x - rect.width - 4;
frameTitle = getTitle(frameTitle, fm, titleW);
xOffset -= SwingUtilities2.stringWidth(frame, fm, frameTitle);
}
titleLength = SwingUtilities2.stringWidth(frame, fm, frameTitle);
SwingUtilities2.drawString(frame, g, frameTitle, xOffset, yOffset);
xOffset += leftToRight ? titleLength + 5 : -5;
}
int bumpXOffset;
int bumpLength;
if (leftToRight) {
bumpLength = width - buttonsWidth - xOffset - 5;
bumpXOffset = xOffset;
} else {
bumpLength = xOffset - buttonsWidth - 5;
bumpXOffset = buttonsWidth + 5;
}
int bumpYOffset = 3;
int bumpHeight = getHeight() - (2 * bumpYOffset);
bumps.setBumpArea(bumpLength, bumpHeight);
bumps.paintIcon(this, g, bumpXOffset, bumpYOffset);
}
private int getFontHeight() {
return fmRef.getHeight();
}
private static int getSliderBaseline(JSlider slider, int height) {
// We don't handle GTK as too much is hidden to be able to calculate it
if (slider.getPaintLabels() && !isGTK()) {
boolean isAqua = isAqua();
FontMetrics metrics = slider.getFontMetrics(slider.getFont());
Insets insets = slider.getInsets();
Insets focusInsets = (Insets) UIManager.get("Slider.focusInsets");
if (slider.getOrientation() == JSlider.HORIZONTAL) {
int tickLength = 8;
int contentHeight =
height - insets.top - insets.bottom - focusInsets.top - focusInsets.bottom;
int thumbHeight = 20;
if (isMetal()) {
tickLength = ((Integer) UIManager.get("Slider.majorTickLength")).intValue() + 5;
thumbHeight = UIManager.getIcon("Slider.horizontalThumbIcon").getIconHeight();
} else if (isWindows() && isXP()) {
// NOTE: this is not correct, this should come from
// the skin (in >= 1.5), but short of reflection
// hacks we don't have access to the real value.
thumbHeight++;
}
int centerSpacing = thumbHeight;
if (isAqua || slider.getPaintTicks()) {
// centerSpacing += getTickLength();
centerSpacing += tickLength;
}
// Assume uniform labels.
centerSpacing += metrics.getAscent() + metrics.getDescent();
int trackY = insets.top + focusInsets.top + (contentHeight - centerSpacing - 1) / 2;
if (isAqua) {
if (slider.getPaintTicks()) {
int prefHeight = slider.getUI().getPreferredSize(slider).height;
int prefDelta = height - prefHeight;
if (prefDelta > 0) {
trackY -= Math.min(1, prefDelta);
}
} else {
trackY--;
}
}
int trackHeight = thumbHeight;
int tickY = trackY + trackHeight;
int tickHeight = tickLength;
if (!isAqua && !slider.getPaintTicks()) {
tickHeight = 0;
}
int labelY = tickY + tickHeight;
return labelY + metrics.getAscent();
} else { // vertical
boolean inverted = slider.getInverted();
Integer value = inverted ? getMinSliderValue(slider) : getMaxSliderValue(slider);
if (value != null) {
int thumbHeight = 11;
if (isMetal()) {
thumbHeight = UIManager.getIcon("Slider.verticalThumbIcon").getIconHeight();
}
int trackBuffer = Math.max(metrics.getHeight() / 2, thumbHeight / 2);
int contentY = focusInsets.top + insets.top;
int trackY = contentY + trackBuffer;
int trackHeight =
height
- focusInsets.top
- focusInsets.bottom
- insets.top
- insets.bottom
- trackBuffer
- trackBuffer;
int maxValue = getMaxSliderValue(slider).intValue();
int min = slider.getMinimum();
int max = slider.getMaximum();
double valueRange = (double) max - (double) min;
double pixelsPerValue = (double) trackHeight / (double) valueRange;
int trackBottom = trackY + (trackHeight - 1);
if (isAqua) {
trackY -= 3;
trackBottom += 6;
}
int yPosition = trackY;
double offset;
if (!inverted) {
offset = pixelsPerValue * ((double) max - value.intValue());
} else {
offset = pixelsPerValue * ((double) value.intValue() - min);
}
if (isAqua) {
yPosition += Math.floor(offset);
} else {
yPosition += Math.round(offset);
}
yPosition = Math.max(trackY, yPosition);
yPosition = Math.min(trackBottom, yPosition);
if (isAqua) {
return yPosition + metrics.getAscent();
}
return yPosition - metrics.getHeight() / 2 + metrics.getAscent();
}
}
}
return -1;
}
