/*

 * Copyright (c) 2011, 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.lwawt;

import java.awt.*;

import java.awt.event.*;

import java.awt.peer.*;

import java.util.List;

import javax.swing.*;

import sun.awt.*;

import sun.java2d.*;

import sun.java2d.loops.Blit;

import sun.java2d.loops.CompositeType;

import sun.java2d.pipe.Region;

import sun.util.logging.PlatformLogger;

public class LWWindowPeer

    extends LWContainerPeer<Window, JComponent>

    implements FramePeer, DialogPeer, FullScreenCapable, DisplayChangedListener, PlatformEventNotifier

{

    public enum PeerType {

        SIMPLEWINDOW,

        FRAME,

        DIALOG,

        EMBEDDED_FRAME,

        VIEW_EMBEDDED_FRAME,

        LW_FRAME

    }

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.lwawt.focus.LWWindowPeer");

    private final PlatformWindow platformWindow;

    private static final int MINIMUM_WIDTH = 1;

    private static final int MINIMUM_HEIGHT = 1;

    private Insets insets = new Insets(0, 0, 0, 0);

    private GraphicsDevice graphicsDevice;

    private GraphicsConfiguration graphicsConfig;

    private SurfaceData surfaceData;

    private final Object surfaceDataLock = new Object();

    private volatile int windowState = Frame.NORMAL;

    // check that the mouse is over the window

    private volatile boolean isMouseOver = false;

    // A peer where the last mouse event came to. Used by cursor manager to

    // find the component under cursor

    private static volatile LWComponentPeer<?, ?> lastCommonMouseEventPeer;

    // A peer where the last mouse event came to. Used to generate

    // MOUSE_ENTERED/EXITED notifications

    private volatile LWComponentPeer<?, ?> lastMouseEventPeer;

    // Peers where all dragged/released events should come to,

    // depending on what mouse button is being dragged according to Cocoa

    private static final LWComponentPeer<?, ?>[] mouseDownTarget = new LWComponentPeer<?, ?>[3];

    // A bitmask that indicates what mouse buttons produce MOUSE_CLICKED events

    // on MOUSE_RELEASE. Click events are only generated if there were no drag

    // events between MOUSE_PRESSED and MOUSE_RELEASED for particular button

    private static int mouseClickButtons = 0;

    private volatile boolean isOpaque = true;

    private static final Font DEFAULT_FONT = new Font("Lucida Grande", Font.PLAIN, 13);

    private static LWWindowPeer grabbingWindow;

    private volatile boolean skipNextFocusChange;

    private static final Color nonOpaqueBackground = new Color(0, 0, 0, 0);

    private volatile boolean textured;

    private final PeerType peerType;

    private final SecurityWarningWindow warningWindow;

    /**

     * Current modal blocker or null.

     *

     * Synchronization: peerTreeLock.

     */

    private LWWindowPeer blocker;

    public LWWindowPeer(Window target, PlatformComponent platformComponent,

                        PlatformWindow platformWindow, PeerType peerType)

    {

        super(target, platformComponent);

        this.platformWindow = platformWindow;

        this.peerType = peerType;

        Window owner = target.getOwner();

        LWWindowPeer ownerPeer = owner == null ? null :

             (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(owner);

        PlatformWindow ownerDelegate = (ownerPeer != null) ? ownerPeer.getPlatformWindow() : null;

        // The delegate.initialize() needs a non-null GC on X11.

        GraphicsConfiguration gc = getTarget().getGraphicsConfiguration();

        synchronized (getStateLock()) {

            // graphicsConfig should be updated according to the real window

            // bounds when the window is shown, see 4868278

            this.graphicsConfig = gc;

        }

        if (!target.isFontSet()) {

            target.setFont(DEFAULT_FONT);

        }

        if (!target.isBackgroundSet()) {

            target.setBackground(SystemColor.window);

        } else {

            // first we check if user provided alpha for background. This is

            // similar to what Apple's Java do.

            // Since JDK7 we should rely on setOpacity() only.

            // this.opacity = c.getAlpha();

        }

        if (!target.isForegroundSet()) {

            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.

        }

        platformWindow.initialize(target, this, ownerDelegate);

        // Init warning window(for applets)

        SecurityWarningWindow warn = null;

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

            // accessSystemTray permission allows to display TrayIcon, TrayIcon tooltip

            // and TrayIcon balloon windows without a warning window.

            if (!AWTAccessor.getWindowAccessor().isTrayIconWindow(target)) {

                LWToolkit toolkit = (LWToolkit)Toolkit.getDefaultToolkit();

                warn = toolkit.createSecurityWarning(target, this);

            }

        }

        warningWindow = warn;

    }

    @Override

    void initializeImpl() {

        super.initializeImpl();

        if (getTarget() instanceof Frame) {

            setTitle(((Frame) getTarget()).getTitle());

            setState(((Frame) getTarget()).getExtendedState());

        } else if (getTarget() instanceof Dialog) {

            setTitle(((Dialog) getTarget()).getTitle());

        }

        updateAlwaysOnTopState();

        updateMinimumSize();

        final Shape shape = getTarget().getShape();

        if (shape != null) {

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

        }

        final float opacity = getTarget().getOpacity();

        if (opacity < 1.0f) {

            setOpacity(opacity);

        }

        setOpaque(getTarget().isOpaque());

        updateInsets(platformWindow.getInsets());

        if (getSurfaceData() == null) {

            replaceSurfaceData(false);

        }

        activateDisplayListener();

    }

    // Just a helper method

    @Override

    public PlatformWindow getPlatformWindow() {

        return platformWindow;

    }

    @Override

    protected LWWindowPeer getWindowPeerOrSelf() {

        return this;

    }

    // ---- PEER METHODS ---- //

    @Override

    protected void disposeImpl() {

        deactivateDisplayListener();

        SurfaceData oldData = getSurfaceData();

        synchronized (surfaceDataLock){

            surfaceData = null;

        }

        if (oldData != null) {

            oldData.invalidate();

        }

        if (isGrabbing()) {

            ungrab();

        }

        if (warningWindow != null) {

            warningWindow.dispose();

        }

        platformWindow.dispose();

        super.disposeImpl();

    }

    @Override

    protected void setVisibleImpl(final boolean visible) {

        if (!visible && warningWindow != null) {

            warningWindow.setVisible(false, false);

        }

        super.setVisibleImpl(visible);

        // TODO: update graphicsConfig, see 4868278

        platformWindow.setVisible(visible);

        if (isSimpleWindow()) {

            KeyboardFocusManagerPeer kfmPeer = LWKeyboardFocusManagerPeer.getInstance();

            if (visible) {

                if (!getTarget().isAutoRequestFocus()) {

                    return;

                } else {

                    requestWindowFocus(CausedFocusEvent.Cause.ACTIVATION);

                }

            // Focus the owner in case this window is focused.

            } else if (kfmPeer.getCurrentFocusedWindow() == getTarget()) {

                // Transfer focus to the owner.

                LWWindowPeer owner = getOwnerFrameDialog(LWWindowPeer.this);

                if (owner != null) {

                    owner.requestWindowFocus(CausedFocusEvent.Cause.ACTIVATION);

                }

            }

        }

    }

    @Override

    public final GraphicsConfiguration getGraphicsConfiguration() {

        synchronized (getStateLock()) {

            return graphicsConfig;

        }

    }

    @Override

    public boolean updateGraphicsData(GraphicsConfiguration gc) {

        setGraphicsConfig(gc);

        return false;

    }

    protected final Graphics getOnscreenGraphics(Color fg, Color bg, Font f) {

        if (getSurfaceData() == null) {

            return null;

        }

        if (fg == null) {

            fg = SystemColor.windowText;

        }

        if (bg == null) {

            bg = SystemColor.window;

        }

        if (f == null) {

            f = DEFAULT_FONT;

        }

        return platformWindow.transformGraphics(new SunGraphics2D(getSurfaceData(), fg, bg, f));

    }

    @Override

    public void setBounds(int x, int y, int w, int h, int op) {

        if((op & NO_EMBEDDED_CHECK) == 0 && getPeerType() == PeerType.VIEW_EMBEDDED_FRAME) {

            return;

        }

        if ((op & SET_CLIENT_SIZE) != 0) {

            // SET_CLIENT_SIZE is only applicable to window peers, so handle it here

            // instead of pulling 'insets' field up to LWComponentPeer

            // no need to add insets since Window's notion of width and height includes insets.

            op &= ~SET_CLIENT_SIZE;

            op |= SET_SIZE;

        }

        // Don't post ComponentMoved/Resized and Paint events

        // until we've got a notification from the delegate

        Rectangle cb = constrainBounds(x, y, w, h);

        Rectangle newBounds = new Rectangle(getBounds());

        if ((op & (SET_LOCATION | SET_BOUNDS)) != 0) {

            newBounds.x = cb.x;

            newBounds.y = cb.y;

        }

        if ((op & (SET_SIZE | SET_BOUNDS)) != 0) {

            newBounds.width = cb.width;

            newBounds.height = cb.height;

        }

        // Native system could constraint bounds, so the peer wold be updated in the callback

        platformWindow.setBounds(newBounds.x, newBounds.y, newBounds.width, newBounds.height);

    }

    public Rectangle constrainBounds(Rectangle bounds) {

        return constrainBounds(bounds.x, bounds.y, bounds.width, bounds.height);

    }

    public Rectangle constrainBounds(int x, int y, int w, int h) {

        if (w < MINIMUM_WIDTH) {

            w = MINIMUM_WIDTH;

        }

        if (h < MINIMUM_HEIGHT) {

            h = MINIMUM_HEIGHT;

        }

        final int maxW = getLWGC().getMaxTextureWidth();

        final int maxH = getLWGC().getMaxTextureHeight();

        if (w > maxW) {

            w = maxW;

        }

        if (h > maxH) {

            h = maxH;

        }

        return new Rectangle(x, y, w, h);

    }

    @Override

    public Point getLocationOnScreen() {

        return platformWindow.getLocationOnScreen();

    }

    /**

     * Overridden from LWContainerPeer to return the correct insets.

     * Insets are queried from the delegate and are kept up to date by

     * requiering when needed (i.e. when the window geometry is changed).

     */

    @Override

    public Insets getInsets() {

        synchronized (getStateLock()) {

            return insets;

        }

    }

    @Override

    public FontMetrics getFontMetrics(Font f) {

        // TODO: check for "use platform metrics" settings

        return platformWindow.getFontMetrics(f);

    }

    @Override

    public void toFront() {

        platformWindow.toFront();

    }

    @Override

    public void toBack() {

        platformWindow.toBack();

    }

    @Override

    public void setZOrder(ComponentPeer above) {

        throw new RuntimeException("not implemented");

    }

    @Override

    public void updateAlwaysOnTopState() {

        platformWindow.setAlwaysOnTop(getTarget().isAlwaysOnTop());

    }

    @Override

    public void updateFocusableWindowState() {

        platformWindow.updateFocusableWindowState();

    }

    @Override

    public void setModalBlocked(Dialog blocker, boolean blocked) {

        synchronized (getPeerTreeLock()) {

            ComponentPeer peer =  AWTAccessor.getComponentAccessor().getPeer(blocker);

            if (blocked && (peer instanceof LWWindowPeer)) {

                this.blocker = (LWWindowPeer) peer;

            } else {

                this.blocker = null;

            }

        }

        platformWindow.setModalBlocked(blocked);

    }

    @Override

    public void updateMinimumSize() {

        final Dimension min;

        if (getTarget().isMinimumSizeSet()) {

            min = getTarget().getMinimumSize();

            min.width = Math.max(min.width, MINIMUM_WIDTH);

            min.height = Math.max(min.height, MINIMUM_HEIGHT);

        } else {

            min = new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT);

        }

        final Dimension max;

        if (getTarget().isMaximumSizeSet()) {

            max = getTarget().getMaximumSize();

            max.width = Math.min(max.width, getLWGC().getMaxTextureWidth());

            max.height = Math.min(max.height, getLWGC().getMaxTextureHeight());

        } else {

            max = new Dimension(getLWGC().getMaxTextureWidth(),

                                getLWGC().getMaxTextureHeight());

        }

        platformWindow.setSizeConstraints(min.width, min.height, max.width, max.height);

    }

    @Override

    public void updateIconImages() {

        getPlatformWindow().updateIconImages();

    }

    @Override

    public void setBackground(final Color c) {

        super.setBackground(c);

        updateOpaque();

    }

    @Override

    public void setOpacity(float opacity) {

        getPlatformWindow().setOpacity(opacity);

        repaintPeer();

    }

    @Override

    public final void setOpaque(final boolean isOpaque) {

        if (this.isOpaque != isOpaque) {

            this.isOpaque = isOpaque;

            updateOpaque();

        }

    }

    private void updateOpaque() {

        getPlatformWindow().setOpaque(!isTranslucent());

        replaceSurfaceData(false);

        repaintPeer();

    }

    @Override

    public void updateWindow() {

    }

    public final boolean isTextured() {

        return textured;

    }

    public final void setTextured(final boolean isTextured) {

        textured = isTextured;

    }

    @Override

    public final boolean isTranslucent() {

        synchronized (getStateLock()) {

            /*

             * Textured window is a special case of translucent window.

             * The difference is only in nswindow background. So when we set

             * texture property our peer became fully translucent. It doesn't

             * fill background, create non opaque backbuffers and layer etc.

             */

            return !isOpaque || isShaped() || isTextured();

        }

    }

    @Override

    final void applyShapeImpl(final Region shape) {

        super.applyShapeImpl(shape);

        updateOpaque();

    }

    @Override

    public void repositionSecurityWarning() {