/*

 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.awt.X11;

import java.awt.*;

import sun.awt.*;

import java.util.*;

import sun.util.logging.PlatformLogger;

public class XBaseWindow {

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XBaseWindow");

    private static final PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XBaseWindow");

    private static final PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XBaseWindow");

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XBaseWindow");

    private static final PlatformLogger grabLog = PlatformLogger.getLogger("sun.awt.X11.grab.XBaseWindow");

    public static final String

        PARENT_WINDOW = "parent window", // parent window, Long

        BOUNDS = "bounds", // bounds of the window, Rectangle

        OVERRIDE_REDIRECT = "overrideRedirect", // override_redirect setting, Boolean

        EVENT_MASK = "event mask", // event mask, Integer

        VALUE_MASK = "value mask", // value mask, Long

        BORDER_PIXEL = "border pixel", // border pixel value, Integer

        COLORMAP = "color map", // color map, Long

        DEPTH = "visual depth", // depth, Integer

        VISUAL_CLASS = "visual class", // visual class, Integer

        VISUAL = "visual", // visual, Long

        EMBEDDED = "embedded", // is embedded?, Boolean

        DELAYED = "delayed", // is creation delayed?, Boolean

        PARENT = "parent", // parent peer

        BACKGROUND_PIXMAP = "pixmap", // background pixmap

        VISIBLE = "visible", // whether it is visible by default

        SAVE_UNDER = "save under", // save content under this window

        BACKING_STORE = "backing store", // enables double buffering

        BIT_GRAVITY = "bit gravity"; // copy old content on geometry change

    private XCreateWindowParams delayedParams;

    Set<Long> children = new HashSet<Long>();

    long window;

    boolean visible;

    boolean mapped;

    boolean embedded;

    Rectangle maxBounds;

    volatile XBaseWindow parentWindow;

    private boolean disposed;

    private long screen;

    private XSizeHints hints;

    private XWMHints wmHints;

    final static int MIN_SIZE = 1;

    final static int DEF_LOCATION = 1;

    private static XAtom wm_client_leader;

    static enum InitialiseState {

        INITIALISING,

        NOT_INITIALISED,

        INITIALISED,

        FAILED_INITIALISATION

    };

    private InitialiseState initialising;

    int x;

    int y;

    int width;

    int height;

    void awtLock() {

        XToolkit.awtLock();

    }

    void awtUnlock() {

        XToolkit.awtUnlock();

    }

    void awtLockNotifyAll() {

        XToolkit.awtLockNotifyAll();

    }

    void awtLockWait() throws InterruptedException {

        XToolkit.awtLockWait();

    }

    // To prevent errors from overriding obsolete methods

    protected final void init(long parentWindow, Rectangle bounds) {}

    protected final void preInit() {}

    protected final void postInit() {}

    // internal lock for synchronizing state changes and paint calls, initialized in preInit.

    // the order with other locks: AWTLock -> stateLock

    static class StateLock extends Object { }

    protected StateLock state_lock;

    /**

     * Called for delayed inits during construction

     */

    void instantPreInit(XCreateWindowParams params) {

        state_lock = new StateLock();

        initialising = InitialiseState.NOT_INITIALISED;

    }

    /**

     * Called before window creation, descendants should override to initialize the data,

     * initialize params.

     */

    void preInit(XCreateWindowParams params) {

        state_lock = new StateLock();

        initialising = InitialiseState.NOT_INITIALISED;

        embedded = Boolean.TRUE.equals(params.get(EMBEDDED));

        visible = Boolean.TRUE.equals(params.get(VISIBLE));

        Object parent = params.get(PARENT);

        if (parent instanceof XBaseWindow) {

            parentWindow = (XBaseWindow)parent;

        } else {

            Long parentWindowID = (Long)params.get(PARENT_WINDOW);

            if (parentWindowID != null) {

                parentWindow = XToolkit.windowToXWindow(parentWindowID);

            }

        }

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

        if (eventMask != null) {

            long mask = eventMask.longValue();

            mask |= XConstants.SubstructureNotifyMask;

            params.put(EVENT_MASK, mask);

        }

        screen = -1;

    }

    /**

     * Called after window creation, descendants should override to initialize Window

     * with class-specific values and perform post-initialization actions.

     */

    void postInit(XCreateWindowParams params) {

        if (log.isLoggable(PlatformLogger.Level.FINE)) {

            log.fine("WM name is " + getWMName());

        }

        updateWMName();

        // Set WM_CLIENT_LEADER property

        initClientLeader();

    }

    /**

     * Creates window using parameters <code>params</code>

     * If params contain flag DELAYED doesn't do anything.

     * Note: Descendants can call this method to create the window

     * at the time different to instance construction.

     */

    protected final void init(XCreateWindowParams params) {

        awtLock();

        initialising = InitialiseState.INITIALISING;

        awtUnlock();

        try {

            if (!Boolean.TRUE.equals(params.get(DELAYED))) {

                preInit(params);

                create(params);

                postInit(params);

            } else {

                instantPreInit(params);

                delayedParams = params;

            }

            awtLock();

            initialising = InitialiseState.INITIALISED;

            awtLockNotifyAll();

            awtUnlock();

        } catch (RuntimeException re) {

            awtLock();

            initialising = InitialiseState.FAILED_INITIALISATION;

            awtLockNotifyAll();

            awtUnlock();

            throw re;

        } catch (Throwable t) {

            log.warning("Exception during peer initialization", t);

            awtLock();

            initialising = InitialiseState.FAILED_INITIALISATION;

            awtLockNotifyAll();

            awtUnlock();

        }

    }

    public boolean checkInitialised() {

        awtLock();

        try {

            switch (initialising) {

              case INITIALISED:

                  return true;

              case INITIALISING:

                  try {

                      while (initialising != InitialiseState.INITIALISED) {

                          awtLockWait();

                      }

                  } catch (InterruptedException ie) {

                      return false;

                  }

                  return true;

              case NOT_INITIALISED:

              case FAILED_INITIALISATION:

                  return false;

              default:

                  return false;

            }

        } finally {

            awtUnlock();

        }

    }

    /*

     * Creates an invisible InputOnly window without an associated Component.

     */

    XBaseWindow() {

        this(new XCreateWindowParams());

    }

    /**

     * Creates normal child window

     */

    XBaseWindow(long parentWindow, Rectangle bounds) {

        this(new XCreateWindowParams(new Object[] {

            BOUNDS, bounds,

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

    }

    /**

     * Creates top-level window

     */

    XBaseWindow(Rectangle bounds) {

        this(new XCreateWindowParams(new Object[] {

            BOUNDS, bounds

        }));

    }

    public XBaseWindow (XCreateWindowParams params) {

        init(params);

    }

    /* This create is used by the XEmbeddedFramePeer since it has to create the window

       as a child of the netscape window. This netscape window is passed in as wid */

    XBaseWindow(long parentWindow) {

        this(new XCreateWindowParams(new Object[] {

            PARENT_WINDOW, Long.valueOf(parentWindow),

            EMBEDDED, Boolean.TRUE

        }));

    }

    /**

     * Verifies that all required parameters are set. If not, sets them to default values.

     * Verifies values of critical parameters, adjust their values when needed.

     * @throws IllegalArgumentException if params is null

     */

    protected void checkParams(XCreateWindowParams params) {

        if (params == null) {

            throw new IllegalArgumentException("Window creation parameters are null");

        }

        params.putIfNull(PARENT_WINDOW, Long.valueOf(XToolkit.getDefaultRootWindow()));

        params.putIfNull(BOUNDS, new Rectangle(DEF_LOCATION, DEF_LOCATION, MIN_SIZE, MIN_SIZE));

        params.putIfNull(DEPTH, Integer.valueOf((int)XConstants.CopyFromParent));

        params.putIfNull(VISUAL, Long.valueOf(XConstants.CopyFromParent));

        params.putIfNull(VISUAL_CLASS, Integer.valueOf(XConstants.InputOnly));

        params.putIfNull(VALUE_MASK, Long.valueOf(XConstants.CWEventMask));

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

        bounds.width = Math.max(MIN_SIZE, bounds.width);

        bounds.height = Math.max(MIN_SIZE, bounds.height);

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

        long eventMask = eventMaskObj != null ? eventMaskObj.longValue() : 0;

        // We use our own synthetic grab see XAwtState.getGrabWindow()

        // (see X vol. 1, 8.3.3.2)

        eventMask |= XConstants.PropertyChangeMask | XConstants.OwnerGrabButtonMask;

        params.put(EVENT_MASK, Long.valueOf(eventMask));

    }

    /**

     * Creates window with parameters specified by <code>params</code>

     * @see #init

     */

    private final void create(XCreateWindowParams params) {

        XToolkit.awtLock();

        try {

            XSetWindowAttributes xattr = new XSetWindowAttributes();

            try {

                checkParams(params);

                long value_mask = ((Long)params.get(VALUE_MASK)).longValue();

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

                xattr.set_event_mask(eventMask.longValue());

                value_mask |= XConstants.CWEventMask;

                Long border_pixel = (Long)params.get(BORDER_PIXEL);

                if (border_pixel != null) {

                    xattr.set_border_pixel(border_pixel.longValue());

                    value_mask |= XConstants.CWBorderPixel;

                }

                Long colormap = (Long)params.get(COLORMAP);

                if (colormap != null) {

                    xattr.set_colormap(colormap.longValue());

                    value_mask |= XConstants.CWColormap;

                }

                Long background_pixmap = (Long)params.get(BACKGROUND_PIXMAP);

                if (background_pixmap != null) {

                    xattr.set_background_pixmap(background_pixmap.longValue());

                    value_mask |= XConstants.CWBackPixmap;

                }

                Long parentWindow = (Long)params.get(PARENT_WINDOW);

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

                Integer depth = (Integer)params.get(DEPTH);

                Integer visual_class = (Integer)params.get(VISUAL_CLASS);

                Long visual = (Long)params.get(VISUAL);

                Boolean overrideRedirect = (Boolean)params.get(OVERRIDE_REDIRECT);

                if (overrideRedirect != null) {

                    xattr.set_override_redirect(overrideRedirect.booleanValue());

                    value_mask |= XConstants.CWOverrideRedirect;

                }

                Boolean saveUnder = (Boolean)params.get(SAVE_UNDER);

                if (saveUnder != null) {

                    xattr.set_save_under(saveUnder.booleanValue());

                    value_mask |= XConstants.CWSaveUnder;

                }

                Integer backingStore = (Integer)params.get(BACKING_STORE);

                if (backingStore != null) {

                    xattr.set_backing_store(backingStore.intValue());

                    value_mask |= XConstants.CWBackingStore;

                }

                Integer bitGravity = (Integer)params.get(BIT_GRAVITY);

                if (bitGravity != null) {

                    xattr.set_bit_gravity(bitGravity.intValue());

                    value_mask |= XConstants.CWBitGravity;

                }

                if (log.isLoggable(PlatformLogger.Level.FINE)) {

                    log.fine("Creating window for " + this + " with the following attributes: \n" + params);

                }

                window = XlibWrapper.XCreateWindow(XToolkit.getDisplay(),

                                   parentWindow.longValue(),

                                   bounds.x, bounds.y, // location

                                   bounds.width, bounds.height, // size

                                   0, // border

                                   depth.intValue(), // depth

                                   visual_class.intValue(), // class

                                   visual.longValue(), // visual

                                   value_mask,  // value mask

                                   xattr.pData); // attributes

                if (window == 0) {

                    throw new IllegalStateException("Couldn't create window because of wrong parameters. Run with NOISY_AWT to see details");

                }

                XToolkit.addToWinMap(window, this);

            } finally {

                xattr.dispose();

            }

        } finally {

            XToolkit.awtUnlock();

        }

    }

    public XCreateWindowParams getDelayedParams() {

        return delayedParams;

    }

    protected String getWMName() {

        return XToolkit.getCorrectXIDString(getClass().getName());

    }

    protected void initClientLeader() {

        XToolkit.awtLock();

        try {

            if (wm_client_leader == null) {

                wm_client_leader = XAtom.get("WM_CLIENT_LEADER");

            }

            wm_client_leader.setWindowProperty(this, getXAWTRootWindow());

        } finally {

            XToolkit.awtUnlock();

        }

    }

    static XRootWindow getXAWTRootWindow() {

        return XRootWindow.getInstance();

    }

    void destroy() {

        XToolkit.awtLock();

        try {

            if (hints != null) {

                XlibWrapper.XFree(hints.pData);

                hints = null;

            }

            XToolkit.removeFromWinMap(getWindow(), this);

            XlibWrapper.XDestroyWindow(XToolkit.getDisplay(), getWindow());

            if (XPropertyCache.isCachingSupported()) {

                XPropertyCache.clearCache(window);

            }

            window = -1;

            if( !isDisposed() ) {

                setDisposed( true );

            }

            XAwtState.getGrabWindow(); // Magic - getGrabWindow clear state if grabbing window is disposed of.

        } finally {

            XToolkit.awtUnlock();

        }

    }

    void flush() {

        XToolkit.awtLock();

        try {

            XlibWrapper.XFlush(XToolkit.getDisplay());

        } finally {

            XToolkit.awtUnlock();

        }

    }

    /**

     * Helper function to set W

     */

    public final void setWMHints(XWMHints hints) {

        XToolkit.awtLock();

        try {

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

        } finally {

            XToolkit.awtUnlock();

        }

    }

    public XWMHints getWMHints() {

        if (wmHints == null) {

            wmHints = new XWMHints(XlibWrapper.XAllocWMHints());

//              XlibWrapper.XGetWMHints(XToolkit.getDisplay(),

//                                      getWindow(),

//                                      wmHints.pData);

        }

        return wmHints;

    }

    /*

     * Call this method under AWTLock.

     * The lock should be acquired untill all operations with XSizeHints are completed.

     */

    public XSizeHints getHints() {

        if (hints == null) {

            long p_hints = XlibWrapper.XAllocSizeHints();

            hints = new XSizeHints(p_hints);

//              XlibWrapper.XGetWMNormalHints(XToolkit.getDisplay(), getWindow(), p_hints, XlibWrapper.larg1);

            // TODO: Shouldn't we listen for WM updates on this property?

        }

        return hints;

    }

    public void setSizeHints(long flags, int x, int y, int width, int height) {

        if (insLog.isLoggable(PlatformLogger.Level.FINER)) {

            insLog.finer("Setting hints, flags " + XlibWrapper.hintsToString(flags));

        }

        XToolkit.awtLock();

        try {

            XSizeHints hints = getHints();

            // Note: if PPosition is not set in flags this means that

            // we want to reset PPosition in hints.  This is necessary

            // for locationByPlatform functionality

            if ((flags & XUtilConstants.PPosition) != 0) {

                hints.set_x(x);

                hints.set_y(y);

            }

            if ((flags & XUtilConstants.PSize) != 0) {

                hints.set_width(width);

                hints.set_height(height);

            } else if ((hints.get_flags() & XUtilConstants.PSize) != 0) {

                flags |= XUtilConstants.PSize;

            }

            if ((flags & XUtilConstants.PMinSize) != 0) {

                hints.set_min_width(width);

                hints.set_min_height(height);

            } else if ((hints.get_flags() & XUtilConstants.PMinSize) != 0) {

                flags |= XUtilConstants.PMinSize;

                //Fix for 4320050: Minimum size for java.awt.Frame is not being enforced.

                //We don't need to reset minimum size if it's already set

            }

            if ((flags & XUtilConstants.PMaxSize) != 0) {

                if (maxBounds != null) {

                    if (maxBounds.width != Integer.MAX_VALUE) {

                        hints.set_max_width(maxBounds.width);

                    } else {

                        hints.set_max_width(XToolkit.getDefaultScreenWidth());

                    }

                    if (maxBounds.height != Integer.MAX_VALUE) {

                        hints.set_max_height(maxBounds.height);

                    } else {

                        hints.set_max_height(XToolkit.getDefaultScreenHeight());