/*
* Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.java.swing.plaf.gtk;
import sun.swing.SwingUtilities2;
import com.sun.java.swing.plaf.gtk.GTKConstants.ArrowType;
import com.sun.java.swing.plaf.gtk.GTKConstants.ShadowType;
import javax.swing.plaf.ColorUIResource;
import javax.swing.plaf.synth.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.*;
import java.net.*;
import java.security.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.xml.parsers.*;
import org.xml.sax.SAXException;
import org.w3c.dom.*;
/**
*/
class Metacity implements SynthConstants {
// Tutorial:
// http://developer.gnome.org/doc/tutorials/metacity/metacity-themes.html
// Themes:
// http://art.gnome.org/theme_list.php?category=metacity
static Metacity INSTANCE;
private static final String[] themeNames = {
getUserTheme(),
"blueprint",
"Bluecurve",
"Crux",
"SwingFallbackTheme"
};
static {
for (String themeName : themeNames) {
if (themeName != null) {
try {
INSTANCE = new Metacity(themeName);
} catch (FileNotFoundException ex) {
} catch (IOException ex) {
logError(themeName, ex);
} catch (ParserConfigurationException ex) {
logError(themeName, ex);
} catch (SAXException ex) {
logError(themeName, ex);
}
}
if (INSTANCE != null) {
break;
}
}
if (INSTANCE == null) {
throw new Error("Could not find any installed metacity theme, and fallback failed");
}
}
private static boolean errorLogged = false;
private static DocumentBuilder documentBuilder;
private static Document xmlDoc;
private static String userHome;
private Node frame_style_set;
private Map<String, Object> frameGeometry;
private Map<String, Map<String, Object>> frameGeometries;
private LayoutManager titlePaneLayout = new TitlePaneLayout();
private ColorizeImageFilter imageFilter = new ColorizeImageFilter();
private URL themeDir = null;
private SynthContext context;
private String themeName;
private ArithmeticExpressionEvaluator aee = new ArithmeticExpressionEvaluator();
private Map<String, Integer> variables;
// Reusable clip shape object
private RoundRectClipShape roundedClipShape;
protected Metacity(String themeName) throws IOException, ParserConfigurationException, SAXException {
this.themeName = themeName;
themeDir = getThemeDir(themeName);
if (themeDir != null) {
URL themeURL = new URL(themeDir, "metacity-theme-1.xml");
xmlDoc = getXMLDoc(themeURL);
if (xmlDoc == null) {
throw new IOException(themeURL.toString());
}
} else {
throw new FileNotFoundException(themeName);
}
// Initialize constants
variables = new HashMap<String, Integer>();
NodeList nodes = xmlDoc.getElementsByTagName("constant");
int n = nodes.getLength();
for (int i = 0; i < n; i++) {
Node node = nodes.item(i);
String name = getStringAttr(node, "name");
if (name != null) {
String value = getStringAttr(node, "value");
if (value != null) {
try {
variables.put(name, Integer.parseInt(value));
} catch (NumberFormatException ex) {
logError(themeName, ex);
// Ignore bad value
}
}
}
}
// Cache frame geometries
frameGeometries = new HashMap<String, Map<String, Object>>();
nodes = xmlDoc.getElementsByTagName("frame_geometry");
n = nodes.getLength();
for (int i = 0; i < n; i++) {
Node node = nodes.item(i);
String name = getStringAttr(node, "name");
if (name != null) {
HashMap<String, Object> gm = new HashMap<String, Object>();
frameGeometries.put(name, gm);
String parentGM = getStringAttr(node, "parent");
if (parentGM != null) {
gm.putAll(frameGeometries.get(parentGM));
}
gm.put("has_title",
Boolean.valueOf(getBooleanAttr(node, "has_title", true)));
gm.put("rounded_top_left",
Boolean.valueOf(getBooleanAttr(node, "rounded_top_left", false)));
gm.put("rounded_top_right",
Boolean.valueOf(getBooleanAttr(node, "rounded_top_right", false)));
gm.put("rounded_bottom_left",
Boolean.valueOf(getBooleanAttr(node, "rounded_bottom_left", false)));
gm.put("rounded_bottom_right",
Boolean.valueOf(getBooleanAttr(node, "rounded_bottom_right", false)));
NodeList childNodes = node.getChildNodes();
int nc = childNodes.getLength();
for (int j = 0; j < nc; j++) {
Node child = childNodes.item(j);
if (child.getNodeType() == Node.ELEMENT_NODE) {
name = child.getNodeName();
Object value = null;
if ("distance".equals(name)) {
value = Integer.valueOf(getIntAttr(child, "value", 0));
} else if ("border".equals(name)) {
value = new Insets(getIntAttr(child, "top", 0),
getIntAttr(child, "left", 0),
getIntAttr(child, "bottom", 0),
getIntAttr(child, "right", 0));
} else if ("aspect_ratio".equals(name)) {
value = new Float(getFloatAttr(child, "value", 1.0F));
} else {
logError(themeName, "Unknown Metacity frame geometry value type: "+name);
}
String childName = getStringAttr(child, "name");
if (childName != null && value != null) {
gm.put(childName, value);
}
}
}
}
}
frameGeometry = frameGeometries.get("normal");
}
public static LayoutManager getTitlePaneLayout() {
return INSTANCE.titlePaneLayout;
}
private Shape getRoundedClipShape(int x, int y, int w, int h,
int arcw, int arch, int corners) {
if (roundedClipShape == null) {
roundedClipShape = new RoundRectClipShape();
}
roundedClipShape.setRoundedRect(x, y, w, h, arcw, arch, corners);
return roundedClipShape;
}
void paintButtonBackground(SynthContext context, Graphics g, int x, int y, int w, int h) {
updateFrameGeometry(context);
this.context = context;
JButton button = (JButton)context.getComponent();
String buttonName = button.getName();
int buttonState = context.getComponentState();
JComponent titlePane = (JComponent)button.getParent();
Container titlePaneParent = titlePane.getParent();
JInternalFrame jif;
if (titlePaneParent instanceof JInternalFrame) {
jif = (JInternalFrame)titlePaneParent;
} else if (titlePaneParent instanceof JInternalFrame.JDesktopIcon) {
jif = ((JInternalFrame.JDesktopIcon)titlePaneParent).getInternalFrame();
} else {
return;
}
boolean active = jif.isSelected();
button.setOpaque(false);
String state = "normal";
if ((buttonState & PRESSED) != 0) {
state = "pressed";
} else if ((buttonState & MOUSE_OVER) != 0) {
state = "prelight";
}
String function = null;
String location = null;
boolean left_corner = false;
boolean right_corner = false;
if (buttonName == "InternalFrameTitlePane.menuButton") {
function = "menu";
location = "left_left";
left_corner = true;
} else if (buttonName == "InternalFrameTitlePane.iconifyButton") {
function = "minimize";
int nButtons = ((jif.isIconifiable() ? 1 : 0) +
(jif.isMaximizable() ? 1 : 0) +
(jif.isClosable() ? 1 : 0));
right_corner = (nButtons == 1);
switch (nButtons) {
case 1: location = "right_right"; break;
case 2: location = "right_middle"; break;
case 3: location = "right_left"; break;
}
} else if (buttonName == "InternalFrameTitlePane.maximizeButton") {
function = "maximize";
right_corner = !jif.isClosable();
location = jif.isClosable() ? "right_middle" : "right_right";
} else if (buttonName == "InternalFrameTitlePane.closeButton") {
function = "close";
right_corner = true;
location = "right_right";
}
Node frame = getNode(frame_style_set, "frame", new String[] {
"focus", (active ? "yes" : "no"),
"state", (jif.isMaximum() ? "maximized" : "normal")
});
if (function != null && frame != null) {
Node frame_style = getNode("frame_style", new String[] {
"name", getStringAttr(frame, "style")
});
if (frame_style != null) {
Shape oldClip = g.getClip();
if ((right_corner && getBoolean("rounded_top_right", false)) ||
(left_corner && getBoolean("rounded_top_left", false))) {
Point buttonLoc = button.getLocation();
if (right_corner) {
g.setClip(getRoundedClipShape(0, 0, w, h,
12, 12, RoundRectClipShape.TOP_RIGHT));
} else {
g.setClip(getRoundedClipShape(0, 0, w, h,
11, 11, RoundRectClipShape.TOP_LEFT));
}
Rectangle clipBounds = oldClip.getBounds();
g.clipRect(clipBounds.x, clipBounds.y,
clipBounds.width, clipBounds.height);
}
drawButton(frame_style, location+"_background", state, g, w, h, jif);
drawButton(frame_style, function, state, g, w, h, jif);
g.setClip(oldClip);
}
}
}
protected void drawButton(Node frame_style, String function, String state,
Graphics g, int w, int h, JInternalFrame jif) {
Node buttonNode = getNode(frame_style, "button",
new String[] { "function", function, "state", state });
if (buttonNode == null && !state.equals("normal")) {
buttonNode = getNode(frame_style, "button",
new String[] { "function", function, "state", "normal" });
}
if (buttonNode != null) {
Node draw_ops;
String draw_ops_name = getStringAttr(buttonNode, "draw_ops");
if (draw_ops_name != null) {
draw_ops = getNode("draw_ops", new String[] { "name", draw_ops_name });
} else {
draw_ops = getNode(buttonNode, "draw_ops", null);
}
variables.put("width", w);
variables.put("height", h);
draw(draw_ops, g, jif);
}
}
void paintFrameBorder(SynthContext context, Graphics g, int x0, int y0, int width, int height) {
updateFrameGeometry(context);
this.context = context;
JComponent comp = context.getComponent();
JComponent titlePane = findChild(comp, "InternalFrame.northPane");
if (titlePane == null) {
return;
}
JInternalFrame jif = null;
if (comp instanceof JInternalFrame) {
jif = (JInternalFrame)comp;
} else if (comp instanceof JInternalFrame.JDesktopIcon) {
jif = ((JInternalFrame.JDesktopIcon)comp).getInternalFrame();
} else {
assert false : "component is not JInternalFrame or JInternalFrame.JDesktopIcon";
return;
}
boolean active = jif.isSelected();
Font oldFont = g.getFont();
g.setFont(titlePane.getFont());
g.translate(x0, y0);
Rectangle titleRect = calculateTitleArea(jif);
JComponent menuButton = findChild(titlePane, "InternalFrameTitlePane.menuButton");
Icon frameIcon = jif.getFrameIcon();
variables.put("mini_icon_width",
(frameIcon != null) ? frameIcon.getIconWidth() : 0);
variables.put("mini_icon_height",
(frameIcon != null) ? frameIcon.getIconHeight() : 0);
variables.put("title_width", calculateTitleTextWidth(g, jif));
FontMetrics fm = SwingUtilities2.getFontMetrics(jif, g);
variables.put("title_height", fm.getAscent() + fm.getDescent());
// These don't seem to apply here, but the Galaxy theme uses them. Not sure why.
variables.put("icon_width", 32);
variables.put("icon_height", 32);
if (frame_style_set != null) {
Node frame = getNode(frame_style_set, "frame", new String[] {
"focus", (active ? "yes" : "no"),
"state", (jif.isMaximum() ? "maximized" : "normal")
});
if (frame != null) {
Node frame_style = getNode("frame_style", new String[] {
"name", getStringAttr(frame, "style")
});
if (frame_style != null) {
Shape oldClip = g.getClip();
boolean roundTopLeft = getBoolean("rounded_top_left", false);
boolean roundTopRight = getBoolean("rounded_top_right", false);
boolean roundBottomLeft = getBoolean("rounded_bottom_left", false);
boolean roundBottomRight = getBoolean("rounded_bottom_right", false);
if (roundTopLeft || roundTopRight || roundBottomLeft || roundBottomRight) {
jif.setOpaque(false);
g.setClip(getRoundedClipShape(0, 0, width, height, 12, 12,
(roundTopLeft ? RoundRectClipShape.TOP_LEFT : 0) |
(roundTopRight ? RoundRectClipShape.TOP_RIGHT : 0) |
(roundBottomLeft ? RoundRectClipShape.BOTTOM_LEFT : 0) |
(roundBottomRight ? RoundRectClipShape.BOTTOM_RIGHT : 0)));
}
Rectangle clipBounds = oldClip.getBounds();
g.clipRect(clipBounds.x, clipBounds.y,
clipBounds.width, clipBounds.height);
int titleHeight = titlePane.getHeight();
boolean minimized = jif.isIcon();
Insets insets = getBorderInsets(context, null);
int leftTitlebarEdge = getInt("left_titlebar_edge");
int rightTitlebarEdge = getInt("right_titlebar_edge");
int topTitlebarEdge = getInt("top_titlebar_edge");
int bottomTitlebarEdge = getInt("bottom_titlebar_edge");
if (!minimized) {
drawPiece(frame_style, g, "entire_background",
0, 0, width, height, jif);
}
drawPiece(frame_style, g, "titlebar",
0, 0, width, titleHeight, jif);
drawPiece(frame_style, g, "titlebar_middle",
leftTitlebarEdge, topTitlebarEdge,
width - leftTitlebarEdge - rightTitlebarEdge,
titleHeight - topTitlebarEdge - bottomTitlebarEdge,
jif);
drawPiece(frame_style, g, "left_titlebar_edge",
0, 0, leftTitlebarEdge, titleHeight, jif);
drawPiece(frame_style, g, "right_titlebar_edge",
width - rightTitlebarEdge, 0,
rightTitlebarEdge, titleHeight, jif);
drawPiece(frame_style, g, "top_titlebar_edge",
0, 0, width, topTitlebarEdge, jif);
drawPiece(frame_style, g, "bottom_titlebar_edge",
0, titleHeight - bottomTitlebarEdge,
width, bottomTitlebarEdge, jif);
drawPiece(frame_style, g, "title",
titleRect.x, titleRect.y, titleRect.width, titleRect.height, jif);
if (!minimized) {
drawPiece(frame_style, g, "left_edge",
0, titleHeight, insets.left, height-titleHeight, jif);
drawPiece(frame_style, g, "right_edge",
width-insets.right, titleHeight, insets.right, height-titleHeight, jif);
drawPiece(frame_style, g, "bottom_edge",
0, height - insets.bottom, width, insets.bottom, jif);
drawPiece(frame_style, g, "overlay",
0, 0, width, height, jif);
}
g.setClip(oldClip);
}
}
}
g.translate(-x0, -y0);
g.setFont(oldFont);
}
private static class Privileged implements PrivilegedAction<Object> {
private static int GET_THEME_DIR = 0;
private static int GET_USER_THEME = 1;
private static int GET_IMAGE = 2;
private int type;
private Object arg;
public Object doPrivileged(int type, Object arg) {
this.type = type;
this.arg = arg;
return AccessController.doPrivileged(this);
}
public Object run() {
if (type == GET_THEME_DIR) {
String sep = File.separator;
String[] dirs = new String[] {
userHome + sep + ".themes",
System.getProperty("swing.metacitythemedir"),
"/usr/X11R6/share/themes",
"/usr/X11R6/share/gnome/themes",
"/usr/local/share/themes",
"/usr/local/share/gnome/themes",
"/usr/share/themes",
"/usr/gnome/share/themes", // Debian/Redhat/Solaris
"/opt/gnome2/share/themes" // SuSE
};
URL themeDir = null;
for (int i = 0; i < dirs.length; i++) {
// System property may not be set so skip null directories.
if (dirs[i] == null) {
continue;
}
File dir =
new File(dirs[i] + sep + arg + sep + "metacity-1");
if (new File(dir, "metacity-theme-1.xml").canRead()) {
try {
themeDir = dir.toURI().toURL();
} catch (MalformedURLException ex) {
themeDir = null;
}
break;
}
}
if (themeDir == null) {
String filename = "resources/metacity/" + arg +
"/metacity-1/metacity-theme-1.xml";
URL url = getClass().getResource(filename);
if (url != null) {
String str = url.toString();
try {
themeDir = new URL(str.substring(0, str.lastIndexOf('/'))+"/");
} catch (MalformedURLException ex) {
themeDir = null;
}
}
}
return themeDir;
} else if (type == GET_USER_THEME) {
try {
// Set userHome here because we need the privilege
userHome = System.getProperty("user.home");
String theme = System.getProperty("swing.metacitythemename");
if (theme != null) {
return theme;
}
// Note: this is a small file (< 1024 bytes) so it's not worth
// starting an XML parser or even to use a buffered reader.
URL url = new URL(new File(userHome).toURI().toURL(),
".gconf/apps/metacity/general/%25gconf.xml");
// Pending: verify character encoding spec for gconf
Reader reader = new InputStreamReader(url.openStream(), "ISO-8859-1");
char[] buf = new char[1024];
StringBuffer strBuf = new StringBuffer();
int n;
while ((n = reader.read(buf)) >= 0) {
strBuf.append(buf, 0, n);
}
reader.close();
String str = strBuf.toString();
if (str != null) {
String strLowerCase = str.toLowerCase();
int i = strLowerCase.indexOf("<entry name=\"theme\"");
if (i >= 0) {
i = strLowerCase.indexOf("<stringvalue>", i);
if (i > 0) {
i += "<stringvalue>".length();
int i2 = str.indexOf("<", i);
return str.substring(i, i2);
}
}
}
} catch (MalformedURLException ex) {
// OK to just ignore. We'll use a fallback theme.
} catch (IOException ex) {
// OK to just ignore. We'll use a fallback theme.
}
return null;
} else if (type == GET_IMAGE) {
return new ImageIcon((URL)arg).getImage();
} else {
return null;
}
}
}
private static URL getThemeDir(String themeName) {
return (URL)new Privileged().doPrivileged(Privileged.GET_THEME_DIR, themeName);
}
private static String getUserTheme() {
return (String)new Privileged().doPrivileged(Privileged.GET_USER_THEME, null);
}
protected void tileImage(Graphics g, Image image, int x0, int y0, int w, int h, float[] alphas) {
Graphics2D g2 = (Graphics2D)g;
Composite oldComp = g2.getComposite();
int sw = image.getWidth(null);
int sh = image.getHeight(null);
int y = y0;
while (y < y0 + h) {
sh = Math.min(sh, y0 + h - y);
int x = x0;
while (x < x0 + w) {
float f = (alphas.length - 1.0F) * x / (x0 + w);
int i = (int)f;
f -= (int)f;
float alpha = (1-f) * alphas[i];
if (i+1 < alphas.length) {
alpha += f * alphas[i+1];
}
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
int swm = Math.min(sw, x0 + w - x);
g.drawImage(image, x, y, x+swm, y+sh, 0, 0, swm, sh, null);
x += swm;
}
y += sh;
}
g2.setComposite(oldComp);
}
private HashMap<String, Image> images = new HashMap<String, Image>();
protected Image getImage(String key, Color c) {
Image image = images.get(key+"-"+c.getRGB());
if (image == null) {
image = imageFilter.colorize(getImage(key), c);
if (image != null) {
images.put(key+"-"+c.getRGB(), image);
}
}
return image;
}
protected Image getImage(String key) {
Image image = images.get(key);
if (image == null) {
if (themeDir != null) {
try {
URL url = new URL(themeDir, key);
image = (Image)new Privileged().doPrivileged(Privileged.GET_IMAGE, url);
} catch (MalformedURLException ex) {
//log("Bad image url: "+ themeDir + "/" + key);
}
}
if (image != null) {
images.put(key, image);
}
}
return image;
}
private class ColorizeImageFilter extends RGBImageFilter {
double cr, cg, cb;
public ColorizeImageFilter() {
canFilterIndexColorModel = true;
}
public void setColor(Color color) {
cr = color.getRed() / 255.0;
cg = color.getGreen() / 255.0;
cb = color.getBlue() / 255.0;
}
public Image colorize(Image fromImage, Color c) {
setColor(c);
ImageProducer producer = new FilteredImageSource(fromImage.getSource(), this);
return new ImageIcon(context.getComponent().createImage(producer)).getImage();
}
public int filterRGB(int x, int y, int rgb) {
// Assume all rgb values are shades of gray
double grayLevel = 2 * (rgb & 0xff) / 255.0;
double r, g, b;
if (grayLevel <= 1.0) {
r = cr * grayLevel;
g = cg * grayLevel;
b = cb * grayLevel;
} else {
grayLevel -= 1.0;
r = cr + (1.0 - cr) * grayLevel;
g = cg + (1.0 - cg) * grayLevel;
b = cb + (1.0 - cb) * grayLevel;
}
return ((rgb & 0xff000000) +
(((int)(r * 255)) << 16) +
(((int)(g * 255)) << 8) +
(int)(b * 255));
}
}
protected static JComponent findChild(JComponent parent, String name) {
int n = parent.getComponentCount();
for (int i = 0; i < n; i++) {
JComponent c = (JComponent)parent.getComponent(i);
if (name.equals(c.getName())) {
return c;
}
}
return null;
}
protected class TitlePaneLayout implements LayoutManager {
public void addLayoutComponent(String name, Component c) {}
public void removeLayoutComponent(Component c) {}
public Dimension preferredLayoutSize(Container c) {
return minimumLayoutSize(c);
}
public Dimension minimumLayoutSize(Container c) {
JComponent titlePane = (JComponent)c;
Container titlePaneParent = titlePane.getParent();
JInternalFrame frame;
if (titlePaneParent instanceof JInternalFrame) {
frame = (JInternalFrame)titlePaneParent;
} else if (titlePaneParent instanceof JInternalFrame.JDesktopIcon) {
frame = ((JInternalFrame.JDesktopIcon)titlePaneParent).getInternalFrame();
} else {
return null;
}
Dimension buttonDim = calculateButtonSize(titlePane);
Insets title_border = (Insets)getFrameGeometry().get("title_border");
Insets button_border = (Insets)getFrameGeometry().get("button_border");
// Calculate width.
int width = getInt("left_titlebar_edge") + buttonDim.width + getInt("right_titlebar_edge");
if (title_border != null) {
width += title_border.left + title_border.right;
}
if (frame.isClosable()) {
width += buttonDim.width;
}
if (frame.isMaximizable()) {
width += buttonDim.width;
}
if (frame.isIconifiable()) {
width += buttonDim.width;
}
FontMetrics fm = frame.getFontMetrics(titlePane.getFont());
String frameTitle = frame.getTitle();
int title_w = frameTitle != null ? SwingUtilities2.stringWidth(
frame, fm, frameTitle) : 0;
int title_length = frameTitle != null ? frameTitle.length() : 0;
// Leave room for three characters in the title.
if (title_length > 3) {
int subtitle_w = SwingUtilities2.stringWidth(
frame, fm, frameTitle.substring(0, 3) + "...");
width += (title_w < subtitle_w) ? title_w : subtitle_w;
} else {
width += title_w;
}
// Calculate height.
int titleHeight = fm.getHeight() + getInt("title_vertical_pad");
if (title_border != null) {
titleHeight += title_border.top + title_border.bottom;
}
int buttonHeight = buttonDim.height;
if (button_border != null) {
buttonHeight += button_border.top + button_border.bottom;
}
int height = Math.max(buttonHeight, titleHeight);
return new Dimension(width, height);
}
public void layoutContainer(Container c) {
JComponent titlePane = (JComponent)c;
Container titlePaneParent = titlePane.getParent();
JInternalFrame frame;
if (titlePaneParent instanceof JInternalFrame) {
frame = (JInternalFrame)titlePaneParent;
} else if (titlePaneParent instanceof JInternalFrame.JDesktopIcon) {
frame = ((JInternalFrame.JDesktopIcon)titlePaneParent).getInternalFrame();
} else {
return;
}
Map gm = getFrameGeometry();
int w = titlePane.getWidth();
int h = titlePane.getHeight();
JComponent menuButton = findChild(titlePane, "InternalFrameTitlePane.menuButton");
JComponent minimizeButton = findChild(titlePane, "InternalFrameTitlePane.iconifyButton");
JComponent maximizeButton = findChild(titlePane, "InternalFrameTitlePane.maximizeButton");
JComponent closeButton = findChild(titlePane, "InternalFrameTitlePane.closeButton");
Insets button_border = (Insets)gm.get("button_border");
Dimension buttonDim = calculateButtonSize(titlePane);
int y = (button_border != null) ? button_border.top : 0;
if (titlePaneParent.getComponentOrientation().isLeftToRight()) {
int x = getInt("left_titlebar_edge");
menuButton.setBounds(x, y, buttonDim.width, buttonDim.height);
x = w - buttonDim.width - getInt("right_titlebar_edge");
if (button_border != null) {
x -= button_border.right;
}
if (frame.isClosable()) {
closeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
x -= buttonDim.width;
}
if (frame.isMaximizable()) {
maximizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
x -= buttonDim.width;
}
if (frame.isIconifiable()) {
minimizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
}
} else {
int x = w - buttonDim.width - getInt("right_titlebar_edge");
menuButton.setBounds(x, y, buttonDim.width, buttonDim.height);
x = getInt("left_titlebar_edge");
if (button_border != null) {
x += button_border.left;
}
if (frame.isClosable()) {
closeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
x += buttonDim.width;
}
if (frame.isMaximizable()) {
maximizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
x += buttonDim.width;
}
if (frame.isIconifiable()) {
minimizeButton.setBounds(x, y, buttonDim.width, buttonDim.height);
}
}
}
} // end TitlePaneLayout
protected Map getFrameGeometry() {
return frameGeometry;
}
protected void setFrameGeometry(JComponent titlePane, Map gm) {
this.frameGeometry = gm;
if (getInt("top_height") == 0 && titlePane != null) {
gm.put("top_height", Integer.valueOf(titlePane.getHeight()));
}
}
protected int getInt(String key) {
Integer i = (Integer)frameGeometry.get(key);
if (i == null) {
i = variables.get(key);
}
return (i != null) ? i.intValue() : 0;
}
protected boolean getBoolean(String key, boolean fallback) {
Boolean b = (Boolean)frameGeometry.get(key);
return (b != null) ? b.booleanValue() : fallback;
}
protected void drawArc(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
Color color = parseColor(getStringAttr(attrs, "color"));
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
int start_angle = aee.evaluate(getStringAttr(attrs, "start_angle"));
int extent_angle = aee.evaluate(getStringAttr(attrs, "extent_angle"));
boolean filled = getBooleanAttr(node, "filled", false);
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
g.setColor(color);
if (filled) {
g.fillArc(x, y, w, h, start_angle, extent_angle);
} else {
g.drawArc(x, y, w, h, start_angle, extent_angle);
}
}
protected void drawLine(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
Color color = parseColor(getStringAttr(attrs, "color"));
int x1 = aee.evaluate(getStringAttr(attrs, "x1"));
int y1 = aee.evaluate(getStringAttr(attrs, "y1"));
int x2 = aee.evaluate(getStringAttr(attrs, "x2"));
int y2 = aee.evaluate(getStringAttr(attrs, "y2"));
int lineWidth = aee.evaluate(getStringAttr(attrs, "width"), 1);
g.setColor(color);
if (lineWidth != 1) {
Graphics2D g2d = (Graphics2D)g;
Stroke stroke = g2d.getStroke();
g2d.setStroke(new BasicStroke((float)lineWidth));
g2d.drawLine(x1, y1, x2, y2);
g2d.setStroke(stroke);
} else {
g.drawLine(x1, y1, x2, y2);
}
}
protected void drawRectangle(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
Color color = parseColor(getStringAttr(attrs, "color"));
boolean filled = getBooleanAttr(node, "filled", false);
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
g.setColor(color);
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
if (filled) {
g.fillRect(x, y, w, h);
} else {
g.drawRect(x, y, w, h);
}
}
protected void drawTile(Node node, Graphics g, JInternalFrame jif) {
NamedNodeMap attrs = node.getAttributes();
int x0 = aee.evaluate(getStringAttr(attrs, "x"));
int y0 = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
int tw = aee.evaluate(getStringAttr(attrs, "tile_width"));
int th = aee.evaluate(getStringAttr(attrs, "tile_height"));
int width = getInt("width");
int height = getInt("height");
if (width == -1) {
x0 -= w;
}
if (height == -1) {
y0 -= h;
}
Shape oldClip = g.getClip();
if (g instanceof Graphics2D) {
((Graphics2D)g).clip(new Rectangle(x0, y0, w, h));
}
variables.put("width", tw);
variables.put("height", th);
Node draw_ops = getNode("draw_ops", new String[] { "name", getStringAttr(node, "name") });
int y = y0;
while (y < y0 + h) {
int x = x0;
while (x < x0 + w) {
g.translate(x, y);
draw(draw_ops, g, jif);
g.translate(-x, -y);
x += tw;
}
y += th;
}
variables.put("width", width);
variables.put("height", height);
g.setClip(oldClip);
}
protected void drawTint(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
Color color = parseColor(getStringAttr(attrs, "color"));
float alpha = Float.parseFloat(getStringAttr(attrs, "alpha"));
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D)g;
Composite oldComp = g2.getComposite();
AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
g2.setComposite(ac);
g2.setColor(color);
g2.fillRect(x, y, w, h);
g2.setComposite(oldComp);
}
}
protected void drawTitle(Node node, Graphics g, JInternalFrame jif) {
NamedNodeMap attrs = node.getAttributes();
String colorStr = getStringAttr(attrs, "color");
int i = colorStr.indexOf("gtk:fg[");
if (i > 0) {
colorStr = colorStr.substring(0, i) + "gtk:text[" + colorStr.substring(i+7);
}
Color color = parseColor(colorStr);
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
String title = jif.getTitle();
if (title != null) {
FontMetrics fm = SwingUtilities2.getFontMetrics(jif, g);
title = SwingUtilities2.clipStringIfNecessary(jif, fm, title,
calculateTitleArea(jif).width);
g.setColor(color);
SwingUtilities2.drawString(jif, g, title, x, y + fm.getAscent());
}
}
protected Dimension calculateButtonSize(JComponent titlePane) {
int buttonHeight = getInt("button_height");
if (buttonHeight == 0) {
buttonHeight = titlePane.getHeight();
if (buttonHeight == 0) {
buttonHeight = 13;
} else {
Insets button_border = (Insets)frameGeometry.get("button_border");
if (button_border != null) {
buttonHeight -= (button_border.top + button_border.bottom);
}
}
}
int buttonWidth = getInt("button_width");
if (buttonWidth == 0) {
buttonWidth = buttonHeight;
Float aspect_ratio = (Float)frameGeometry.get("aspect_ratio");
if (aspect_ratio != null) {
buttonWidth = (int)(buttonHeight / aspect_ratio.floatValue());
}
}
return new Dimension(buttonWidth, buttonHeight);
}
protected Rectangle calculateTitleArea(JInternalFrame jif) {
JComponent titlePane = findChild(jif, "InternalFrame.northPane");
Dimension buttonDim = calculateButtonSize(titlePane);
Insets title_border = (Insets)frameGeometry.get("title_border");
Insets button_border = (Insets)getFrameGeometry().get("button_border");
Rectangle r = new Rectangle();
r.x = getInt("left_titlebar_edge");
r.y = 0;
r.height = titlePane.getHeight();
if (title_border != null) {
r.x += title_border.left;
r.y += title_border.top;
r.height -= (title_border.top + title_border.bottom);
}
if (titlePane.getParent().getComponentOrientation().isLeftToRight()) {
r.x += buttonDim.width;
if (button_border != null) {
r.x += button_border.left;
}
r.width = titlePane.getWidth() - r.x - getInt("right_titlebar_edge");
if (jif.isClosable()) {
r.width -= buttonDim.width;
}
if (jif.isMaximizable()) {
r.width -= buttonDim.width;
}
if (jif.isIconifiable()) {
r.width -= buttonDim.width;
}
} else {
if (jif.isClosable()) {
r.x += buttonDim.width;
}
if (jif.isMaximizable()) {
r.x += buttonDim.width;
}
if (jif.isIconifiable()) {
r.x += buttonDim.width;
}
r.width = titlePane.getWidth() - r.x - getInt("right_titlebar_edge")
- buttonDim.width;
if (button_border != null) {
r.x -= button_border.right;
}
}
if (title_border != null) {
r.width -= title_border.right;
}
return r;
}
protected int calculateTitleTextWidth(Graphics g, JInternalFrame jif) {
String title = jif.getTitle();
if (title != null) {
Rectangle r = calculateTitleArea(jif);
return Math.min(SwingUtilities2.stringWidth(jif,
SwingUtilities2.getFontMetrics(jif, g), title), r.width);
}
return 0;
}
protected void setClip(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
if (g instanceof Graphics2D) {
((Graphics2D)g).clip(new Rectangle(x, y, w, h));
}
}
protected void drawGTKArrow(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
String arrow = getStringAttr(attrs, "arrow");
String shadow = getStringAttr(attrs, "shadow");
String stateStr = getStringAttr(attrs, "state").toUpperCase();
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
int state = -1;
if ("NORMAL".equals(stateStr)) {
state = ENABLED;
} else if ("SELECTED".equals(stateStr)) {
state = SELECTED;
} else if ("INSENSITIVE".equals(stateStr)) {
state = DISABLED;
} else if ("PRELIGHT".equals(stateStr)) {
state = MOUSE_OVER;
}
ShadowType shadowType = null;
if ("in".equals(shadow)) {
shadowType = ShadowType.IN;
} else if ("out".equals(shadow)) {
shadowType = ShadowType.OUT;
} else if ("etched_in".equals(shadow)) {
shadowType = ShadowType.ETCHED_IN;
} else if ("etched_out".equals(shadow)) {
shadowType = ShadowType.ETCHED_OUT;
} else if ("none".equals(shadow)) {
shadowType = ShadowType.NONE;
}
ArrowType direction = null;
if ("up".equals(arrow)) {
direction = ArrowType.UP;
} else if ("down".equals(arrow)) {
direction = ArrowType.DOWN;
} else if ("left".equals(arrow)) {
direction = ArrowType.LEFT;
} else if ("right".equals(arrow)) {
direction = ArrowType.RIGHT;
}
GTKPainter.INSTANCE.paintMetacityElement(context, g, state,
"metacity-arrow", x, y, w, h, shadowType, direction);
}
protected void drawGTKBox(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
String shadow = getStringAttr(attrs, "shadow");
String stateStr = getStringAttr(attrs, "state").toUpperCase();
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
int state = -1;
if ("NORMAL".equals(stateStr)) {
state = ENABLED;
} else if ("SELECTED".equals(stateStr)) {
state = SELECTED;
} else if ("INSENSITIVE".equals(stateStr)) {
state = DISABLED;
} else if ("PRELIGHT".equals(stateStr)) {
state = MOUSE_OVER;
}
ShadowType shadowType = null;
if ("in".equals(shadow)) {
shadowType = ShadowType.IN;
} else if ("out".equals(shadow)) {
shadowType = ShadowType.OUT;
} else if ("etched_in".equals(shadow)) {
shadowType = ShadowType.ETCHED_IN;
} else if ("etched_out".equals(shadow)) {
shadowType = ShadowType.ETCHED_OUT;
} else if ("none".equals(shadow)) {
shadowType = ShadowType.NONE;
}
GTKPainter.INSTANCE.paintMetacityElement(context, g, state,
"metacity-box", x, y, w, h, shadowType, null);
}
protected void drawGTKVLine(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
String stateStr = getStringAttr(attrs, "state").toUpperCase();
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y1 = aee.evaluate(getStringAttr(attrs, "y1"));
int y2 = aee.evaluate(getStringAttr(attrs, "y2"));
int state = -1;
if ("NORMAL".equals(stateStr)) {
state = ENABLED;
} else if ("SELECTED".equals(stateStr)) {
state = SELECTED;
} else if ("INSENSITIVE".equals(stateStr)) {
state = DISABLED;
} else if ("PRELIGHT".equals(stateStr)) {
state = MOUSE_OVER;
}
GTKPainter.INSTANCE.paintMetacityElement(context, g, state,
"metacity-vline", x, y1, 1, y2 - y1, null, null);
}
protected void drawGradient(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
String type = getStringAttr(attrs, "type");
float alpha = getFloatAttr(node, "alpha", -1F);
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
// Get colors from child nodes
Node[] colorNodes = getNodesByName(node, "color");
Color[] colors = new Color[colorNodes.length];
for (int i = 0; i < colorNodes.length; i++) {
colors[i] = parseColor(getStringAttr(colorNodes[i], "value"));
}
boolean horizontal = ("diagonal".equals(type) || "horizontal".equals(type));
boolean vertical = ("diagonal".equals(type) || "vertical".equals(type));
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D)g;
Composite oldComp = g2.getComposite();
if (alpha >= 0F) {
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
}
int n = colors.length - 1;
for (int i = 0; i < n; i++) {
g2.setPaint(new GradientPaint(x + (horizontal ? (i*w/n) : 0),
y + (vertical ? (i*h/n) : 0),
colors[i],
x + (horizontal ? ((i+1)*w/n) : 0),
y + (vertical ? ((i+1)*h/n) : 0),
colors[i+1]));
g2.fillRect(x + (horizontal ? (i*w/n) : 0),
y + (vertical ? (i*h/n) : 0),
(horizontal ? (w/n) : w),
(vertical ? (h/n) : h));
}
g2.setComposite(oldComp);
}
}
protected void drawImage(Node node, Graphics g) {
NamedNodeMap attrs = node.getAttributes();
String filename = getStringAttr(attrs, "filename");
String colorizeStr = getStringAttr(attrs, "colorize");
Color colorize = (colorizeStr != null) ? parseColor(colorizeStr) : null;
String alpha = getStringAttr(attrs, "alpha");
Image object = (colorize != null) ? getImage(filename, colorize) : getImage(filename);
variables.put("object_width", object.getWidth(null));
variables.put("object_height", object.getHeight(null));
String fill_type = getStringAttr(attrs, "fill_type");
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
if (alpha != null) {
if ("tile".equals(fill_type)) {
StringTokenizer tokenizer = new StringTokenizer(alpha, ":");
float[] alphas = new float[tokenizer.countTokens()];
for (int i = 0; i < alphas.length; i++) {
alphas[i] = Float.parseFloat(tokenizer.nextToken());
}
tileImage(g, object, x, y, w, h, alphas);
} else {
float a = Float.parseFloat(alpha);
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D)g;
Composite oldComp = g2.getComposite();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, a));
g2.drawImage(object, x, y, w, h, null);
g2.setComposite(oldComp);
}
}
} else {
g.drawImage(object, x, y, w, h, null);
}
}
protected void drawIcon(Node node, Graphics g, JInternalFrame jif) {
Icon icon = jif.getFrameIcon();
if (icon == null) {
return;
}
NamedNodeMap attrs = node.getAttributes();
String alpha = getStringAttr(attrs, "alpha");
int x = aee.evaluate(getStringAttr(attrs, "x"));
int y = aee.evaluate(getStringAttr(attrs, "y"));
int w = aee.evaluate(getStringAttr(attrs, "width"));
int h = aee.evaluate(getStringAttr(attrs, "height"));
if (getInt("width") == -1) {
x -= w;
}
if (getInt("height") == -1) {
y -= h;
}
if (alpha != null) {
float a = Float.parseFloat(alpha);
if (g instanceof Graphics2D) {
Graphics2D g2 = (Graphics2D)g;
Composite oldComp = g2.getComposite();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, a));
icon.paintIcon(jif, g, x, y);
g2.setComposite(oldComp);
}
} else {
icon.paintIcon(jif, g, x, y);
}
}
protected void drawInclude(Node node, Graphics g, JInternalFrame jif) {
int oldWidth = getInt("width");
int oldHeight = getInt("height");
NamedNodeMap attrs = node.getAttributes();
int x = aee.evaluate(getStringAttr(attrs, "x"), 0);
int y = aee.evaluate(getStringAttr(attrs, "y"), 0);
int w = aee.evaluate(getStringAttr(attrs, "width"), -1);
int h = aee.evaluate(getStringAttr(attrs, "height"), -1);
if (w != -1) {
variables.put("width", w);
}
if (h != -1) {
variables.put("height", h);
}
Node draw_ops = getNode("draw_ops", new String[] {
"name", getStringAttr(node, "name")
});
g.translate(x, y);
draw(draw_ops, g, jif);
g.translate(-x, -y);
if (w != -1) {
variables.put("width", oldWidth);
}
if (h != -1) {
variables.put("height", oldHeight);
}
}
protected void draw(Node draw_ops, Graphics g, JInternalFrame jif) {
if (draw_ops != null) {
NodeList nodes = draw_ops.getChildNodes();
if (nodes != null) {
Shape oldClip = g.getClip();
for (int i = 0; i < nodes.getLength(); i++) {
Node child = nodes.item(i);
if (child.getNodeType() == Node.ELEMENT_NODE) {
try {
String name = child.getNodeName();
if ("include".equals(name)) {
drawInclude(child, g, jif);
} else if ("arc".equals(name)) {
drawArc(child, g);
} else if ("clip".equals(name)) {
setClip(child, g);
} else if ("gradient".equals(name)) {
drawGradient(child, g);
} else if ("gtk_arrow".equals(name)) {
drawGTKArrow(child, g);
} else if ("gtk_box".equals(name)) {
drawGTKBox(child, g);
} else if ("gtk_vline".equals(name)) {
drawGTKVLine(child, g);
} else if ("image".equals(name)) {
drawImage(child, g);
} else if ("icon".equals(name)) {
drawIcon(child, g, jif);
} else if ("line".equals(name)) {
drawLine(child, g);
} else if ("rectangle".equals(name)) {
drawRectangle(child, g);
} else if ("tint".equals(name)) {
drawTint(child, g);
} else if ("tile".equals(name)) {
drawTile(child, g, jif);
} else if ("title".equals(name)) {
drawTitle(child, g, jif);
} else {
System.err.println("Unknown Metacity drawing op: "+child);
}
} catch (NumberFormatException ex) {
logError(themeName, ex);
}
}
}
g.setClip(oldClip);
}
}
}
protected void drawPiece(Node frame_style, Graphics g, String position, int x, int y,
int width, int height, JInternalFrame jif) {
Node piece = getNode(frame_style, "piece", new String[] { "position", position });
if (piece != null) {
Node draw_ops;
String draw_ops_name = getStringAttr(piece, "draw_ops");
if (draw_ops_name != null) {
draw_ops = getNode("draw_ops", new String[] { "name", draw_ops_name });
} else {
draw_ops = getNode(piece, "draw_ops", null);
}
variables.put("width", width);
variables.put("height", height);
g.translate(x, y);
draw(draw_ops, g, jif);
g.translate(-x, -y);
}
}
Insets getBorderInsets(SynthContext context, Insets insets) {
updateFrameGeometry(context);
if (insets == null) {
insets = new Insets(0, 0, 0, 0);
}
insets.top = ((Insets)frameGeometry.get("title_border")).top;
insets.bottom = getInt("bottom_height");
insets.left = getInt("left_width");
insets.right = getInt("right_width");
return insets;
}
private void updateFrameGeometry(SynthContext context) {
this.context = context;
JComponent comp = context.getComponent();
JComponent titlePane = findChild(comp, "InternalFrame.northPane");
JInternalFrame jif = null;
if (comp instanceof JInternalFrame) {
jif = (JInternalFrame)comp;
} else if (comp instanceof JInternalFrame.JDesktopIcon) {
jif = ((JInternalFrame.JDesktopIcon)comp).getInternalFrame();
} else {
assert false : "component is not JInternalFrame or JInternalFrame.JDesktopIcon";
return;
}
if (frame_style_set == null) {
Node window = getNode("window", new String[]{"type", "normal"});
if (window != null) {
frame_style_set = getNode("frame_style_set",
new String[] {"name", getStringAttr(window, "style_set")});
}
if (frame_style_set == null) {
frame_style_set = getNode("frame_style_set", new String[] {"name", "normal"});
}
}
if (frame_style_set != null) {
Node frame = getNode(frame_style_set, "frame", new String[] {
"focus", (jif.isSelected() ? "yes" : "no"),
"state", (jif.isMaximum() ? "maximized" : "normal")
});
if (frame != null) {
Node frame_style = getNode("frame_style", new String[] {
"name", getStringAttr(frame, "style")
});
if (frame_style != null) {
Map gm = frameGeometries.get(getStringAttr(frame_style, "geometry"));
setFrameGeometry(titlePane, gm);
}
}
}
}
protected static void logError(String themeName, Exception ex) {
logError(themeName, ex.toString());
}
protected static void logError(String themeName, String msg) {
if (!errorLogged) {
System.err.println("Exception in Metacity for theme \""+themeName+"\": "+msg);
errorLogged = true;
}
}
// XML Parsing
protected static Document getXMLDoc(final URL xmlFile)
throws IOException,
ParserConfigurationException,
SAXException {
if (documentBuilder == null) {
documentBuilder =
DocumentBuilderFactory.newInstance().newDocumentBuilder();
}
InputStream inputStream =
AccessController.doPrivileged(new PrivilegedAction<InputStream>() {
public InputStream run() {
try {
return new BufferedInputStream(xmlFile.openStream());
} catch (IOException ex) {
return null;
}
}
});
Document doc = null;
if (inputStream != null) {
doc = documentBuilder.parse(inputStream);
}
return doc;
}
protected Node[] getNodesByName(Node parent, String name) {
NodeList nodes = parent.getChildNodes(); // ElementNode
int n = nodes.getLength();
ArrayList<Node> list = new ArrayList<Node>();
for (int i=0; i < n; i++) {
Node node = nodes.item(i);
if (name.equals(node.getNodeName())) {
list.add(node);
}
}
return list.toArray(new Node[list.size()]);
}
protected Node getNode(String tagName, String[] attrs) {
NodeList nodes = xmlDoc.getElementsByTagName(tagName);
return (nodes != null) ? getNode(nodes, tagName, attrs) : null;
}
protected Node getNode(Node parent, String name, String[] attrs) {
Node node = null;
NodeList nodes = parent.getChildNodes();
if (nodes != null) {
node = getNode(nodes, name, attrs);
}
if (node == null) {
String inheritFrom = getStringAttr(parent, "parent");
if (inheritFrom != null) {
Node inheritFromNode = getNode(parent.getParentNode(),
parent.getNodeName(),
new String[] { "name", inheritFrom });
if (inheritFromNode != null) {
node = getNode(inheritFromNode, name, attrs);
}
}
}
return node;
}
protected Node getNode(NodeList nodes, String name, String[] attrs) {
int n = nodes.getLength();
for (int i=0; i < n; i++) {
Node node = nodes.item(i);
if (name.equals(node.getNodeName())) {
if (attrs != null) {
NamedNodeMap nodeAttrs = node.getAttributes();
if (nodeAttrs != null) {
boolean matches = true;
int nAttrs = attrs.length / 2;
for (int a = 0; a < nAttrs; a++) {
String aName = attrs[a * 2];
String aValue = attrs[a * 2 + 1];
Node attr = nodeAttrs.getNamedItem(aName);
if (attr == null ||
aValue != null && !aValue.equals(attr.getNodeValue())) {
matches = false;
break;
}
}
if (matches) {
return node;
}
}
} else {
return node;
}
}
}
return null;
}
protected String getStringAttr(Node node, String name) {
String value = null;
NamedNodeMap attrs = node.getAttributes();
if (attrs != null) {
value = getStringAttr(attrs, name);
if (value == null) {
String inheritFrom = getStringAttr(attrs, "parent");
if (inheritFrom != null) {
Node inheritFromNode = getNode(node.getParentNode(),
node.getNodeName(),
new String[] { "name", inheritFrom });
if (inheritFromNode != null) {
value = getStringAttr(inheritFromNode, name);
}
}
}
}
return value;
}
protected String getStringAttr(NamedNodeMap attrs, String name) {
Node item = attrs.getNamedItem(name);
return (item != null) ? item.getNodeValue() : null;
}
protected boolean getBooleanAttr(Node node, String name, boolean fallback) {
String str = getStringAttr(node, name);
if (str != null) {
return Boolean.valueOf(str).booleanValue();
}
return fallback;
}
protected int getIntAttr(Node node, String name, int fallback) {
String str = getStringAttr(node, name);
int value = fallback;
if (str != null) {
try {
value = Integer.parseInt(str);
} catch (NumberFormatException ex) {
logError(themeName, ex);
}
}
return value;
}
protected float getFloatAttr(Node node, String name, float fallback) {
String str = getStringAttr(node, name);
float value = fallback;
if (str != null) {
try {
value = Float.parseFloat(str);
} catch (NumberFormatException ex) {
logError(themeName, ex);
}
}
return value;
}
protected Color parseColor(String str) {
StringTokenizer tokenizer = new StringTokenizer(str, "/");
int n = tokenizer.countTokens();
if (n > 1) {
String function = tokenizer.nextToken();
if ("shade".equals(function)) {
assert (n == 3);
Color c = parseColor2(tokenizer.nextToken());
float alpha = Float.parseFloat(tokenizer.nextToken());
return GTKColorType.adjustColor(c, 1.0F, alpha, alpha);
} else if ("blend".equals(function)) {
assert (n == 4);
Color bg = parseColor2(tokenizer.nextToken());
Color fg = parseColor2(tokenizer.nextToken());
float alpha = Float.parseFloat(tokenizer.nextToken());
if (alpha > 1.0f) {
alpha = 1.0f / alpha;
}
return new Color((int)(bg.getRed() + ((fg.getRed() - bg.getRed()) * alpha)),
(int)(bg.getRed() + ((fg.getRed() - bg.getRed()) * alpha)),
(int)(bg.getRed() + ((fg.getRed() - bg.getRed()) * alpha)));
} else {
System.err.println("Unknown Metacity color function="+str);
return null;
}
} else {
return parseColor2(str);
}
}
protected Color parseColor2(String str) {
Color c = null;
if (str.startsWith("gtk:")) {
int i1 = str.indexOf('[');
if (i1 > 3) {
String typeStr = str.substring(4, i1).toLowerCase();
int i2 = str.indexOf(']');
if (i2 > i1+1) {
String stateStr = str.substring(i1+1, i2).toUpperCase();
int state = -1;
if ("ACTIVE".equals(stateStr)) {
state = PRESSED;
} else if ("INSENSITIVE".equals(stateStr)) {
state = DISABLED;
} else if ("NORMAL".equals(stateStr)) {
state = ENABLED;
} else if ("PRELIGHT".equals(stateStr)) {
state = MOUSE_OVER;
} else if ("SELECTED".equals(stateStr)) {
state = SELECTED;
}
ColorType type = null;
if ("fg".equals(typeStr)) {
type = GTKColorType.FOREGROUND;
} else if ("bg".equals(typeStr)) {
type = GTKColorType.BACKGROUND;
} else if ("base".equals(typeStr)) {
type = GTKColorType.TEXT_BACKGROUND;
} else if ("text".equals(typeStr)) {
type = GTKColorType.TEXT_FOREGROUND;
} else if ("dark".equals(typeStr)) {
type = GTKColorType.DARK;
} else if ("light".equals(typeStr)) {
type = GTKColorType.LIGHT;
}
if (state >= 0 && type != null) {
c = ((GTKStyle)context.getStyle()).getGTKColor(context, state, type);
}
}
}
}
if (c == null) {
c = parseColorString(str);
}
return c;
}
private static Color parseColorString(String str) {
if (str.charAt(0) == '#') {
str = str.substring(1);
int i = str.length();
if (i < 3 || i > 12 || (i % 3) != 0) {
return null;
}
i /= 3;
int r;
int g;
int b;
try {
r = Integer.parseInt(str.substring(0, i), 16);
g = Integer.parseInt(str.substring(i, i * 2), 16);
b = Integer.parseInt(str.substring(i * 2, i * 3), 16);
} catch (NumberFormatException nfe) {
return null;
}
if (i == 4) {
return new ColorUIResource(r / 65535.0f, g / 65535.0f, b / 65535.0f);
} else if (i == 1) {
return new ColorUIResource(r / 15.0f, g / 15.0f, b / 15.0f);
} else if (i == 2) {
return new ColorUIResource(r, g, b);
} else {
return new ColorUIResource(r / 4095.0f, g / 4095.0f, b / 4095.0f);
}
} else {
return XColors.lookupColor(str);
}
}
class ArithmeticExpressionEvaluator {
private PeekableStringTokenizer tokenizer;
int evaluate(String expr) {
tokenizer = new PeekableStringTokenizer(expr, " \t+-*/%()", true);
return Math.round(expression());
}
int evaluate(String expr, int fallback) {
return (expr != null) ? evaluate(expr) : fallback;
}
public float expression() {
float value = getTermValue();
boolean done = false;
while (!done && tokenizer.hasMoreTokens()) {
String next = tokenizer.peek();
if ("+".equals(next) ||
"-".equals(next) ||
"`max`".equals(next) ||
"`min`".equals(next)) {
tokenizer.nextToken();
float value2 = getTermValue();
if ("+".equals(next)) {
value += value2;
} else if ("-".equals(next)) {
value -= value2;
} else if ("`max`".equals(next)) {
value = Math.max(value, value2);
} else if ("`min`".equals(next)) {
value = Math.min(value, value2);
}
} else {
done = true;
}
}
return value;
}
public float getTermValue() {
float value = getFactorValue();
boolean done = false;
while (!done && tokenizer.hasMoreTokens()) {
String next = tokenizer.peek();
if ("*".equals(next) || "/".equals(next) || "%".equals(next)) {
tokenizer.nextToken();
float value2 = getFactorValue();
if ("*".equals(next)) {
value *= value2;
} else if ("/".equals(next)) {
value /= value2;
} else {
value %= value2;
}
} else {
done = true;
}
}
return value;
}
public float getFactorValue() {
float value;
if ("(".equals(tokenizer.peek())) {
tokenizer.nextToken();
value = expression();
tokenizer.nextToken(); // skip right paren
} else {
String token = tokenizer.nextToken();
if (Character.isDigit(token.charAt(0))) {
value = Float.parseFloat(token);
} else {
Integer i = variables.get(token);
if (i == null) {
i = (Integer)getFrameGeometry().get(token);
}
if (i == null) {
logError(themeName, "Variable \"" + token + "\" not defined");
return 0;
}
value = (i != null) ? i.intValue() : 0F;
}
}
return value;
}
}
static class PeekableStringTokenizer extends StringTokenizer {
String token = null;
public PeekableStringTokenizer(String str, String delim,
boolean returnDelims) {
super(str, delim, returnDelims);
peek();
}
public String peek() {
if (token == null) {
token = nextToken();
}
return token;
}
public boolean hasMoreTokens() {
return (token != null || super.hasMoreTokens());
}
public String nextToken() {
if (token != null) {
String t = token;
token = null;
if (hasMoreTokens()) {
peek();
}
return t;
} else {
String token = super.nextToken();
while ((token.equals(" ") || token.equals("\t"))
&& hasMoreTokens()) {
token = super.nextToken();
}
return token;
}
}
}
static class RoundRectClipShape extends RectangularShape {
static final int TOP_LEFT = 1;
static final int TOP_RIGHT = 2;
static final int BOTTOM_LEFT = 4;
static final int BOTTOM_RIGHT = 8;
int x;
int y;
int width;
int height;
int arcwidth;
int archeight;
int corners;
public RoundRectClipShape() {
}
public RoundRectClipShape(int x, int y, int w, int h,
int arcw, int arch, int corners) {
setRoundedRect(x, y, w, h, arcw, arch, corners);
}
public void setRoundedRect(int x, int y, int w, int h,
int arcw, int arch, int corners) {
this.corners = corners;
this.x = x;
this.y = y;
this.width = w;
this.height = h;
this.arcwidth = arcw;
this.archeight = arch;
}
public double getX() {
return (double)x;
}
public double getY() {
return (double)y;
}
public double getWidth() {
return (double)width;
}
public double getHeight() {
return (double)height;
}
public double getArcWidth() {
return (double)arcwidth;
}
public double getArcHeight() {
return (double)archeight;
}
public boolean isEmpty() {
return false; // Not called
}
public Rectangle2D getBounds2D() {
return null; // Not called
}
public int getCornerFlags() {
return corners;
}
public void setFrame(double x, double y, double w, double h) {
// Not called
}
public boolean contains(double x, double y) {
return false; // Not called
}
private int classify(double coord, double left, double right, double arcsize) {
return 0; // Not called
}
public boolean intersects(double x, double y, double w, double h) {
return false; // Not called
}
public boolean contains(double x, double y, double w, double h) {
return false; // Not called
}
public PathIterator getPathIterator(AffineTransform at) {
return new RoundishRectIterator(this, at);
}
static class RoundishRectIterator implements PathIterator {
double x, y, w, h, aw, ah;
AffineTransform affine;
int index;
double ctrlpts[][];
int types[];
private static final double angle = Math.PI / 4.0;
private static final double a = 1.0 - Math.cos(angle);
private static final double b = Math.tan(angle);
private static final double c = Math.sqrt(1.0 + b * b) - 1 + a;
private static final double cv = 4.0 / 3.0 * a * b / c;
private static final double acv = (1.0 - cv) / 2.0;
// For each array:
// 4 values for each point {v0, v1, v2, v3}:
// point = (x + v0 * w + v1 * arcWidth,
// y + v2 * h + v3 * arcHeight);
private static final double CtrlPtTemplate[][] = {
{ 0.0, 0.0, 1.0, 0.0 }, /* BOTTOM LEFT corner */
{ 0.0, 0.0, 1.0, -0.5 }, /* BOTTOM LEFT arc start */
{ 0.0, 0.0, 1.0, -acv, /* BOTTOM LEFT arc curve */
0.0, acv, 1.0, 0.0,
0.0, 0.5, 1.0, 0.0 },
{ 1.0, 0.0, 1.0, 0.0 }, /* BOTTOM RIGHT corner */
{ 1.0, -0.5, 1.0, 0.0 }, /* BOTTOM RIGHT arc start */
{ 1.0, -acv, 1.0, 0.0, /* BOTTOM RIGHT arc curve */
1.0, 0.0, 1.0, -acv,
1.0, 0.0, 1.0, -0.5 },
{ 1.0, 0.0, 0.0, 0.0 }, /* TOP RIGHT corner */
{ 1.0, 0.0, 0.0, 0.5 }, /* TOP RIGHT arc start */
{ 1.0, 0.0, 0.0, acv, /* TOP RIGHT arc curve */
1.0, -acv, 0.0, 0.0,
1.0, -0.5, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0 }, /* TOP LEFT corner */
{ 0.0, 0.5, 0.0, 0.0 }, /* TOP LEFT arc start */
{ 0.0, acv, 0.0, 0.0, /* TOP LEFT arc curve */
0.0, 0.0, 0.0, acv,
0.0, 0.0, 0.0, 0.5 },
{}, /* Closing path element */
};
private static final int CornerFlags[] = {
RoundRectClipShape.BOTTOM_LEFT,
RoundRectClipShape.BOTTOM_RIGHT,
RoundRectClipShape.TOP_RIGHT,
RoundRectClipShape.TOP_LEFT,
};
RoundishRectIterator(RoundRectClipShape rr, AffineTransform at) {
this.x = rr.getX();
this.y = rr.getY();
this.w = rr.getWidth();
this.h = rr.getHeight();
this.aw = Math.min(w, Math.abs(rr.getArcWidth()));
this.ah = Math.min(h, Math.abs(rr.getArcHeight()));
this.affine = at;
if (w < 0 || h < 0) {
// Don't draw anything...
ctrlpts = new double[0][];
types = new int[0];
} else {
int corners = rr.getCornerFlags();
int numedges = 5; // 4xCORNER_POINT, CLOSE
for (int i = 1; i < 0x10; i <<= 1) {
// Add one for each corner that has a curve
if ((corners & i) != 0) numedges++;
}
ctrlpts = new double[numedges][];
types = new int[numedges];
int j = 0;
for (int i = 0; i < 4; i++) {
types[j] = SEG_LINETO;
if ((corners & CornerFlags[i]) == 0) {
ctrlpts[j++] = CtrlPtTemplate[i*3+0];
} else {
ctrlpts[j++] = CtrlPtTemplate[i*3+1];
types[j] = SEG_CUBICTO;
ctrlpts[j++] = CtrlPtTemplate[i*3+2];
}
}
types[j] = SEG_CLOSE;
ctrlpts[j++] = CtrlPtTemplate[12];
types[0] = SEG_MOVETO;
}
}
public int getWindingRule() {
return WIND_NON_ZERO;
}
public boolean isDone() {
return index >= ctrlpts.length;
}
public void next() {
index++;
}
public int currentSegment(float[] coords) {
if (isDone()) {
throw new NoSuchElementException("roundrect iterator out of bounds");
}
double ctrls[] = ctrlpts[index];
int nc = 0;
for (int i = 0; i < ctrls.length; i += 4) {
coords[nc++] = (float) (x + ctrls[i + 0] * w + ctrls[i + 1] * aw);
coords[nc++] = (float) (y + ctrls[i + 2] * h + ctrls[i + 3] * ah);
}
if (affine != null) {
affine.transform(coords, 0, coords, 0, nc / 2);
}
return types[index];
}
public int currentSegment(double[] coords) {
if (isDone()) {
throw new NoSuchElementException("roundrect iterator out of bounds");
}
double ctrls[] = ctrlpts[index];
int nc = 0;
for (int i = 0; i < ctrls.length; i += 4) {
coords[nc++] = x + ctrls[i + 0] * w + ctrls[i + 1] * aw;
coords[nc++] = y + ctrls[i + 2] * h + ctrls[i + 3] * ah;
}
if (affine != null) {
affine.transform(coords, 0, coords, 0, nc / 2);
}
return types[index];
}
}
}
}
