/*
 * @(#)SynthInternalFrameUI.java	1.13 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.java.swing.plaf.gtk;

import java.awt.*;
import java.awt.event.*;
import java.awt.peer.LightweightPeer;

import javax.swing.*;
import javax.swing.plaf.*;
import javax.swing.event.*;

import java.beans.*;
import java.io.Serializable;


/**
 * A basic L&F implementation of JInternalFrame.  
 *
 * @version 1.13 01/23/03 (originally from version 1.104 of BasicInternalFrameUI)
 * @author David Kloba
 * @author Joshua Outwater
 * @author Rich Schiavi
 */
class SynthInternalFrameUI extends InternalFrameUI implements SynthUI, LazyActionMap.Loader {
    private SynthStyle style;
    // Listeners
    protected MouseInputAdapter          borderListener;
    protected PropertyChangeListener     propertyChangeListener;
    protected LayoutManager              internalFrameLayout;
    protected ComponentListener          componentListener;
    protected MouseInputListener         glassPaneDispatcher;
 
    // Subcomponents
    protected JComponent northPane;
    protected JComponent southPane;
    protected JComponent westPane;
    protected JComponent eastPane;
    protected SynthInternalFrameTitlePane titlePane;

    protected JInternalFrame frame;

    private static DesktopManager sharedDesktopManager;
    private boolean componentListenerAdded = false;

    private Rectangle parentBounds;

    private boolean dragging = false;

    private boolean keyBindingRegistered = false;
    private boolean keyBindingActive = false;

    private InternalFrameListener internalFrameListener = null;
    
    public static ComponentUI createUI(JComponent b) {
        return new SynthInternalFrameUI();
    }

    public void installUI(JComponent c)   {
        frame = (JInternalFrame)c;
        fetchStyle(c);
        frame.setLayout(internalFrameLayout = createLayoutManager());

        // PENDING (josh): Why is installListeners first? Can it be made
        // last?
        installListeners();
        installComponents();
        installDefaults();
        installKeyboardActions();
    }

