/*

 * Copyright 2002-2008 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.InvocationEvent;

import java.awt.event.WindowEvent;

import java.util.logging.Level;

import java.util.logging.Logger;

import sun.awt.ComponentAccessor;

import sun.awt.SunToolkit;

abstract class XDecoratedPeer extends XWindowPeer {

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

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

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

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

    // Set to true when we get the first ConfigureNotify after being

    // reparented - indicates that WM has adopted the top-level.

    boolean configure_seen;

    boolean insets_corrected;

    XIconWindow iconWindow;

    WindowDimensions dimensions;

    XContentWindow content;

    Insets currentInsets;

    XFocusProxyWindow focusProxy;

    XDecoratedPeer(Window target) {

        super(target);

    }

    XDecoratedPeer(XCreateWindowParams params) {

        super(params);

    }

    public long getShell() {

        return window;

    }

    public long getContentWindow() {

        return (content == null) ? window : content.getWindow();

    }

    void preInit(XCreateWindowParams params) {

        super.preInit(params);

        winAttr.initialFocus = true;

        currentInsets = new Insets(0,0,0,0);

        applyGuessedInsets();

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

        dimensions = new WindowDimensions(bounds, getRealInsets(), false);

        params.put(BOUNDS, dimensions.getClientRect());

        insLog.log(Level.FINE, "Initial dimensions {0}", new Object[] { dimensions });

        // Deny default processing of these events on the shell - proxy will take care of

        // them instead

        Long eventMask = (Long)params.get(EVENT_MASK);

        params.add(EVENT_MASK, Long.valueOf(eventMask.longValue() & ~(XConstants.FocusChangeMask | XConstants.KeyPressMask | XConstants.KeyReleaseMask)));

    }

    void postInit(XCreateWindowParams params) {

        super.postInit(params);

        // The lines that follow need to be in a postInit, so they

        // happen after the X window is created.

        initResizability();

        updateSizeHints(dimensions);

        XWM.requestWMExtents(getWindow());

        content = XContentWindow.createContent(this);

        if (warningWindow != null) {

            warningWindow.toFront();

        }

        focusProxy = createFocusProxy();

    }

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

        if (!XWM.getWM().setNetWMIcon(this, icons)) {

            if (icons.size() > 0) {

                if (iconWindow == null) {

                    iconWindow = new XIconWindow(this);

                }

                iconWindow.setIconImages(icons);

            }

        }

    }

    public void updateMinimumSize() {

        super.updateMinimumSize();

        updateMinSizeHints();

    }

    private void updateMinSizeHints() {

        if (isResizable()) {

            Dimension minimumSize = getTargetMinimumSize();

            if (minimumSize != null) {

                Insets insets = getRealInsets();

                int minWidth = minimumSize.width - insets.left - insets.right;

                int minHeight = minimumSize.height - insets.top - insets.bottom;

                if (minWidth < 0) minWidth = 0;

                if (minHeight < 0) minHeight = 0;

                setSizeHints(XUtilConstants.PMinSize | (isLocationByPlatform()?0:(XUtilConstants.PPosition | XUtilConstants.USPosition)),

                             getX(), getY(), minWidth, minHeight);

                if (isVisible()) {

                    Rectangle bounds = getShellBounds();

                    int nw = (bounds.width < minWidth) ? minWidth : bounds.width;

                    int nh = (bounds.height < minHeight) ? minHeight : bounds.height;

                    if (nw != bounds.width || nh != bounds.height) {

                        setShellSize(new Rectangle(0, 0, nw, nh));

                    }

                }

            } else {

                boolean isMinSizeSet = isMinSizeSet();

                XWM.removeSizeHints(this, XUtilConstants.PMinSize);

                /* Some WMs need remap to redecorate the window */

                if (isMinSizeSet && isShowing() && XWM.needRemap(this)) {

                    /*

                     * Do the re/mapping at the Xlib level.  Since we essentially

                     * work around a WM bug we don't want this hack to be exposed

                     * to Intrinsics (i.e. don't mess with grabs, callbacks etc).

                     */

                    xSetVisible(false);

                    XToolkit.XSync();

                    xSetVisible(true);

                }

            }

        }

    }

    XFocusProxyWindow createFocusProxy() {

        return new XFocusProxyWindow(this);

    }

    protected XAtomList getWMProtocols() {

        XAtomList protocols = super.getWMProtocols();

        protocols.add(wm_delete_window);

        protocols.add(wm_take_focus);

        return protocols;

    }

    public Graphics getGraphics() {

        return getGraphics(content.surfaceData,

                           ComponentAccessor.getForeground(target),

                           ComponentAccessor.getBackground(target),

                           ComponentAccessor.getFont_NoClientCode(target));

    }

    public void setTitle(String title) {

        if (log.isLoggable(Level.FINE)) log.fine("Title is " + title);

        winAttr.title = title;

        updateWMName();

    }

    protected String getWMName() {

        if (winAttr.title == null || winAttr.title.trim().equals("")) {

            return " ";

        } else {

            return winAttr.title;

        }

    }

    void updateWMName() {

        super.updateWMName();

        String name = getWMName();

        XToolkit.awtLock();

        try {

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

                name = "Java";

            }

            XAtom iconNameAtom = XAtom.get(XAtom.XA_WM_ICON_NAME);

            iconNameAtom.setProperty(getWindow(), name);

            XAtom netIconNameAtom = XAtom.get("_NET_WM_ICON_NAME");

            netIconNameAtom.setPropertyUTF8(getWindow(), name);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    // NOTE: This method may be called by privileged threads.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    public void handleIconify() {

        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_ICONIFIED));

    }

    // NOTE: This method may be called by privileged threads.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    public void handleDeiconify() {

        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_DEICONIFIED));

    }

    public void handleFocusEvent(XEvent xev) {

        super.handleFocusEvent(xev);

        XFocusChangeEvent xfe = xev.get_xfocus();

        // If we somehow received focus events forward it instead to proxy

        // FIXME: Shouldn't we instead check for inferrior?

        focusLog.finer("Received focus event on shell: " + xfe);

//         focusProxy.xRequestFocus();

   }

