/* * Copyright (c) 1997, 2006, 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 javax.swing.plaf.basic; import javax.swing.*;import javax.swing.plaf.*; import java.beans.*; import java.awt.event.*;import java.awt.Dimension;import java.awt.Insets;import java.awt.Graphics;import java.awt.KeyboardFocusManager;import java.awt.*;import java.util.Vector;import sun.swing.DefaultLookup;import sun.swing.UIAction;import sun.awt.AppContext; /** * Basic L&F for a desktop. * * @author Steve Wilson */public class BasicDesktopPaneUI extends DesktopPaneUI {    // Old actions forward to an instance of this.    private static final Actions SHARED_ACTION = new Actions();    private static Dimension minSize = new Dimension(0,0);    private static Dimension maxSize = new Dimension(Integer.MAX_VALUE,            Integer.MAX_VALUE);    private Handler handler;    private PropertyChangeListener pcl;     protected JDesktopPane desktop;    protected DesktopManager desktopManager;     /**     * As of Java 2 platform v1.3 this previously undocumented field is no     * longer used.     * Key bindings are now defined by the LookAndFeel, please refer to     * the key bindings specification for further details.     *     * @deprecated As of 1.3.     */    @Deprecated    protected KeyStroke minimizeKey;    /**     * As of Java 2 platform v1.3 this previously undocumented field is no     * longer used.     * Key bindings are now defined by the LookAndFeel, please refer to     * the key bindings specification for further details.     *     * @deprecated As of 1.3.     */    @Deprecated    protected KeyStroke maximizeKey;    /**     * As of Java 2 platform v1.3 this previously undocumented field is no     * longer used.     * Key bindings are now defined by the LookAndFeel, please refer to     * the key bindings specification for further details.     *     * @deprecated As of 1.3.     */    @Deprecated    protected KeyStroke closeKey;    /**     * As of Java 2 platform v1.3 this previously undocumented field is no     * longer used.     * Key bindings are now defined by the LookAndFeel, please refer to     * the key bindings specification for further details.     *     * @deprecated As of 1.3.     */    @Deprecated    protected KeyStroke navigateKey;    /**     * As of Java 2 platform v1.3 this previously undocumented field is no     * longer used.     * Key bindings are now defined by the LookAndFeel, please refer to     * the key bindings specification for further details.     *     * @deprecated As of 1.3.     */    @Deprecated    protected KeyStroke navigateKey2;     public static ComponentUI createUI(JComponent c) {        return new BasicDesktopPaneUI();    }     public BasicDesktopPaneUI() {    }     public void installUI(JComponent c)   {        desktop = (JDesktopPane)c;        installDefaults();        installDesktopManager();        installListeners();        installKeyboardActions();    }     public void uninstallUI(JComponent c) {        uninstallKeyboardActions();        uninstallListeners();        uninstallDesktopManager();        uninstallDefaults();        desktop = null;        handler = null;    }     protected void installDefaults() {        if (desktop.getBackground() == null ||            desktop.getBackground() instanceof UIResource) {            desktop.setBackground(UIManager.getColor("Desktop.background"));        }        LookAndFeel.installProperty(desktop, "opaque", Boolean.TRUE);    }     protected void uninstallDefaults() { }     /**     * Installs the <code>PropertyChangeListener</code> returned from     * <code>createPropertyChangeListener</code> on the     * <code>JDesktopPane</code>.     *     * @since 1.5     * @see #createPropertyChangeListener     */    protected void installListeners() {        pcl = createPropertyChangeListener();        desktop.addPropertyChangeListener(pcl);    }     /**     * Uninstalls the <code>PropertyChangeListener</code> returned from     * <code>createPropertyChangeListener</code> from the     * <code>JDesktopPane</code>.     *     * @since 1.5     * @see #createPropertyChangeListener     */    protected void uninstallListeners() {        desktop.removePropertyChangeListener(pcl);        pcl = null;    }     protected void installDesktopManager() {        desktopManager = desktop.getDesktopManager();        if(desktopManager == null) {            desktopManager = new BasicDesktopManager();            desktop.setDesktopManager(desktopManager);        }    }     protected void uninstallDesktopManager() {        if(desktop.getDesktopManager() instanceof UIResource) {            desktop.setDesktopManager(null);        }        desktopManager = null;    }     protected void installKeyboardActions(){        InputMap inputMap = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);        if (inputMap != null) {            SwingUtilities.replaceUIInputMap(desktop,                        JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);        }        inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);        if (inputMap != null) {            SwingUtilities.replaceUIInputMap(desktop,                        JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,                        inputMap);        }         LazyActionMap.installLazyActionMap(desktop, BasicDesktopPaneUI.class,                "DesktopPane.actionMap");        registerKeyboardActions();    }     protected void registerKeyboardActions(){    }     protected void unregisterKeyboardActions(){    }     InputMap getInputMap(int condition) {        if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {            return createInputMap(condition);        }        else if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {            return (InputMap)DefaultLookup.get(desktop, this,                    "Desktop.ancestorInputMap");        }        return null;    }     InputMap createInputMap(int condition) {        if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {            Object[] bindings = (Object[])DefaultLookup.get(desktop,                    this, "Desktop.windowBindings");             if (bindings != null) {                return LookAndFeel.makeComponentInputMap(desktop, bindings);            }        }        return null;    }     static void loadActionMap(LazyActionMap map) {        map.put(new Actions(Actions.RESTORE));        map.put(new Actions(Actions.CLOSE));        map.put(new Actions(Actions.MOVE));        map.put(new Actions(Actions.RESIZE));        map.put(new Actions(Actions.LEFT));        map.put(new Actions(Actions.SHRINK_LEFT));        map.put(new Actions(Actions.RIGHT));        map.put(new Actions(Actions.SHRINK_RIGHT));        map.put(new Actions(Actions.UP));        map.put(new Actions(Actions.SHRINK_UP));        map.put(new Actions(Actions.DOWN));        map.put(new Actions(Actions.SHRINK_DOWN));        map.put(new Actions(Actions.ESCAPE));        map.put(new Actions(Actions.MINIMIZE));        map.put(new Actions(Actions.MAXIMIZE));        map.put(new Actions(Actions.NEXT_FRAME));        map.put(new Actions(Actions.PREVIOUS_FRAME));        map.put(new Actions(Actions.NAVIGATE_NEXT));        map.put(new Actions(Actions.NAVIGATE_PREVIOUS));    }     protected void uninstallKeyboardActions(){      unregisterKeyboardActions();      SwingUtilities.replaceUIInputMap(desktop, JComponent.                                     WHEN_IN_FOCUSED_WINDOW, null);      SwingUtilities.replaceUIInputMap(desktop, JComponent.                                     WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);      SwingUtilities.replaceUIActionMap(desktop, null);    }     public void paint(Graphics g, JComponent c) {}     public Dimension getPreferredSize(JComponent c) {return null;}     public Dimension getMinimumSize(JComponent c) {        return minSize;        }    public Dimension getMaximumSize(JComponent c){        return maxSize;    }     /**     * Returns the <code>PropertyChangeListener</code> to install on     * the <code>JDesktopPane</code>.     *     * @since 1.5     * @return The PropertyChangeListener that will be added to track     * changes in the desktop pane.     */    protected PropertyChangeListener createPropertyChangeListener() {        return getHandler();    }     private Handler getHandler() {        if (handler == null) {            handler = new Handler();        }        return handler;    }     private class Handler implements PropertyChangeListener {        public void propertyChange(PropertyChangeEvent evt) {            String propertyName = evt.getPropertyName();            if ("desktopManager" == propertyName) {                installDesktopManager();            }        }    }     /**     * The default DesktopManager installed by the UI.     */    private class BasicDesktopManager extends DefaultDesktopManager            implements UIResource {    }     private static class Actions extends UIAction {        private static String CLOSE = "close";        private static String ESCAPE = "escape";        private static String MAXIMIZE = "maximize";        private static String MINIMIZE = "minimize";        private static String MOVE = "move";        private static String RESIZE = "resize";        private static String RESTORE = "restore";        private static String LEFT = "left";        private static String RIGHT = "right";        private static String UP = "up";        private static String DOWN = "down";        private static String SHRINK_LEFT = "shrinkLeft";        private static String SHRINK_RIGHT = "shrinkRight";        private static String SHRINK_UP = "shrinkUp";        private static String SHRINK_DOWN = "shrinkDown";        private static String NEXT_FRAME = "selectNextFrame";        private static String PREVIOUS_FRAME = "selectPreviousFrame";        private static String NAVIGATE_NEXT = "navigateNext";        private static String NAVIGATE_PREVIOUS = "navigatePrevious";        private final int MOVE_RESIZE_INCREMENT = 10;        private static boolean moving = false;        private static boolean resizing = false;        private static JInternalFrame sourceFrame = null;        private static Component focusOwner = null;         Actions() {            super(null);        }         Actions(String name) {            super(name);        }         public void actionPerformed(ActionEvent e) {            JDesktopPane dp = (JDesktopPane)e.getSource();            String key = getName();             if (CLOSE == key || MAXIMIZE == key || MINIMIZE == key ||                    RESTORE == key) {                setState(dp, key);            }            else if (ESCAPE == key) {                if (sourceFrame == dp.getSelectedFrame() &&                        focusOwner != null) {                    focusOwner.requestFocus();                }                moving = false;                resizing = false;                sourceFrame = null;                focusOwner = null;            }            else if (MOVE == key || RESIZE == key) {                sourceFrame = dp.getSelectedFrame();                if (sourceFrame == null) {                    return;                }                moving = (key == MOVE) ? true : false;                resizing = (key == RESIZE) ? true : false;                 focusOwner = KeyboardFocusManager.                    getCurrentKeyboardFocusManager().getFocusOwner();                if (!SwingUtilities.isDescendingFrom(focusOwner, sourceFrame)) {                    focusOwner = null;                }                sourceFrame.requestFocus();            }            else if (LEFT == key ||                     RIGHT == key ||                     UP == key ||                     DOWN == key ||                     SHRINK_RIGHT == key ||                     SHRINK_LEFT == key ||                     SHRINK_UP == key ||                     SHRINK_DOWN == key) {                JInternalFrame c = dp.getSelectedFrame();                if (sourceFrame == null || c != sourceFrame ||                        KeyboardFocusManager.                            getCurrentKeyboardFocusManager().getFocusOwner() !=                                sourceFrame) {                    return;                }                Insets minOnScreenInsets =                    UIManager.getInsets("Desktop.minOnScreenInsets");                Dimension size = c.getSize();                Dimension minSize = c.getMinimumSize();                int dpWidth = dp.getWidth();                int dpHeight = dp.getHeight();                int delta;                Point loc = c.getLocation();                if (LEFT == key) {                    if (moving) {                        c.setLocation(                                loc.x + size.width - MOVE_RESIZE_INCREMENT <                                    minOnScreenInsets.right ?                                        -size.width + minOnScreenInsets.right :                                        loc.x - MOVE_RESIZE_INCREMENT,                                loc.y);                    } else if (resizing) {                        c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);                        c.setSize(size.width + MOVE_RESIZE_INCREMENT,                                size.height);                    }                } else if (RIGHT == key) {                    if (moving) {                        c.setLocation(                                loc.x + MOVE_RESIZE_INCREMENT >                                    dpWidth - minOnScreenInsets.left ?                                        dpWidth - minOnScreenInsets.left :                                        loc.x + MOVE_RESIZE_INCREMENT,                                loc.y);                    } else if (resizing) {                        c.setSize(size.width + MOVE_RESIZE_INCREMENT,                                size.height);                    }                } else if (UP == key) {                    if (moving) {                        c.setLocation(loc.x,                                loc.y + size.height - MOVE_RESIZE_INCREMENT <                                    minOnScreenInsets.bottom ?                                        -size.height +                                            minOnScreenInsets.bottom :                                        loc.y - MOVE_RESIZE_INCREMENT);                    } else if (resizing) {                        c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);                        c.setSize(size.width,                                size.height + MOVE_RESIZE_INCREMENT);                    }                } else if (DOWN == key) {                    if (moving) {                        c.setLocation(loc.x,                                loc.y + MOVE_RESIZE_INCREMENT >                                    dpHeight - minOnScreenInsets.top ?                                        dpHeight - minOnScreenInsets.top :                                        loc.y + MOVE_RESIZE_INCREMENT);                    } else if (resizing) {                        c.setSize(size.width,                                size.height + MOVE_RESIZE_INCREMENT);                    }                } else if (SHRINK_LEFT == key && resizing) {                    // Make sure we don't resize less than minimum size.                    if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {                        delta = MOVE_RESIZE_INCREMENT;                    } else {                        delta = size.width - minSize.width;                    }                     // Ensure that we keep the internal frame on the desktop.                    if (loc.x + size.width - delta < minOnScreenInsets.left) {                        delta = loc.x + size.width - minOnScreenInsets.left;                    }                    c.setSize(size.width - delta, size.height);                } else if (SHRINK_RIGHT == key && resizing) {                    // Make sure we don't resize less than minimum size.                    if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {                        delta = MOVE_RESIZE_INCREMENT;                    } else {                        delta = size.width - minSize.width;                    }                     // Ensure that we keep the internal frame on the desktop.                    if (loc.x + delta > dpWidth - minOnScreenInsets.right) {                        delta = (dpWidth - minOnScreenInsets.right) - loc.x;                    }                     c.setLocation(loc.x + delta, loc.y);                    c.setSize(size.width - delta, size.height);                } else if (SHRINK_UP == key && resizing) {                    // Make sure we don't resize less than minimum size.                    if (minSize.height <                            (size.height - MOVE_RESIZE_INCREMENT)) {                        delta = MOVE_RESIZE_INCREMENT;                    } else {                        delta = size.height - minSize.height;                    }                     // Ensure that we keep the internal frame on the desktop.                    if (loc.y + size.height - delta <                            minOnScreenInsets.bottom) {                        delta = loc.y + size.height - minOnScreenInsets.bottom;                    }                     c.setSize(size.width, size.height - delta);                } else if (SHRINK_DOWN == key  && resizing) {                    // Make sure we don't resize less than minimum size.                    if (minSize.height <                            (size.height - MOVE_RESIZE_INCREMENT)) {                        delta = MOVE_RESIZE_INCREMENT;                    } else {                        delta = size.height - minSize.height;

Lines 1–500 of 713. Load more