    public void uninstallUI(JComponent c) {
        if (c != frame) {
            throw new IllegalComponentStateException(
                this + " was asked to deinstall() " 
                + c + " when it only knows about " 
                + frame + "."); 
        }
                
        uninstallKeyboardActions();
        uninstallDefaults();
        uninstallComponents();
        uninstallListeners();
        frame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));    
        internalFrameLayout = null;
        frame.setLayout(null);
        frame = null;
    }
    
    protected void installDefaults(){
        /* enable the content pane to inherit background color from its
           parent by setting its background color to null. Fixes bug#
           4268949. */
        JComponent contentPane = (JComponent) frame.getContentPane();
        if (contentPane != null) {
            Color bg = contentPane.getBackground();
            if (bg instanceof UIResource) {
                contentPane.setBackground(null);
            }
        }
    }

    private void fetchStyle(JComponent c) {
        SynthContext context = getContext(c, ENABLED);
        SynthStyle oldStyle = style;

        style = SynthLookAndFeel.updateStyle(context, this);
        if (style != oldStyle) {
            Icon frameIcon = frame.getFrameIcon();
            if (frameIcon == null || frameIcon instanceof UIResource) {
                frame.setFrameIcon(context.getStyle().getIcon(
                                   context, "InternalFrame.icon"));
            }
        }
        context.dispose();
    }

    protected void uninstallDefaults() {
        SynthContext context = getContext(frame, ENABLED);

        style.uninstallDefaults(context);
        context.dispose();
        Icon frameIcon = frame.getFrameIcon();
        if (frameIcon instanceof UIResource) {
            frame.setFrameIcon(null);
        }
        style = null;
    }

    protected void installKeyboardActions(){
        if (internalFrameListener == null) {
            createInternalFrameListener();
        }
        frame.addInternalFrameListener(internalFrameListener);

        LazyActionMap.installLazyActionMap(frame, this);
    }

    protected void uninstallKeyboardActions(){
        if (internalFrameListener != null) {
            frame.removeInternalFrameListener(internalFrameListener);
        }
        SwingUtilities.replaceUIInputMap(frame, JComponent.
            WHEN_IN_FOCUSED_WINDOW, null);
        SwingUtilities.replaceUIActionMap(frame, null);

    }

    protected void installComponents(){
    setNorthPane(createNorthPane(frame));
    setSouthPane(createSouthPane(frame));
    setEastPane(createEastPane(frame));
    setWestPane(createWestPane(frame));
    }

    protected void uninstallComponents(){
        setNorthPane(null);
        setSouthPane(null);
        setEastPane(null);
        setWestPane(null);
        titlePane = null;
    }

    protected void installListeners() {
        borderListener = createBorderListener(frame);
        propertyChangeListener = createPropertyChangeListener();
        frame.addPropertyChangeListener(propertyChangeListener);
        installMouseHandlers(frame);
        glassPaneDispatcher = createGlassPaneDispatcher();
        frame.getGlassPane().addMouseListener(glassPaneDispatcher);
        frame.getGlassPane().addMouseMotionListener(glassPaneDispatcher);
        componentListener =  createComponentListener();
        if (frame.getParent() != null) {
            parentBounds = frame.getParent().getBounds();
        }
        if ((frame.getParent() != null) && !componentListenerAdded) {
            frame.getParent().addComponentListener(componentListener);
            componentListenerAdded = true;
        }
    }

    protected void uninstallListeners() {
        if ((frame.getParent() != null) && componentListenerAdded) {
            frame.getParent().removeComponentListener(componentListener);
            componentListenerAdded = false;
        }
        componentListener = null;
        frame.getGlassPane().removeMouseListener(glassPaneDispatcher);
        frame.getGlassPane().removeMouseMotionListener(glassPaneDispatcher);
        glassPaneDispatcher = null;
        deinstallMouseHandlers(frame);      
        frame.removePropertyChangeListener(propertyChangeListener);
        propertyChangeListener = null;
        borderListener = null;
    }

    public void loadActionMap(JComponent c, ActionMap map) {
        // add action for the system menu
        map.put("showSystemMenu", new AbstractAction() {
            public void actionPerformed(ActionEvent e){
                //titlePane.showSystemMenu();
            }
            public boolean isEnabled(){
                return isKeyBindingActive();
            }
        });
    }

    InputMap getInputMap(int condition) {
        if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {
            return createInputMap(condition);
        }
        return null;
    }

    InputMap createInputMap(int condition) {
        if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {
            SynthContext context = getContext(frame, ENABLED);
            Object[] bindings = (Object[])context.getStyle().get
                    (context, "InternalFrame.windowBindings");
            if (bindings != null) {
                return LookAndFeel.makeComponentInputMap(frame, bindings);
            }
        }
        return null;
    }

    protected LayoutManager createLayoutManager(){
        return new InternalFrameLayout();
    }

    protected PropertyChangeListener createPropertyChangeListener(){
        return new InternalFramePropertyChangeListener();
    }

    public Dimension getPreferredSize(JComponent x) {
        if ((JComponent)frame == x) {
            return frame.getLayout().preferredLayoutSize(x);
        }
        return new Dimension(100, 100);
    }
    
    public Dimension getMinimumSize(JComponent x) {
        if ((JComponent)frame == x) {
            return frame.getLayout().minimumLayoutSize(x);
        }
        return new Dimension(0, 0);
    }
    
    public Dimension getMaximumSize(JComponent x) {
        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
    }

    public SynthContext getContext(JComponent c) {
        return getContext(c, getComponentState(c));
    }

    private SynthContext getContext(JComponent c, int state) {
        return SynthContext.getContext(SynthContext.class, c,
                            SynthLookAndFeel.getRegion(c), style, state);
    }

    private Region getRegion(JComponent c) {
        return SynthLookAndFeel.getRegion(c);
    }

    public int getComponentState(JComponent c) {
        return SynthLookAndFeel.getComponentState(c);
    }

    /** 
      * Installs necessary mouse handlers on <code>newPane</code>
      * and adds it to the frame.
      * Reverse process for the <code>currentPane</code>. 
      */
    protected void replacePane(JComponent currentPane, JComponent newPane) {
        if (currentPane != null) {
            deinstallMouseHandlers(currentPane);
            frame.remove(currentPane);
        }
        if (newPane != null) {
           frame.add(newPane);
           installMouseHandlers(newPane);
        }
    }

    protected void deinstallMouseHandlers(JComponent c) {
        c.removeMouseListener(borderListener);
        c.removeMouseMotionListener(borderListener);
    }
  
    protected void installMouseHandlers(JComponent c) {
        c.addMouseListener(borderListener);
        c.addMouseMotionListener(borderListener);
    }
    
    protected JComponent createNorthPane(JInternalFrame w) {
        titlePane = new SynthInternalFrameTitlePane(w);
	titlePane.setName("InternalFrame.northPane");
        return titlePane;
    }
    
    protected JComponent createSouthPane(JInternalFrame w) {
        return null;
    }

    protected JComponent createWestPane(JInternalFrame w) {
        return null;
    }

    protected JComponent createEastPane(JInternalFrame w) {
        return null;
    }


    protected MouseInputAdapter createBorderListener(JInternalFrame w) {
        return new BorderListener();
    }

    private InternalFrameListener getInternalFrameListener(){
        return internalFrameListener;
    }
    
    protected void createInternalFrameListener(){
        internalFrameListener = new BasicInternalFrameListener();
    }

    protected final boolean isKeyBindingRegistered(){
        return keyBindingRegistered;
    }

    protected final void setKeyBindingRegistered(boolean b){
        keyBindingRegistered = b;
    }

    public final boolean isKeyBindingActive(){
        return keyBindingActive;
    }

    protected final void setKeyBindingActive(boolean b){
        keyBindingActive = b;
    }


    protected void setupMenuOpenKey(){
    // PENDING(hania): Why are these WHEN_IN_FOCUSED_WINDOWs? Shouldn't
    // they be WHEN_ANCESTOR_OF_FOCUSED_COMPONENT?
    // Also, no longer registering on the desktopicon, the previous
    // action did nothing.
    InputMap map = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
    SwingUtilities.replaceUIInputMap(frame,
                      JComponent.WHEN_IN_FOCUSED_WINDOW, map);
    //ActionMap actionMap = getActionMap();
    //SwingUtilities.replaceUIActionMap(frame, actionMap);
    }

    protected void setupMenuCloseKey(){
    }      

    public JComponent getNorthPane() {
        return northPane;
    }

    public void setNorthPane(JComponent c) {
        if (northPane != null &&
                northPane instanceof SynthInternalFrameTitlePane) {
            ((SynthInternalFrameTitlePane)northPane).uninstallListeners();
        }
        replacePane(northPane, c);
        northPane = c;
    }

    public JComponent getSouthPane() {
        return southPane;
    }

    public void setSouthPane(JComponent c) {
        southPane = c;
    }

    public JComponent getWestPane() {
        return westPane;
    }

    public void setWestPane(JComponent c) {
        westPane = c;
    }

    public JComponent getEastPane() {
        return eastPane;
    }

    public void setEastPane(JComponent c) {
        eastPane = c;
    }

    public void update(Graphics g, JComponent c) {
        SynthContext context = getContext(c);

        SynthLookAndFeel.update(context, g);
        paint(context, g);
        context.dispose();
    }

    public void paint(Graphics g, JComponent c) {
        SynthContext context = getContext(c);

        paint(context, g);
        context.dispose();
    }

    protected void paint(SynthContext context, Graphics g) {
    }

    class InternalFramePropertyChangeListener implements
            PropertyChangeListener {
        // Detects changes in state from the JInternalFrame and handles
        // actions.
        public void propertyChange(PropertyChangeEvent evt) {
            String prop = (String)evt.getPropertyName();
            JInternalFrame f = (JInternalFrame)evt.getSource();
            Object newValue = evt.getNewValue();
            Object oldValue = evt.getOldValue();
            // ASSERT(frame == f) - This should always be true

            if (SynthLookAndFeel.shouldUpdateStyle(evt)) {
                fetchStyle((JInternalFrame)evt.getSource());
            }
            if (JInternalFrame.IS_CLOSED_PROPERTY.equals(prop)) {
                if (newValue == Boolean.TRUE) {
                    if ((frame.getParent() != null) && componentListenerAdded) {
                        frame.getParent().removeComponentListener(
                            componentListener);
                    }
                    closeFrame(f);
                }
            } else if (JInternalFrame.IS_MAXIMUM_PROPERTY.equals(prop)) {
                if (newValue == Boolean.TRUE) {
                    maximizeFrame(f);
                } else {
                    minimizeFrame(f);
                }
            } else if (JInternalFrame.IS_ICON_PROPERTY.equals(prop)) {
                if (newValue == Boolean.TRUE) {
                    iconifyFrame(f);
                } else {
                    deiconifyFrame(f);
                }
            } else if (JInternalFrame.IS_SELECTED_PROPERTY.equals(prop)) {
                Component glassPane = f.getGlassPane();
                if (newValue == Boolean.TRUE && oldValue == Boolean.FALSE) {
            activateFrame(f);
                    // glassPane.removeMouseListener(glassPaneDispatcher);
                    // glassPane.removeMouseMotionListener(glassPaneDispatcher);
                    glassPane.setVisible(false);
                } else if (newValue == Boolean.FALSE &&
                        oldValue == Boolean.TRUE) {
                    deactivateFrame(f);
                    // glassPane.addMouseListener(glassPaneDispatcher);
                    // glassPane.addMouseMotionListener(glassPaneDispatcher);
                    glassPane.setVisible(true);
                }
            } else if (prop.equals("ancestor")) {
                if (frame.getParent() != null) {
                    parentBounds = f.getParent().getBounds();
                } else {
                    parentBounds = null;
                }
                if ((frame.getParent() != null) && !componentListenerAdded ) {
                    f.getParent().addComponentListener(componentListener);
                    componentListenerAdded = true;
                } else if ((newValue == null) && componentListenerAdded) {
                    if (f.getParent() != null) {
                        f.getParent().removeComponentListener(
                            componentListener);
                    }
                    componentListenerAdded = false;
                }
            } else if (JInternalFrame.TITLE_PROPERTY.equals(prop) ||
                    prop.equals("closable") || prop.equals("iconable") ||
                    prop.equals("maximizable")) {
                Dimension dim = frame.getMinimumSize();
                Dimension frame_dim = frame.getSize();
                if (dim.width > frame_dim.width) {
                    frame.setSize(dim.width, frame_dim.height);
                }
            }
        }
    }

    class InternalFrameLayout implements LayoutManager {
        public void addLayoutComponent(String name, Component c) {}

        public void removeLayoutComponent(Component c) {}    

        public Dimension preferredLayoutSize(Container c)  {
            Dimension result;
            Insets i = frame.getInsets();
            result = new Dimension(frame.getRootPane().getPreferredSize());
            result.width += i.left + i.right;
            result.height += i.top + i.bottom;

            if (getNorthPane() != null) {
                Dimension d = getNorthPane().getPreferredSize();
                result.width = Math.max(d.width, result.width);
                result.height += d.height;
            }

            if (getSouthPane() != null) {
                Dimension d = getSouthPane().getPreferredSize();
                result.width = Math.max(d.width, result.width);
                result.height += d.height;
            }

            if (getEastPane() != null) {
                Dimension d = getEastPane().getPreferredSize();
                result.width += d.width;
                result.height = Math.max(d.height, result.height);
            }

            if (getWestPane() != null) {
                Dimension d = getWestPane().getPreferredSize();
                result.width += d.width;
                result.height = Math.max(d.height, result.height);
            }
            return result;
        }
    
        public Dimension minimumLayoutSize(Container c) {
            // The minimum size of the internal frame only takes into account
            // the title pane since you are allowed to resize the frames to
            // the point where just the title pane is visible.
            Dimension result = new Dimension();
            if (getNorthPane() != null &&
                    getNorthPane() instanceof SynthInternalFrameTitlePane) {
                result = new Dimension(getNorthPane().getMinimumSize());
            }
            Insets i = frame.getInsets();
            result.width += i.left + i.right;
            result.height += i.top + i.bottom;
            return result;
        }
    
        public void layoutContainer(Container c) {
            Insets i = frame.getInsets();
            int cx, cy, cw, ch;
        
            cx = i.left;
            cy = 0;
            cw = frame.getWidth() - i.left - i.right;
            ch = frame.getHeight() - i.bottom;
        
            if (getNorthPane() != null) {
                Dimension size = getNorthPane().getPreferredSize();
		// Ignore insets when placing the title pane
		getNorthPane().setBounds(0, 0, frame.getWidth(), size.height);
                cy += size.height;
                ch -= size.height;
            }

            if (getSouthPane() != null) {
                Dimension size = getSouthPane().getPreferredSize();
                getSouthPane().setBounds(cx, frame.getHeight() - i.bottom - size.height,
					 cw, size.height);
                ch -= size.height;
            }

            if (getWestPane() != null) {
                Dimension size = getWestPane().getPreferredSize();
                getWestPane().setBounds(cx, cy, size.width, ch);
                cw -= size.width;
                cx += size.width;           
            }

            if (getEastPane() != null) {
                Dimension size = getEastPane().getPreferredSize();
                getEastPane().setBounds(cw - size.width, cy, size.width, ch);
                cw -= size.width;           
            }
        
            if (frame.getRootPane() != null) {
                frame.getRootPane().setBounds(cx, cy, cw, ch);
            }
        }
    }

