/*

 * Copyright 2002-2009 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.awt.X11;

import java.awt.*;

import java.awt.event.ComponentEvent;

import java.awt.event.FocusEvent;

import java.awt.event.WindowEvent;

import java.awt.image.BufferedImage;

import java.awt.peer.ComponentPeer;

import java.awt.peer.WindowPeer;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import java.util.Vector;

import java.util.logging.Level;

import java.util.logging.Logger;

import sun.awt.AWTAccessor;

import sun.awt.ComponentAccessor;

import sun.awt.WindowAccessor;

import sun.awt.DisplayChangedListener;

import sun.awt.SunToolkit;

import sun.awt.X11GraphicsDevice;

import sun.awt.X11GraphicsEnvironment;

import sun.java2d.pipe.Region;

class XWindowPeer extends XPanelPeer implements WindowPeer,

                                                DisplayChangedListener {

    private static final Logger log = Logger.getLogger("sun.awt.X11.XWindowPeer");

    private static final Logger focusLog = Logger.getLogger("sun.awt.X11.focus.XWindowPeer");

    private static final Logger insLog = Logger.getLogger("sun.awt.X11.insets.XWindowPeer");

    private static final Logger grabLog = Logger.getLogger("sun.awt.X11.grab.XWindowPeer");

    private static final Logger iconLog = Logger.getLogger("sun.awt.X11.icon.XWindowPeer");

    // should be synchronized on awtLock

    private static Set<XWindowPeer> windows = new HashSet<XWindowPeer>();

    static XAtom wm_protocols;

    static XAtom wm_delete_window;

    static XAtom wm_take_focus;

    XWindowAttributesData winAttr;

    private boolean cachedFocusableWindow;

    XWarningWindow warningWindow;

    private boolean alwaysOnTop;

    PropMwmHints mwm_hints;

    private boolean locationByPlatform;

    Dialog modalBlocker;

    boolean delayedModalBlocking = false;

    Dimension targetMinimumSize = null;

    private XWindowPeer ownerPeer;

    // used for modal blocking to keep existing z-order

    protected XWindowPeer prevTransientFor, nextTransientFor;

    // value of WM_TRANSIENT_FOR hint set on this window

    private XWindowPeer curRealTransientFor;

    private boolean grab = false; // Whether to do a grab during showing

    private boolean isMapped = false; // Is this window mapped or not

    private boolean stateChanged; // Indicates whether the value on savedState is valid

    private int savedState; // Holds last known state of the top-level window

    private boolean mustControlStackPosition = false; // Am override-redirect not on top

    private XEventDispatcher rootPropertyEventDispatcher = null;

    /*

     * Focus related flags

     */

    private boolean isUnhiding = false;             // Is the window unhiding.

    private boolean isBeforeFirstMapNotify = false; // Is the window (being shown) between

                                                    //    setVisible(true) & handleMapNotify().

    // It need to be accessed from XFramePeer.

    protected Vector <ToplevelStateListener> toplevelStateListeners = new Vector<ToplevelStateListener>();

    XWindowPeer(XCreateWindowParams params) {

        super(params.putIfNull(PARENT_WINDOW, Long.valueOf(0)));

    }

    XWindowPeer(Window target) {

        super(new XCreateWindowParams(new Object[] {

            TARGET, target,

            PARENT_WINDOW, Long.valueOf(0)}));

    }

    /*

     * This constant defines icon size recommended for using.

     * Apparently, we should use XGetIconSizes which should

     * return icon sizes would be most appreciated by the WM.

     * However, XGetIconSizes always returns 0 for some reason.

     * So the constant has been introduced.

     */

    private static final int PREFERRED_SIZE_FOR_ICON = 128;

    /*

     * Sometimes XChangeProperty(_NET_WM_ICON) doesn't work if

     * image buffer is too large. This constant holds maximum

     * length of buffer which can be used with _NET_WM_ICON hint.

     * It holds int's value.

     */

    private static final int MAXIMUM_BUFFER_LENGTH_NET_WM_ICON = (2<<15) - 1;

    void preInit(XCreateWindowParams params) {

        target = (Component)params.get(TARGET);

        params.put(REPARENTED,

                   Boolean.valueOf(isOverrideRedirect() || isSimpleWindow()));

        super.preInit(params);

        params.putIfNull(BIT_GRAVITY, Integer.valueOf(XConstants.NorthWestGravity));

        savedState = XUtilConstants.WithdrawnState;

        XA_NET_WM_STATE = XAtom.get("_NET_WM_STATE");

        winAttr = new XWindowAttributesData();

        params.put(OVERRIDE_REDIRECT, Boolean.valueOf(isOverrideRedirect()));

        SunToolkit.awtLock();

        try {

            windows.add(this);

            if (wm_protocols == null) {

                wm_protocols = XAtom.get("WM_PROTOCOLS");

                wm_delete_window = XAtom.get("WM_DELETE_WINDOW");

                wm_take_focus = XAtom.get("WM_TAKE_FOCUS");

            }

        }

        finally {

            SunToolkit.awtUnlock();

        }

        cachedFocusableWindow = isFocusableWindow();

        Font f = target.getFont();

        if (f == null) {

            f = XWindow.getDefaultFont();

            target.setFont(f);

            // we should not call setFont because it will call a repaint

            // which the peer may not be ready to do yet.

        }

        Color c = target.getBackground();

        if (c == null) {

            Color background = SystemColor.window;

            target.setBackground(background);

            // we should not call setBackGround because it will call a repaint

            // which the peer may not be ready to do yet.

        }

        c = target.getForeground();

        if (c == null) {

            target.setForeground(SystemColor.windowText);

            // we should not call setForeGround because it will call a repaint

            // which the peer may not be ready to do yet.

        }

        alwaysOnTop = ((Window)target).isAlwaysOnTop() && ((Window)target).isAlwaysOnTopSupported();

        GraphicsConfiguration gc = getGraphicsConfiguration();

        ((X11GraphicsDevice)gc.getDevice()).addDisplayChangedListener(this);

        Rectangle bounds = (Rectangle)(params.get(BOUNDS));

        params.put(BOUNDS, constrainBounds(bounds.x, bounds.y, bounds.width, bounds.height));

    }

    private void initWMProtocols() {

        wm_protocols.setAtomListProperty(this, getWMProtocols());

    }

    /**

     * Returns list of protocols which should be installed on this window.

     * Descendants can override this method to add class-specific protocols

     */

    protected XAtomList getWMProtocols() {

        // No protocols on simple window

        return new XAtomList();

    }

    protected String getWMName() {

        String name = target.getName();

        if (name == null || name.trim().equals("")) {

            name = " ";

        }

        return name;

    }

    void postInit(XCreateWindowParams params) {

        super.postInit(params);

        // Init WM_PROTOCOLS atom

        initWMProtocols();

        // Set WM_TRANSIENT_FOR and group_leader

        Window t_window = (Window)target;

        Window owner = t_window.getOwner();

        if (owner != null) {

            ownerPeer = (XWindowPeer)owner.getPeer();

            if (focusLog.isLoggable(Level.FINER)) {

                focusLog.fine("Owner is " + owner);

                focusLog.fine("Owner peer is " + ownerPeer);

                focusLog.fine("Owner X window " + Long.toHexString(ownerPeer.getWindow()));

                focusLog.fine("Owner content X window " + Long.toHexString(ownerPeer.getContentWindow()));

            }

            // as owner window may be an embedded window, we must get a toplevel window

            // to set as TRANSIENT_FOR hint

            long ownerWindow = ownerPeer.getWindow();

            if (ownerWindow != 0) {

                XToolkit.awtLock();

                try {

                    // Set WM_TRANSIENT_FOR

                    if (focusLog.isLoggable(Level.FINE)) focusLog.fine("Setting transient on " + Long.toHexString(getWindow())

                                                                       + " for " + Long.toHexString(ownerWindow));

                    setToplevelTransientFor(this, ownerPeer, false, true);

                    // Set group leader

                    XWMHints hints = getWMHints();

                    hints.set_flags(hints.get_flags() | (int)XUtilConstants.WindowGroupHint);

                    hints.set_window_group(ownerWindow);

                    XlibWrapper.XSetWMHints(XToolkit.getDisplay(), getWindow(), hints.pData);

                }

                finally {

                    XToolkit.awtUnlock();

                }

            }

        }

         // Init warning window(for applets)

        if (((Window)target).getWarningString() != null) {

            // accessSystemTray permission allows to display TrayIcon, TrayIcon tooltip

            // and TrayIcon balloon windows without a warning window.

            if (!WindowAccessor.isTrayIconWindow((Window)target)) {

                warningWindow = new XWarningWindow((Window)target, getWindow());

            }

        }

        setSaveUnder(true);

        updateIconImages();

        updateShape();

        updateOpacity();

        // no need in updateOpaque() as it is no-op

    }

    public void updateIconImages() {

        Window target = (Window)this.target;

        java.util.List<Image> iconImages = ((Window)target).getIconImages();

        XWindowPeer ownerPeer = getOwnerPeer();

        winAttr.icons = new ArrayList<XIconInfo>();

        if (iconImages.size() != 0) {

            //read icon images from target

            winAttr.iconsInherited = false;

            for (Iterator<Image> i = iconImages.iterator(); i.hasNext(); ) {

                Image image = i.next();

                if (image == null) {

                    if (log.isLoggable(Level.FINEST)) {

                        log.finest("XWindowPeer.updateIconImages: Skipping the image passed into Java because it's null.");

                    }

                    continue;

                }

                XIconInfo iconInfo;

                try {

                    iconInfo = new XIconInfo(image);

                } catch (Exception e){

                    if (log.isLoggable(Level.FINEST)) {

                        log.finest("XWindowPeer.updateIconImages: Perhaps the image passed into Java is broken. Skipping this icon.");

                    }

                    continue;

                }

                if (iconInfo.isValid()) {

                    winAttr.icons.add(iconInfo);

                }

            }

        }

        // Fix for CR#6425089

        winAttr.icons = normalizeIconImages(winAttr.icons);

        if (winAttr.icons.size() == 0) {

            //target.icons is empty or all icon images are broken

            if (ownerPeer != null) {

                //icon is inherited from parent

                winAttr.iconsInherited = true;

                winAttr.icons = ownerPeer.getIconInfo();

            } else {

                //default icon is used

                winAttr.iconsInherited = false;

                winAttr.icons = getDefaultIconInfo();

            }

        }

        recursivelySetIcon(winAttr.icons);

    }

    /*

     * Sometimes XChangeProperty(_NET_WM_ICON) doesn't work if

     * image buffer is too large. This function help us accommodate

     * initial list of the icon images to certainly-acceptable.

     * It does scale some of these icons to appropriate size

     * if it's necessary.

     */

    static java.util.List<XIconInfo> normalizeIconImages(java.util.List<XIconInfo> icons) {

        java.util.List<XIconInfo> result = new ArrayList<XIconInfo>();

        int totalLength = 0;

        boolean haveLargeIcon = false;

        for (XIconInfo icon : icons) {

            int width = icon.getWidth();

            int height = icon.getHeight();

            int length = icon.getRawLength();

            if (width > PREFERRED_SIZE_FOR_ICON || height > PREFERRED_SIZE_FOR_ICON) {

                if (haveLargeIcon) {

                    continue;

                }

                int scaledWidth = width;

                int scaledHeight = height;

                while (scaledWidth > PREFERRED_SIZE_FOR_ICON ||

                       scaledHeight > PREFERRED_SIZE_FOR_ICON) {

                    scaledWidth = scaledWidth / 2;

                    scaledHeight = scaledHeight / 2;

                }

                icon.setScaledSize(scaledWidth, scaledHeight);

                length = icon.getRawLength();

            }

            if (totalLength + length <= MAXIMUM_BUFFER_LENGTH_NET_WM_ICON) {

                totalLength += length;

                result.add(icon);

                if (width > PREFERRED_SIZE_FOR_ICON || height > PREFERRED_SIZE_FOR_ICON) {

                    haveLargeIcon = true;

                }

            }

        }

        if (iconLog.isLoggable(Level.FINEST)) {

            iconLog.log(Level.FINEST, ">>> Length_ of buffer of icons data: " + totalLength +

                                      ", maximum length: " + MAXIMUM_BUFFER_LENGTH_NET_WM_ICON);

        }

        return result;

    }

    /*

     * Dumps each icon from the list

     */

    static void dumpIcons(java.util.List<XIconInfo> icons) {

        if (iconLog.isLoggable(Level.FINEST)) {

            iconLog.log(Level.FINEST, ">>> Sizes of icon images:");

            for (Iterator<XIconInfo> i = icons.iterator(); i.hasNext(); ) {

                iconLog.log(Level.FINEST, "    {0}", i.next());

            }

        }

    }

    public void recursivelySetIcon(java.util.List<XIconInfo> icons) {

        dumpIcons(winAttr.icons);

        setIconHints(icons);

        Window target = (Window)this.target;

        Window[] children = target.getOwnedWindows();

        int cnt = children.length;

        for (int i = 0; i < cnt; i++) {

            ComponentPeer childPeer = children[i].getPeer();

            if (childPeer != null && childPeer instanceof XWindowPeer) {

                if (((XWindowPeer)childPeer).winAttr.iconsInherited) {

                    ((XWindowPeer)childPeer).winAttr.icons = icons;

                    ((XWindowPeer)childPeer).recursivelySetIcon(icons);

                }

            }

        }

    }

    java.util.List<XIconInfo> getIconInfo() {

        return winAttr.icons;

    }

    void setIconHints(java.util.List<XIconInfo> icons) {

        //This does nothing for XWindowPeer,

        //It's overriden in XDecoratedPeer

    }

    private static ArrayList<XIconInfo> defaultIconInfo;

    protected synchronized static java.util.List<XIconInfo> getDefaultIconInfo() {

        if (defaultIconInfo == null) {

            defaultIconInfo = new ArrayList<XIconInfo>();

            if (XlibWrapper.dataModel == 32) {

                defaultIconInfo.add(new XIconInfo(XAWTIcon32_java_icon16_png.java_icon16_png));

                defaultIconInfo.add(new XIconInfo(XAWTIcon32_java_icon24_png.java_icon24_png));

                defaultIconInfo.add(new XIconInfo(XAWTIcon32_java_icon32_png.java_icon32_png));

                defaultIconInfo.add(new XIconInfo(XAWTIcon32_java_icon48_png.java_icon48_png));

            } else {

                defaultIconInfo.add(new XIconInfo(XAWTIcon64_java_icon16_png.java_icon16_png));

                defaultIconInfo.add(new XIconInfo(XAWTIcon64_java_icon24_png.java_icon24_png));

                defaultIconInfo.add(new XIconInfo(XAWTIcon64_java_icon32_png.java_icon32_png));

                defaultIconInfo.add(new XIconInfo(XAWTIcon64_java_icon48_png.java_icon48_png));

            }

        }

        return defaultIconInfo;

    }

    private void updateShape() {

        // Shape shape = ((Window)target).getShape();

        Shape shape = AWTAccessor.getWindowAccessor().getShape((Window)target);

        if (shape != null) {

            applyShape(Region.getInstance(shape, null));

        }

    }

    private void updateOpacity() {

        // float opacity = ((Window)target).getOpacity();

        float opacity = AWTAccessor.getWindowAccessor().getOpacity((Window)target);

        if (opacity < 1.0f) {

            setOpacity(opacity);

        }

    }

    public void updateMinimumSize() {

        //This function only saves minimumSize value in XWindowPeer

        //Setting WMSizeHints is implemented in XDecoratedPeer

        targetMinimumSize = (((Component)target).isMinimumSizeSet()) ?

            ((Component)target).getMinimumSize() : null;

    }

    public Dimension getTargetMinimumSize() {

        return (targetMinimumSize == null) ? null : new Dimension(targetMinimumSize);

    }

    public XWindowPeer getOwnerPeer() {

        return ownerPeer;

    }

    // This method is overriden at the XDecoratedPeer to handle

    // decorated windows a bit differently.

    Rectangle constrainBounds(int x, int y, int width, int height) {

        // We don't restrict the setBounds() operation if the code is trusted.

        if (!hasWarningWindow()) {

            return new Rectangle(x, y, width, height);

        }

        // The window bounds should be within the visible part of the screen

        int newX = x;

        int newY = y;

        int newW = width;

        int newH = height;

        // Now check each point is within the visible part of the screen

        GraphicsConfiguration gc = ((Window)target).getGraphicsConfiguration();

        Rectangle sB = gc.getBounds();

        Insets sIn = ((Window)target).getToolkit().getScreenInsets(gc);

        int screenX = sB.x + sIn.left;

        int screenY = sB.y + sIn.top;

        int screenW = sB.width - sIn.left - sIn.right;

        int screenH = sB.height - sIn.top - sIn.bottom;

        // First make sure the size is withing the visible part of the screen

        if (newW > screenW) {

            newW = screenW;

        }

        if (newH > screenH) {

            newH = screenH;

        }

        // Tweak the location if needed

        if (newX < screenX) {

            newX = screenX;

        } else if (newX + newW > screenX + screenW) {

            newX = screenX + screenW - newW;

        }

        if (newY < screenY) {

            newY = screenY;

        } else if (newY + newH > screenY + screenH) {

            newY = screenY + screenH - newH;

        }

        return new Rectangle(newX, newY, newW, newH);

    }

    //Fix for 6318144: PIT:Setting Min Size bigger than current size enlarges

    //the window but fails to revalidate, Sol-CDE

    //This bug is regression for

    //5025858: Resizing a decorated frame triggers componentResized event twice.

    //Since events are not posted from Component.setBounds we need to send them here.

    //Note that this function is overriden in XDecoratedPeer so event

    //posting is not changing for decorated peers

    public void setBounds(int x, int y, int width, int height, int op) {

        Rectangle newBounds = constrainBounds(x, y, width, height);