/***************************************************************************************

 *                             I N S E T S   C O D E

 **************************************************************************************/

    protected boolean isInitialReshape() {

        return false;

    }

    private static Insets difference(Insets i1, Insets i2) {

        return new Insets(i1.top-i2.top, i1.left - i2.left, i1.bottom-i2.bottom, i1.right-i2.right);

    }

    private static boolean isNull(Insets i) {

        return (i == null) || ((i.left | i.top | i.right | i.bottom) == 0);

    }

    private static Insets copy(Insets i) {

        return new Insets(i.top, i.left, i.bottom, i.right);

    }

    // insets which we get from WM (e.g from _NET_FRAME_EXTENTS)

    private Insets wm_set_insets;

    private Insets getWMSetInsets(XAtom changedAtom) {

        if (isEmbedded()) {

            return null;

        }

        if (wm_set_insets != null) {

            return wm_set_insets;

        }

        if (changedAtom == null) {

            wm_set_insets = XWM.getInsetsFromExtents(getWindow());

        } else {

            wm_set_insets = XWM.getInsetsFromProp(getWindow(), changedAtom);

        }

        insLog.log(Level.FINER, "FRAME_EXTENTS: {0}", new Object[]{wm_set_insets});

        if (wm_set_insets != null) {

            wm_set_insets = copy(wm_set_insets);

        }

        return wm_set_insets;

    }

    private void resetWMSetInsets() {

        wm_set_insets = null;

    }

    public void handlePropertyNotify(XEvent xev) {

        super.handlePropertyNotify(xev);

        XPropertyEvent ev = xev.get_xproperty();

        if (ev.get_atom() == XWM.XA_KDE_NET_WM_FRAME_STRUT.getAtom()

            || ev.get_atom() == XWM.XA_NET_FRAME_EXTENTS.getAtom())

        {

            getWMSetInsets(XAtom.get(ev.get_atom()));

        }

    }

    long reparent_serial = 0;

    public void handleReparentNotifyEvent(XEvent xev) {

        XReparentEvent  xe = xev.get_xreparent();

        if (insLog.isLoggable(Level.FINE)) insLog.fine(xe.toString());

        reparent_serial = xe.get_serial();

        XToolkit.awtLock();

        try {

            long root = XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber());

            if (isEmbedded()) {

                setReparented(true);

                insets_corrected = true;

                return;

            }

            Component t = (Component)target;

            if (getDecorations() == XWindowAttributesData.AWT_DECOR_NONE) {

                setReparented(true);

                insets_corrected = true;

                reshape(dimensions, SET_SIZE, false);

            } else if (xe.get_parent() == root) {

                configure_seen = false;

                insets_corrected = false;

                /*

                 * We can be repareted to root for two reasons:

                 *   . setVisible(false)

                 *   . WM exited

                 */

                if (isVisible()) { /* WM exited */

                    /* Work around 4775545 */

                    XWM.getWM().unshadeKludge(this);

                    insLog.fine("- WM exited");

                } else {

                    insLog.fine(" - reparent due to hide");

                }

            } else { /* reparented to WM frame, figure out our insets */

                setReparented(true);

                insets_corrected = false;

                // Check if we have insets provided by the WM

                Insets correctWM = getWMSetInsets(null);

                if (correctWM != null) {

                    insLog.log(Level.FINER, "wm-provided insets {0}", new Object[]{correctWM});

                    // If these insets are equal to our current insets - no actions are necessary

                    Insets dimInsets = dimensions.getInsets();

                    if (correctWM.equals(dimInsets)) {

                        insLog.finer("Insets are the same as estimated - no additional reshapes necessary");

                        no_reparent_artifacts = true;

                        insets_corrected = true;

                        applyGuessedInsets();

                        return;

                    }

                } else {

                    correctWM = XWM.getWM().getInsets(this, xe.get_window(), xe.get_parent());

                    if (correctWM != null) {

                        insLog.log(Level.FINER, "correctWM {0}", new Object[] {correctWM});

                    } else {

                        insLog.log(Level.FINER, "correctWM insets are not available, waiting for configureNotify");

                    }

                }

                if (correctWM != null) {

                    handleCorrectInsets(correctWM);

                }

            }

        } finally {

            XToolkit.awtUnlock();

        }

    }

    protected void handleCorrectInsets(Insets correctWM) {

        XToolkit.awtLock();

        try {

            /*

             * Ok, now see if we need adjust window size because

             * initial insets were wrong (most likely they were).

             */

            Insets correction = difference(correctWM, currentInsets);

            insLog.log(Level.FINEST, "Corrention {0}", new Object[] {correction});

            if (!isNull(correction)) {

                currentInsets = copy(correctWM);

                applyGuessedInsets();

                //Fix for 6318109: PIT: Min Size is not honored properly when a

                //smaller size is specified in setSize(), XToolkit

                //update minimum size hints

                updateMinSizeHints();

            }

            if (insLog.isLoggable(Level.FINER)) insLog.finer("Dimensions before reparent: " + dimensions);

            dimensions.setInsets(getRealInsets());

            insets_corrected = true;

            if (isMaximized() || isNull(correction)) {

                return;

            }

            /*

             * If this window has been sized by a pack() we need

             * to keep the interior geometry intact.  Since pack()

             * computed width and height with wrong insets, we

             * must adjust the target dimensions appropriately.

             */

            if ((getHints().get_flags() & (XUtilConstants.USPosition | XUtilConstants.PPosition)) != 0) {

                reshape(dimensions, SET_BOUNDS, false);

            } else {

                reshape(dimensions, SET_SIZE, false);

            }

        } finally {

            XToolkit.awtUnlock();

        }

    }

    public void handleMoved(WindowDimensions dims) {

        Point loc = dims.getLocation();

        ComponentAccessor.setX((Component)target, loc.x);

        ComponentAccessor.setY((Component)target, loc.y);

        postEvent(new ComponentEvent(target, ComponentEvent.COMPONENT_MOVED));

    }

    protected Insets guessInsets() {

        if (isEmbedded() || isTargetUndecorated()) {

            return new Insets(0, 0, 0, 0);

        } else {

            if (!isNull(currentInsets)) {

                /* insets were set on wdata by System Properties */

                return copy(currentInsets);

            } else {

                Insets res = getWMSetInsets(null);

                if (res == null) {

                    res = XWM.getWM().guessInsets(this);

                }

                return res;

            }

        }

    }

    private void applyGuessedInsets() {

        Insets guessed = guessInsets();

        currentInsets = copy(guessed);

    }

    public void revalidate() {

        XToolkit.executeOnEventHandlerThread(target, new Runnable() {

                public void run() {

                    target.invalidate();

                    target.validate();

                }

            });

    }

    Insets getRealInsets() {

        if (isNull(currentInsets)) {

            applyGuessedInsets();

        }

        return currentInsets;

    }

    public Insets getInsets() {

        Insets in = copy(getRealInsets());

        in.top += getMenuBarHeight() + getWarningWindowHeight();

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

            insLog.log(Level.FINEST, "Get insets returns {0}", new Object[] {in});

        }

        return in;

    }

    boolean gravityBug() {

        return XWM.configureGravityBuggy();

    }

    // The height of area used to display current active input method

    int getInputMethodHeight() {

        return 0;

    }

    void updateSizeHints(WindowDimensions dims) {

        Rectangle rec = dims.getClientRect();

        checkShellRect(rec);

        updateSizeHints(rec.x, rec.y, rec.width, rec.height);

    }

    void updateSizeHints() {

        updateSizeHints(dimensions);

    }

    // Coordinates are that of the target

    // Called only on Toolkit thread

    public void reshape(WindowDimensions newDimensions, int op,

                        boolean userReshape)

    {

        if (insLog.isLoggable(Level.FINE)) {

            insLog.fine("Reshaping " + this + " to " + newDimensions + " op " + op + " user reshape " + userReshape);

        }

        if (userReshape) {

            // We handle only userReshape == true cases. It means that

            // if the window manager or any other part of the windowing

            // system sets inappropriate size for this window, we can

            // do nothing but accept it.

            Rectangle reqBounds = newDimensions.getBounds();

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

            newDimensions = new WindowDimensions(newBounds, newDimensions.getInsets(), newDimensions.isClientSizeSet());

        }

        XToolkit.awtLock();

        try {

            if (!isReparented() || !isVisible()) {

                insLog.log(Level.FINE, "- not reparented({0}) or not visible({1}), default reshape",

                           new Object[] {Boolean.valueOf(isReparented()), Boolean.valueOf(visible)});

                // Fix for 6323293.

                // This actually is needed to preserve compatibility with previous releases -

                // some of licensees are expecting componentMoved event on invisible one while

                // its location changes.

                Point oldLocation = getLocation();

                Point newLocation = new Point(ComponentAccessor.getX((Component)target),

                                              ComponentAccessor.getY((Component)target));

                if (!newLocation.equals(oldLocation)) {

                    handleMoved(newDimensions);

                }

                dimensions = new WindowDimensions(newDimensions);

                updateSizeHints(dimensions);

                Rectangle client = dimensions.getClientRect();

                checkShellRect(client);

                setShellBounds(client);