/*

 * 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.basic.BasicInternalFrameTitlePane;

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.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 = Float.valueOf(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 = findInternalFrame(titlePaneParent);

        if (jif == null) {

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

        }

    }

    JInternalFrame findInternalFrame(Component comp) {

        if (comp.getParent() instanceof BasicInternalFrameTitlePane) {

            comp = comp.getParent();

        }

        if (comp instanceof JInternalFrame) {

            return  (JInternalFrame)comp;

        } else if (comp instanceof JInternalFrame.JDesktopIcon) {

            return ((JInternalFrame.JDesktopIcon)comp).getInternalFrame();

        }

        assert false : "cannot find the internal frame";

        return null;

    }

    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 = findInternalFrame(comp);

        if (jif == null) {

            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) {