/// DesktopManager methods
    /**
     * Returns the proper DesktopManager. Calls getDesktopPane() to 
     * find the JDesktop component and returns the desktopManager from
     * it. If this fails, it will return a default DesktopManager that 
     * should work in arbitrary parents.
     */
    protected DesktopManager getDesktopManager() {
        if (frame.getDesktopPane() != null &&
                frame.getDesktopPane().getDesktopManager() != null) {
            return frame.getDesktopPane().getDesktopManager();
        }
        if (sharedDesktopManager == null) {
            sharedDesktopManager = createDesktopManager();
        }
        return sharedDesktopManager;
    }
  
    protected DesktopManager createDesktopManager(){
        return new DefaultDesktopManager();
    }
    
    /**
     * This method is called when the user wants to close the frame.
     * The <code>playCloseSound</code> Action is fired.
     * This action is delegated to the desktopManager.
     */
    protected void closeFrame(JInternalFrame f) {
        // Internal Frame Auditory Cue Activation
        SynthLookAndFeel.playSound(f, "InternalFrame.closeSound");
        // delegate to desktop manager
        getDesktopManager().closeFrame(f);
    }

    /**
     * This method is called when the user wants to maximize the frame.
     * The <code>playMaximizeSound</code> Action is fired.
     * This action is delegated to the desktopManager.
     */
    protected void maximizeFrame(JInternalFrame f) {
        // Internal Frame Auditory Cue Activation
        SynthLookAndFeel.playSound(f, "InternalFrame.maximizeSound");
        // delegate to desktop manager
        getDesktopManager().maximizeFrame(f);
    }

    /**
     * This method is called when the user wants to minimize the frame.
     * The <code>playRestoreDownSound</code> Action is fired.
     * This action is delegated to the desktopManager.
     */
    protected void minimizeFrame(JInternalFrame f) {
        // Internal Frame Auditory Cue Activation
        if (!f.isIcon()) {
            // This method seems to regularly get called after an
            // internal frame is iconified. Don't play this sound then.
            SynthLookAndFeel.playSound(f, "InternalFrame.restoreDownSound");
        }
        // delegate to desktop manager
        getDesktopManager().minimizeFrame(f);
    }

    /**
     * This method is called when the user wants to iconify the frame.
     * The <code>playMinimizeSound</code> Action is fired.
     * This action is delegated to the desktopManager.
     */
    protected void iconifyFrame(JInternalFrame f) {
        // Internal Frame Auditory Cue Activation
        SynthLookAndFeel.playSound(f, "InternalFrame.minimizeSound");
        // delegate to desktop manager
        getDesktopManager().iconifyFrame(f);
    }

    /**
     * This method is called when the user wants to deiconify the frame.
     * The <code>playRestoreUpSound</code> Action is fired.
     * This action is delegated to the desktopManager.
     */
    protected void deiconifyFrame(JInternalFrame f) {
        // Internal Frame Auditory Cue Activation
        if (!f.isMaximum()) {
            // This method seems to regularly get called after an
            // internal frame is maximized. Don't play this sound then.
            SynthLookAndFeel.playSound(f, "InternalFrame.restoreUpSound");
        }
        // delegate to desktop manager
        getDesktopManager().deiconifyFrame(f);
    }

    /**
     * This method is called when the frame becomes selected.
     * This action is delegated to the desktopManager.
     */
    protected void activateFrame(JInternalFrame f) {
        getDesktopManager().activateFrame(f);
    }

    /**
     * This method is called when the frame is no longer selected.
     * This action is delegated to the desktopManager.
     */
    protected void deactivateFrame(JInternalFrame f) {
        getDesktopManager().deactivateFrame(f);
    }

    /////////////////////////////////////////////////////////////////////////
    /// Border Listener Class
    /////////////////////////////////////////////////////////////////////////        
    /**
     * Listens for border adjustments.
     */
    protected class BorderListener extends MouseInputAdapter implements
            SwingConstants {
        // _x & _y are the mousePressed location in absolute coordinate system
        int _x, _y;

        // __x & __y are the mousePressed location in source view's
        // coordinate system
        int __x, __y;
        Rectangle startingBounds;
        int resizeDir;

        protected final int RESIZE_NONE  = 0;
        private boolean discardRelease = false;

        int resizeCornerSize = 16;

        public void mouseClicked(MouseEvent e) {
            if (e.getClickCount() > 1 && e.getSource() == getNorthPane()) {
                if (frame.isIconifiable() && frame.isIcon()) {
                    try {
                        frame.setIcon(false);
                    } catch (PropertyVetoException e2) { }
                } else if (frame.isMaximizable()) {
                    if (!frame.isMaximum()) {
                        try {
                            frame.setMaximum(true);
                        } catch (PropertyVetoException e2) { }
                    } else {
                        try {
                            frame.setMaximum(false);
                        } catch (PropertyVetoException e3) { }
                    }
                } 
            }
        }

        public void mouseReleased(MouseEvent e) {
            if (discardRelease) {
                discardRelease = false;
                return;
            }
            if(resizeDir == RESIZE_NONE) {
                getDesktopManager().endDraggingFrame(frame);    
		dragging = false;
            } else {
                Container c = frame.getTopLevelAncestor();
                if (c instanceof JFrame) {
                    ((JFrame)frame.getTopLevelAncestor()).getGlassPane().
                        setCursor(Cursor.getPredefinedCursor(
                            Cursor.DEFAULT_CURSOR));
                    ((JFrame)frame.getTopLevelAncestor()).getGlassPane().
                        setVisible(false);
                } else if (c instanceof JApplet) {
                    ((JApplet)c).getGlassPane().setCursor(
                        Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    ((JApplet)c).getGlassPane().setVisible(false);
                } else if (c instanceof JWindow) {
                    ((JWindow)c).getGlassPane().setCursor(
                        Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    ((JWindow)c).getGlassPane().setVisible(false);
                } else if (c instanceof JDialog) {
                    ((JDialog)c).getGlassPane().setCursor(
                        Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                    ((JDialog)c).getGlassPane().setVisible(false);
                }
                getDesktopManager().endResizingFrame(frame);
            }
            _x = 0;
            _y = 0;
            __x = 0;
            __y = 0;
            startingBounds = null;
            resizeDir = RESIZE_NONE;
        }

        public void mousePressed(MouseEvent e) {
            Point p = SwingUtilities.convertPoint((Component)e.getSource(), 
                e.getX(), e.getY(), null);
            __x = e.getX();
            __y = e.getY();
            _x = p.x;
            _y = p.y;
            startingBounds = frame.getBounds();
            resizeDir = RESIZE_NONE;

            if (!frame.isSelected()) {
                try {
                    frame.setSelected(true);
                } catch (PropertyVetoException e1) { }
            }
	    Insets i = frame.getInsets();

	    Point ep = new Point(__x, __y);
            if (e.getSource() == getNorthPane()) {
		Point np = getNorthPane().getLocation();
		ep.x += np.x;
		ep.y += np.y;
		if (ep.x > i.left && ep.y > i.top && ep.x < frame.getWidth() - i.right) {
		    getDesktopManager().beginDraggingFrame(frame);
		    dragging = true;
		    return;
                }
            }
            if (!frame.isResizable()) {
                return;
            }

	    if (e.getSource() == frame || e.getSource() == getNorthPane()) {
                if (ep.x <= i.left) {
		    if (ep.y < resizeCornerSize + i.top) {
                        resizeDir = NORTH_WEST;
                    } else if (ep.y > frame.getHeight()
                              - resizeCornerSize - i.bottom) {
                        resizeDir = SOUTH_WEST;
                    } else {  
                        resizeDir = WEST;
                    }
                } else if (ep.x >= frame.getWidth() - i.right) {
		    if (ep.y < resizeCornerSize + i.top) {
                        resizeDir = NORTH_EAST;
                    } else if (ep.y > frame.getHeight()
                            - resizeCornerSize - i.bottom) {
                        resizeDir = SOUTH_EAST;
                    } else {               
                        resizeDir = EAST;
                    }
                } else if (ep.y <= i.top) {
		    if (ep.x < resizeCornerSize + i.left) {
                        resizeDir = NORTH_WEST;
                    } else if (ep.x > frame.getWidth() 
                              - resizeCornerSize - i.right) {
                        resizeDir = NORTH_EAST;
                    } else {             
                        resizeDir = NORTH;
                    }
                } else if (ep.y >= frame.getHeight() - i.bottom) {
		    if (ep.x < resizeCornerSize + i.left) {
                        resizeDir = SOUTH_WEST;
                    } else if (ep.x > frame.getWidth()
                              - resizeCornerSize - i.right) {
                        resizeDir = SOUTH_EAST;
                    } else {                
                      resizeDir = SOUTH;
                    }
                } else {
                    // the mouse press happened inside the frame, not in the
                    // border.
                    discardRelease = true;
                    return;
                }
                Cursor s = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
                switch (resizeDir) {
                    case SOUTH:
                        s = Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR);
                        break; 
                    case NORTH:
                        s = Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR);
                        break; 
                    case WEST:
                        s = Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR);
                        break; 
                    case EAST:
                        s = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
                        break; 
                    case SOUTH_EAST:
                        s = Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR);
                        break; 
                    case SOUTH_WEST:
                        s = Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR);
                        break; 
                    case NORTH_WEST:
                        s = Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR);
                        break; 
                    case NORTH_EAST:
                        s = Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR);
                        break;
                } 
                Container c = frame.getTopLevelAncestor();
                if (c instanceof JFrame){
                    ((JFrame)c).getGlassPane().setVisible(true);
                    ((JFrame)c).getGlassPane().setCursor(s);
                } else if (c instanceof JApplet){
                    ((JApplet)c).getGlassPane().setVisible(true);
                    ((JApplet)c).getGlassPane().setCursor(s);
                } else if (c instanceof JWindow){
                    ((JWindow)c).getGlassPane().setVisible(true);
                    ((JWindow)c).getGlassPane().setCursor(s);
                } else if (c instanceof JDialog){
                    ((JDialog)c).getGlassPane().setVisible(true);
                    ((JDialog)c).getGlassPane().setCursor(s);
                }
                getDesktopManager().beginResizingFrame(frame, resizeDir);
                return;
            }
        }

        public void mouseDragged(MouseEvent e) {   
            if ( startingBounds == null ) {
                // (STEVE) Yucky work around for bug ID 4106552
                return;
            }
                                     
            Point p = SwingUtilities.convertPoint((Component)e.getSource(), 
                e.getX(), e.getY(), null);
            int deltaX = _x - p.x;
            int deltaY = _y - p.y;
            Dimension min = frame.getMinimumSize();
            Dimension max = frame.getMaximumSize();
            int newX, newY, newW, newH;
        
            // Handle a MOVE 
            if (dragging) {
                if (frame.isMaximum() || ((e.getModifiers() &
                        InputEvent.BUTTON1_MASK) !=
                        InputEvent.BUTTON1_MASK)) {
                    // don't allow moving of frames if maximixed or left mouse
                    // button was not used.
                    return;
                }
                Insets i = frame.getInsets();
                int pWidth, pHeight;
                Dimension s = frame.getParent().getSize();
                pWidth = s.width;
                pHeight = s.height;

                newX = startingBounds.x - deltaX;
                newY = startingBounds.y - deltaY;

                // Make sure we stay in-bounds
                if (newX + i.left <= -__x) {
                    newX = -__x - i.left;
                }
                if (newY + i.top <= -__y) {
                    newY = -__y - i.top;
                }
                if (newX + __x + i.right > pWidth) {
                    newX = pWidth - __x - i.right;
                }
                if (newY + __y + i.bottom > pHeight) {
                    newY =  pHeight - __y - i.bottom;
                }

                getDesktopManager().dragFrame(frame, newX, newY);
                return;
            }

            if (!frame.isResizable()) {
                return;
            }

            newX = frame.getX();
            newY = frame.getY();
            newW = frame.getWidth();
            newH = frame.getHeight();

            parentBounds = frame.getParent().getBounds();

            switch(resizeDir) {
                case RESIZE_NONE:
                    return;
                case NORTH:      
                    if (startingBounds.height + deltaY < min.height) {
                        deltaY = -(startingBounds.height - min.height);
                    } else if (startingBounds.height + deltaY > max.height) {
                        deltaY = max.height - startingBounds.height;
                    }

                    if (startingBounds.y - deltaY < 0) {
                        deltaY = startingBounds.y;
                    }
                    newX = startingBounds.x;
                    newY = startingBounds.y - deltaY;
                    newW = startingBounds.width;
                    newH = startingBounds.height + deltaY;
                    break;
                case NORTH_EAST:     
                    if (startingBounds.height + deltaY < min.height) {
                        deltaY = -(startingBounds.height - min.height);
                    } else if (startingBounds.height + deltaY > max.height) {
                        deltaY = max.height - startingBounds.height;
                    }

                    if (startingBounds.y - deltaY < 0) {
                        deltaY = startingBounds.y;
                    }

                    if (startingBounds.width - deltaX < min.width) {
                        deltaX = startingBounds.width - min.width;
                    } else if (startingBounds.width - deltaX > max.width) {
                        deltaX = -(max.width - startingBounds.width);
                    }

                    if (startingBounds.x + startingBounds.width - deltaX >
                            parentBounds.width) {
                        deltaX = startingBounds.x + startingBounds.width
                            - parentBounds.width;
                    }
                    newX = startingBounds.x;
                    newY = startingBounds.y - deltaY;
                    newW = startingBounds.width - deltaX;
                    newH = startingBounds.height + deltaY;
                    break;
                case EAST:      
                    if (startingBounds.width - deltaX < min.width) {
                        deltaX = startingBounds.width - min.width;
                    } else if (startingBounds.width - deltaX > max.width) {
                        deltaX = -(max.width - startingBounds.width);
                    }

                    if (startingBounds.x + startingBounds.width - deltaX >
                            parentBounds.width) {
                        deltaX = startingBounds.x + startingBounds.width
                            - parentBounds.width;
                    }
                    newW = startingBounds.width - deltaX;
                    newH = startingBounds.height;
                    break;
                case SOUTH_EAST:     
                    if (startingBounds.width - deltaX < min.width) {
                        deltaX = startingBounds.width - min.width;
                    } else if (startingBounds.width - deltaX > max.width) {
                        deltaX = -(max.width - startingBounds.width);
                    }

                    if (startingBounds.x + startingBounds.width - deltaX >
                            parentBounds.width) {
                        deltaX = startingBounds.x + startingBounds.width
                            - parentBounds.width;
                    }

                    if (startingBounds.height - deltaY < min.height) {
                        deltaY = startingBounds.height - min.height;
                    } else if (startingBounds.height - deltaY > max.height) {
                        deltaY = -(max.height - startingBounds.height);
                    }

                    if (startingBounds.y + startingBounds.height - deltaY >
                            parentBounds.height) {
                        deltaY = startingBounds.y + startingBounds.height
                            - parentBounds.height;
                    }
                    newW = startingBounds.width - deltaX;
                    newH = startingBounds.height - deltaY;
                    break;
                case SOUTH:      
                    if (startingBounds.height - deltaY < min.height) {
                        deltaY = startingBounds.height - min.height;
                    } else if(startingBounds.height - deltaY > max.height) {
                        deltaY = -(max.height - startingBounds.height);
                    }

                    if (startingBounds.y + startingBounds.height - deltaY >
                            parentBounds.height) {
                        deltaY = startingBounds.y + startingBounds.height
                            - parentBounds.height;
                    }
                    newW = startingBounds.width;
                    newH = startingBounds.height - deltaY;
                    break;
                case SOUTH_WEST:
                    if (startingBounds.height - deltaY < min.height) {
                        deltaY = startingBounds.height - min.height;
                    } else if (startingBounds.height - deltaY > max.height) {
                        deltaY = -(max.height - startingBounds.height);
                    }

                    if (startingBounds.y + startingBounds.height - deltaY >
                            parentBounds.height) {
                        deltaY = startingBounds.y + startingBounds.height
                            - parentBounds.height;
                    }

                    if (startingBounds.width + deltaX < min.width) {
                        deltaX = -(startingBounds.width - min.width);
                    } else if (startingBounds.width + deltaX > max.width) {
                        deltaX = max.width - startingBounds.width;
                    }

                    if (startingBounds.x - deltaX < 0) {
                        deltaX = startingBounds.x;
                    }
                    newX = startingBounds.x - deltaX;
                    newY = startingBounds.y;
                    newW = startingBounds.width + deltaX;
                    newH = startingBounds.height - deltaY;
                    break;
                case WEST:      
                    if (startingBounds.width + deltaX < min.width) {
                        deltaX = -(startingBounds.width - min.width);
                    } else if (startingBounds.width + deltaX > max.width) {
                        deltaX = max.width - startingBounds.width;
                    }

                    if (startingBounds.x - deltaX < 0) {
                        deltaX = startingBounds.x;
                    }
                    newX = startingBounds.x - deltaX;
                    newY = startingBounds.y;
                    newW = startingBounds.width + deltaX;
                    newH = startingBounds.height;
                    break;
                case NORTH_WEST:     
                    if (startingBounds.width + deltaX < min.width) {
                        deltaX = -(startingBounds.width - min.width);
                    } else if (startingBounds.width + deltaX > max.width) {
                        deltaX = max.width - startingBounds.width;
                    }

                    if (startingBounds.x - deltaX < 0) {
                        deltaX = startingBounds.x;
                    }

                    if (startingBounds.height + deltaY < min.height) {
                        deltaY = -(startingBounds.height - min.height);
                    } else if(startingBounds.height + deltaY > max.height) {
                        deltaY = max.height - startingBounds.height;
                    }
                    
                    if (startingBounds.y - deltaY < 0) {
                        deltaY = startingBounds.y;
                    }
                    newX = startingBounds.x - deltaX;
                    newY = startingBounds.y - deltaY;
                    newW = startingBounds.width + deltaX;
                    newH = startingBounds.height + deltaY;
                    break;
                default:
                    return;
            }
            getDesktopManager().resizeFrame(frame, newX, newY, newW, newH);
        }

        public void mouseMoved(MouseEvent e) {
            if (!frame.isResizable()) {
                return;
            }
        
            if (e.getSource() == frame || e.getSource() == getNorthPane()) {
                Insets i = frame.getInsets();
                if (e.getX() <= i.left) {
                    if (e.getY() < resizeCornerSize + i.top) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.NW_RESIZE_CURSOR));
                    } else if (e.getY() > frame.getHeight() - resizeCornerSize
                            - i.bottom) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.SW_RESIZE_CURSOR));
                    } else {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.W_RESIZE_CURSOR));
                    }
                } else if (e.getX() >= frame.getWidth() - i.right) {
                    if (e.getY() < resizeCornerSize + i.top) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.NE_RESIZE_CURSOR));
                    } else if (e.getY() > frame.getHeight() - resizeCornerSize
                            - i.bottom) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.SE_RESIZE_CURSOR));
                    } else {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.E_RESIZE_CURSOR));
                    }
                } else if (e.getY() <= i.top) {
                    if (e.getX() < resizeCornerSize + i.left) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.NW_RESIZE_CURSOR));
                    } else if (e.getX() > frame.getWidth() - resizeCornerSize
                            - i.right) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.NE_RESIZE_CURSOR));
                    } else {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.N_RESIZE_CURSOR));
                    }
                } else if (e.getY() >= frame.getHeight() - i.bottom) {
                    if (e.getX() < resizeCornerSize + i.left) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.SW_RESIZE_CURSOR));
                    } else if (e.getX() > frame.getWidth() - resizeCornerSize
                            - i.right) {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.SE_RESIZE_CURSOR));
                    } else {
                        frame.setCursor(Cursor.getPredefinedCursor(
                            Cursor.S_RESIZE_CURSOR));
                    }
                }
                else {
                    frame.setCursor(Cursor.getPredefinedCursor(
                        Cursor.DEFAULT_CURSOR));
                }
                return;
            }
            frame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
        }         

        public void mouseExited(MouseEvent e) {
            frame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
        }
    }    /// End BorderListener Class

    protected class ComponentHandler implements ComponentListener {
        /**
         * Invoked when a JInternalFrame's parent's size changes.
         */
        public void componentResized(ComponentEvent e) {
            // Get the JInternalFrame's parent container size
            Rectangle parentNewBounds = ((Component) e.getSource()).getBounds();
            JInternalFrame.JDesktopIcon icon = null;

            if (frame != null) {
                icon = frame.getDesktopIcon();
                // Resize the internal frame if it is maximized and relocate
                // the associated icon as well.
                if ( frame.isMaximum() ) {
                    frame.setBounds(0, 0, parentNewBounds.width,
                        parentNewBounds.height);
                }
            }

            // Relocate the icon base on the new parent bounds.
            if (icon != null) {
                Rectangle iconBounds = icon.getBounds();
                int y = iconBounds.y
                    + (parentNewBounds.height- parentBounds.height);
                icon.setBounds(iconBounds.x, y, iconBounds.width,
                        iconBounds.height);
            }

            // Update the new parent bounds for next resize.
            if (!parentBounds.equals(parentNewBounds)) {
                parentBounds = parentNewBounds;
            }

            // Validate the component tree for this container.
            if (frame != null) {
                frame.validate();
            }
        }

        /* Unused */
        public void componentMoved(ComponentEvent e) {}
        /* Unused */
        public void componentShown(ComponentEvent e) {}
        /* Unused */
        public void componentHidden(ComponentEvent e) {}
    }
    
    protected ComponentListener createComponentListener() {
        return new ComponentHandler();
    }


    private static boolean isDragging = false;
    protected class GlassPaneDispatcher implements MouseInputListener {
        private Component mouseEventTarget = null;
        private Component dragSource = null;

        /**
         * When inactive, mouse events are forwarded as appropriate either to 
         * the UI to activate the frame or to the underlying child component.
         */
        public void mousePressed(MouseEvent e) {
            // what is going on here is the GlassPane is up on the inactive
            // internalframe and want's to "catch" the first mousePressed on
            // the frame in order to give it to the BorderLister (and not the
            // underlying component) and let it activate the frame
            if (borderListener != null){
                borderListener.mousePressed(e);
            } 
            forwardMouseEvent(e);
        }

        /** 
         * Forward the mouseEntered event to the underlying child container.
         * @see #mousePressed
         */
        public void mouseEntered(MouseEvent e) {
            forwardMouseEvent(e);
        }

        /** 
         * Forward the mouseMoved event to the underlying child container.
         * @see #mousePressed
         */
        public void mouseMoved(MouseEvent e) {
            forwardMouseEvent(e);
        }

        /** 
         * Forward the mouseExited event to the underlying child container.
         * @see #mousePressed
         */
        public void mouseExited(MouseEvent e) {
            forwardMouseEvent(e);
        }

        /** 
         * Ignore mouseClicked events.
         * @see #mousePressed
         */
         public void mouseClicked(MouseEvent e) { }

        /** 
         * Forward the mouseReleased event to the underlying child container.
         * @see #mousePressed
         */
        public void mouseReleased(MouseEvent e) {
            forwardMouseEvent(e);
        }

        /** 
         * Forward the mouseDragged event to the underlying child container.
         * @see #mousePressed
         */
        public void mouseDragged(MouseEvent e) {
            forwardMouseEvent(e);
        }

        /**
         * Forward a mouse event to the current mouse target, setting it
         * if necessary.
         */
        private void forwardMouseEvent(MouseEvent e) {
            // We only want to do this for the selected internal frame.
            Component target =
                findComponentAt(frame.getRootPane().getLayeredPane(), 
                    e.getX(), e.getY());

            int id = e.getID();
            switch(id) {
                case MouseEvent.MOUSE_ENTERED:
                    if (isDragging && !frame.isSelected()) {
                        return;
                    }
                    if (target != mouseEventTarget) {
                        mouseEventTarget = target;
                    }
                    retargetMouseEvent(id, e, mouseEventTarget);
                    break;
                case MouseEvent.MOUSE_PRESSED:
                    if (target != mouseEventTarget) {
                        mouseEventTarget = target;
                    }
                    retargetMouseEvent(id, e, mouseEventTarget);
                    // Set the drag source in case we start dragging.
                    dragSource = target;
                    break;
                case MouseEvent.MOUSE_EXITED:
                    if (isDragging && !frame.isSelected()) {
                        return;
                    }
                    retargetMouseEvent(id, e, mouseEventTarget);
                    break;
                case MouseEvent.MOUSE_CLICKED:
                    retargetMouseEvent(id, e, mouseEventTarget);
                    break;
                case MouseEvent.MOUSE_MOVED:
                    if (target != mouseEventTarget) {
                        retargetMouseEvent(MouseEvent.MOUSE_EXITED, e,
                                mouseEventTarget);
                        mouseEventTarget = target;
                        retargetMouseEvent(MouseEvent.MOUSE_ENTERED, e,
                                mouseEventTarget);
                    }
                    retargetMouseEvent(id, e, mouseEventTarget);
                    break;
                case MouseEvent.MOUSE_DRAGGED:
                    if (!isDragging) {
                        isDragging = true;
                    }
                    retargetMouseEvent(id, e, dragSource);
                    break;
                case MouseEvent.MOUSE_RELEASED:
                    if (isDragging) {
                        retargetMouseEvent(id, e, dragSource);
                        isDragging = false;
                    } else {
                        retargetMouseEvent(id, e, mouseEventTarget);
                    }
            }
        }

        /**
         * Find the lightweight child component which corresponds to the
         * specified location.  This is similar to the new 1.2 API in
         * Container, but we need to run on 1.1.  The other changes are
         * due to Container.findComponentAt's use of package-private data.
         */
        private Component findComponentAt(Container c, int x, int y) {
            if (!c.contains(x, y)) {
                return c;
            }
            int ncomponents = c.getComponentCount();
            Component component[] = c.getComponents();
            for (int i = 0 ; i < ncomponents ; i++) {
                Component comp = component[i];
                Point loc = comp.getLocation();
                if ((comp != null) && (comp.contains(x - loc.x, y - loc.y)) &&
                        (comp.getPeer() instanceof LightweightPeer) &&
                        (comp.isVisible() == true)) {
                    // found a component that intersects the point, see if there
                    // is a deeper possibility.
                    if (comp instanceof Container) {
                        Container child = (Container) comp;
                        Point childLoc = child.getLocation();
                        Component deeper = findComponentAt(child,
                            x - childLoc.x, y - childLoc.y);
                        if (deeper != null) {
                            return deeper;
                        }
                    } else {
                        return comp;
                    }
                }
            }
            return c;
        }
    
        /* 
         * Dispatch an event clone, retargeted for the specified target.
         */
        private void retargetMouseEvent(int id, MouseEvent e,
                Component target) {
            if (target == null) {
                return;
            }
            // fix for bug #4202966 -- hania
            // When retargetting a mouse event, we need to translate
            // the event's coordinates relative to the target.

            Point p = SwingUtilities.convertPoint(frame.getLayeredPane(),
                                                e.getX(), e.getY(),
                                                target);
            MouseEvent retargeted = new MouseEvent(target, 
                id,
                e.getWhen(),
                e.getModifiers() | e.getModifiersEx(),
                p.x,
                p.y,
                e.getClickCount(),
                e.isPopupTrigger());
            target.dispatchEvent(retargeted);
        }
    }

    protected MouseInputListener createGlassPaneDispatcher(){
        return new GlassPaneDispatcher();
    }

    
    protected class BasicInternalFrameListener implements
            InternalFrameListener {
        public void internalFrameClosing(InternalFrameEvent e) { }

        public void internalFrameClosed(InternalFrameEvent e) {
            frame.removeInternalFrameListener(internalFrameListener);      
        }

        public void internalFrameOpened(InternalFrameEvent e) { }

        public void internalFrameIconified(InternalFrameEvent e) { }

        public void internalFrameDeiconified(InternalFrameEvent e) { }

        public void internalFrameActivated(InternalFrameEvent e) {
            if (!isKeyBindingRegistered()) {
                setKeyBindingRegistered(true);
                setupMenuOpenKey();
                setupMenuCloseKey();
            }
            if (isKeyBindingRegistered()) {
                setKeyBindingActive(true);
            }
        }

        public void internalFrameDeactivated(InternalFrameEvent e) {
            setKeyBindingActive(false);
        }
    }
}