JLayeredPane layeredPane = root.getLayeredPane();        JComponent oldTitlePane = getTitlePane();        if (oldTitlePane != null) {            oldTitlePane.setVisible(false);            layeredPane.remove(oldTitlePane);        }        if (titlePane != null) {            layeredPane.add(titlePane, JLayeredPane.FRAME_CONTENT_LAYER);            titlePane.setVisible(true);        }        this.titlePane = titlePane;    }    /**     * Returns the <code>JComponent</code> rendering the title pane. If this     * returns null, it implies there is no need to render window decorations.     *     * @return the current window title pane, or null     * @see #setTitlePane     */    private JComponent getTitlePane() {        return titlePane;    }    /**     * Returns the <code>JRootPane</code> we're providing the look and     * feel for.     */    private JRootPane getRootPane() {        return root;    }    /**     * Invoked when a property changes. <code>MetalRootPaneUI</code> is     * primarily interested in events originating from the     * <code>JRootPane</code> it has been installed on identifying the     * property <code>windowDecorationStyle</code>. If the      * <code>windowDecorationStyle</code> has changed to a value other     * than <code>JRootPane.NONE</code>, this will add a <code>Component</code>     * to the <code>JRootPane</code> to render the window decorations, as well     * as installing a <code>Border</code> on the <code>JRootPane</code>.     * On the other hand, if the <code>windowDecorationStyle</code> has     * changed to <code>JRootPane.NONE</code>, this will remove the     * <code>Component</code> that has been added to the <code>JRootPane</code>     * as well resetting the Border to what it was before     * <code>installUI</code> was invoked.     *     * @param e A PropertyChangeEvent object describing the event source      *          and the property that has changed.     */    public void propertyChange(PropertyChangeEvent e) {        super.propertyChange(e);                String propertyName = e.getPropertyName();        if(propertyName == null) {            return;        }            if(propertyName.equals("windowDecorationStyle")) {            JRootPane root = (JRootPane) e.getSource();            int style = root.getWindowDecorationStyle();            // This is potentially more than needs to be done,            // but it rarely happens and makes the install/uninstall process            // simpler. MetalTitlePane also assumes it will be recreated if            // the decoration style changes.            uninstallClientDecorations(root);            if (style != JRootPane.NONE) {                installClientDecorations(root);            }        }        else if (propertyName.equals("ancestor")) {            uninstallWindowListeners(root);            if (((JRootPane)e.getSource()).getWindowDecorationStyle() !=                                           JRootPane.NONE) {                installWindowListeners(root, root.getParent());            }        }        return;    }     /**      * A custom layout manager that is responsible for the layout of      * layeredPane, glassPane, menuBar and titlePane, if one has been     * installed.     */    // NOTE: Ideally this would extends JRootPane.RootLayout, but that    //       would force this to be non-static.    private static class MetalRootLayout implements LayoutManager2 {        /**         * Returns the amount of space the layout would like to have.         *         * @param the Container for which this layout manager is being used         * @return a Dimension object containing the layout's preferred size         */         public Dimension preferredLayoutSize(Container parent) {            Dimension cpd, mbd, tpd;            int cpWidth = 0;            int cpHeight = 0;            int mbWidth = 0;            int mbHeight = 0;            int tpWidth = 0;            int tpHeight = 0;            Insets i = parent.getInsets();            JRootPane root = (JRootPane) parent;                if(root.getContentPane() != null) {                cpd = root.getContentPane().getPreferredSize();            } else {                cpd = root.getSize();            }            if (cpd != null) {                cpWidth = cpd.width;                cpHeight = cpd.height;            }            if(root.getMenuBar() != null) {                mbd = root.getMenuBar().getPreferredSize();                if (mbd != null) {                    mbWidth = mbd.width;                    mbHeight = mbd.height;                }            }             if (root.getWindowDecorationStyle() != JRootPane.NONE &&                     (root.getUI() instanceof MetalRootPaneUI)) {                JComponent titlePane = ((MetalRootPaneUI)root.getUI()).                                       getTitlePane();                if (titlePane != null) {                    tpd = titlePane.getPreferredSize();                    if (tpd != null) {                        tpWidth = tpd.width;                        tpHeight = tpd.height;                    }                }            }            return new Dimension(Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,                                  cpHeight + mbHeight + tpWidth + i.top + i.bottom);        }        /**         * Returns the minimum amount of space the layout needs.         *         * @param the Container for which this layout manager is being used         * @return a Dimension object containing the layout's minimum size         */         public Dimension minimumLayoutSize(Container parent) {            Dimension cpd, mbd, tpd;            int cpWidth = 0;            int cpHeight = 0;            int mbWidth = 0;            int mbHeight = 0;            int tpWidth = 0;            int tpHeight = 0;            Insets i = parent.getInsets();            JRootPane root = (JRootPane) parent;                    if(root.getContentPane() != null) {                cpd = root.getContentPane().getMinimumSize();            } else {                cpd = root.getSize();            }            if (cpd != null) {                cpWidth = cpd.width;                cpHeight = cpd.height;            }            if(root.getMenuBar() != null) {                mbd = root.getMenuBar().getMinimumSize();                if (mbd != null) {                    mbWidth = mbd.width;                    mbHeight = mbd.height;                }            }                        if (root.getWindowDecorationStyle() != JRootPane.NONE &&                     (root.getUI() instanceof MetalRootPaneUI)) {                JComponent titlePane = ((MetalRootPaneUI)root.getUI()).                                       getTitlePane();                if (titlePane != null) {                    tpd = titlePane.getMinimumSize();                    if (tpd != null) {                        tpWidth = tpd.width;                        tpHeight = tpd.height;                    }                }            }            return new Dimension(Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,                                  cpHeight + mbHeight + tpWidth + i.top + i.bottom);        }        /**         * Returns the maximum amount of space the layout can use.         *         * @param the Container for which this layout manager is being used         * @return a Dimension object containing the layout's maximum size         */         public Dimension maximumLayoutSize(Container target) {            Dimension cpd, mbd, tpd;            int cpWidth = Integer.MAX_VALUE;            int cpHeight = Integer.MAX_VALUE;            int mbWidth = Integer.MAX_VALUE;            int mbHeight = Integer.MAX_VALUE;            int tpWidth = Integer.MAX_VALUE;            int tpHeight = Integer.MAX_VALUE;            Insets i = target.getInsets();            JRootPane root = (JRootPane) target;                    if(root.getContentPane() != null) {                cpd = root.getContentPane().getMaximumSize();                if (cpd != null) {                    cpWidth = cpd.width;                    cpHeight = cpd.height;                }            }            if(root.getMenuBar() != null) {                mbd = root.getMenuBar().getMaximumSize();                if (mbd != null) {                    mbWidth = mbd.width;                    mbHeight = mbd.height;                }            }            if (root.getWindowDecorationStyle() != JRootPane.NONE &&                     (root.getUI() instanceof MetalRootPaneUI)) {                JComponent titlePane = ((MetalRootPaneUI)root.getUI()).                                       getTitlePane();                if (titlePane != null)                {                    tpd = titlePane.getMaximumSize();                    if (tpd != null) {                        tpWidth = tpd.width;                        tpHeight = tpd.height;                    }                }            }            int maxHeight = Math.max(Math.max(cpHeight, mbHeight), tpHeight);            // Only overflows if 3 real non-MAX_VALUE heights, sum to > MAX_VALUE            // Only will happen if sums to more than 2 billion units.  Not likely.            if (maxHeight != Integer.MAX_VALUE) {                maxHeight = cpHeight + mbHeight + tpHeight + i.top + i.bottom;            }                int maxWidth = Math.max(Math.max(cpWidth, mbWidth), tpWidth);            // Similar overflow comment as above            if (maxWidth != Integer.MAX_VALUE) {                maxWidth += i.left + i.right;            }            return new Dimension(maxWidth, maxHeight);        }            /**         * Instructs the layout manager to perform the layout for the specified         * container.         *         * @param the Container for which this layout manager is being used         */         public void layoutContainer(Container parent) {            JRootPane root = (JRootPane) parent;            Rectangle b = root.getBounds();            Insets i = root.getInsets();            int nextY = 0;            int w = b.width - i.right - i.left;            int h = b.height - i.top - i.bottom;                if(root.getLayeredPane() != null) {                root.getLayeredPane().setBounds(i.left, i.top, w, h);            }            if(root.getGlassPane() != null) {                root.getGlassPane().setBounds(i.left, i.top, w, h);            }            // Note: This is laying out the children in the layeredPane,            // technically, these are not our children.            if (root.getWindowDecorationStyle() != JRootPane.NONE &&                     (root.getUI() instanceof MetalRootPaneUI)) {                JComponent titlePane = ((MetalRootPaneUI)root.getUI()).                                       getTitlePane();                if (titlePane != null) {                    Dimension tpd = titlePane.getPreferredSize();                    if (tpd != null) {                        int tpHeight = tpd.height;                        titlePane.setBounds(0, 0, w, tpHeight);                        nextY += tpHeight;                    }                                    }            }            if(root.getMenuBar() != null) {                Dimension mbd = root.getMenuBar().getPreferredSize();                root.getMenuBar().setBounds(0, nextY, w, mbd.height);                nextY += mbd.height;            }            if(root.getContentPane() != null) {                Dimension cpd = root.getContentPane().getPreferredSize();                root.getContentPane().setBounds(0, nextY, w,                 h < nextY ? 0 : h - nextY);            }        }            public void addLayoutComponent(String name, Component comp) {}        public void removeLayoutComponent(Component comp) {}        public void addLayoutComponent(Component comp, Object constraints) {}        public float getLayoutAlignmentX(Container target) { return 0.0f; }        public float getLayoutAlignmentY(Container target) { return 0.0f; }        public void invalidateLayout(Container target) {}    }    /**     * Maps from positions to cursor type. Refer to calculateCorner and     * calculatePosition for details of this.     */    private static final int[] cursorMapping = new int[]    { Cursor.NW_RESIZE_CURSOR, Cursor.NW_RESIZE_CURSOR, Cursor.N_RESIZE_CURSOR,             Cursor.NE_RESIZE_CURSOR, Cursor.NE_RESIZE_CURSOR,      Cursor.NW_RESIZE_CURSOR, 0, 0, 0, Cursor.NE_RESIZE_CURSOR,      Cursor.W_RESIZE_CURSOR, 0, 0, 0, Cursor.E_RESIZE_CURSOR,      Cursor.SW_RESIZE_CURSOR, 0, 0, 0, Cursor.SE_RESIZE_CURSOR,      Cursor.SW_RESIZE_CURSOR, Cursor.SW_RESIZE_CURSOR, Cursor.S_RESIZE_CURSOR,             Cursor.SE_RESIZE_CURSOR, Cursor.SE_RESIZE_CURSOR    };    /**     * MouseInputHandler is responsible for handling resize/moving of     * the Window. It sets the cursor directly on the Window when then