/*

 * Copyright (c) 2011, 2012, 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 WindowPeer, FramePeer, DialogPeer, FullScreenCapable

{

    public static enum PeerType {

        SIMPLEWINDOW,

        FRAME,

        DIALOG,

    }

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

    private PlatformWindow platformWindow;

    // Window bounds reported by the native system (as opposed to

    // regular bounds inherited from LWComponentPeer which are

    // requested by user and may haven't been applied yet because

    // of asynchronous requests to the windowing system)

    private int sysX;

    private int sysY;

    private int sysW;

    private int sysH;

    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 = null;

    // 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 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;

    /**

     * Current modal blocker or null.

     *

     * Synchronization: peerTreeLock.

     */

    private LWWindowPeer blocker;

    public LWWindowPeer(Window target, PlatformComponent platformComponent,

    {

        super(target, platformComponent);

        this.platformWindow = platformWindow;

        Window owner = target.getOwner();

        LWWindowPeer ownerPeer = (owner != null) ? (LWWindowPeer)owner.getPeer() : null;

        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);

    }

    @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());

        }

        setAlwaysOnTop(getTarget().isAlwaysOnTop());

        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);

        }

    }

    // Just a helper method

    public PlatformWindow getPlatformWindow() {

        return platformWindow;

    }

    @Override

    protected LWWindowPeer getWindowPeerOrSelf() {

        return this;

    }

    @Override

    protected void initializeContainerPeer() {

        // No-op as LWWindowPeer doesn't have any containerPeer

    }

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

    @Override

    protected void disposeImpl() {

        SurfaceData oldData = getSurfaceData();

        synchronized (surfaceDataLock){

            surfaceData = null;

        }

        if (oldData != null) {

            oldData.invalidate();

        }

        if (isGrabbing()) {

            ungrab();

        }

        platformWindow.dispose();

        super.disposeImpl();

    }

    @Override

    protected void setVisibleImpl(final boolean visible) {

        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 & 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;

        }

        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;

        }

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

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

        setBounds(x, y, w, h, op, false, false);

        // Get updated bounds, so we don't have to handle 'op' here manually

        Rectangle r = getBounds();

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

    }

    @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 setAlwaysOnTop(boolean value) {

        platformWindow.setAlwaysOnTop(value);

    }

    @Override

    public void updateFocusableWindowState() {

        platformWindow.updateFocusableWindowState();

    }

    @Override

    public void setModalBlocked(Dialog blocker, boolean blocked) {

        synchronized (getPeerTreeLock()) {

            this.blocker = blocked ? (LWWindowPeer)blocker.getPeer() : 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 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;

    }

    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() {

        throw new RuntimeException("not implemented");

    }

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

    @Override // FramePeer and DialogPeer

    public void setTitle(String title) {

        platformWindow.setTitle(title == null ? "" : title);

    }

    @Override

    public void setMenuBar(MenuBar mb) {

         platformWindow.setMenuBar(mb);

    }

    @Override // FramePeer and DialogPeer

    public void setResizable(boolean resizable) {

        platformWindow.setResizable(resizable);

    }

    @Override

    public void setState(int state) {

        platformWindow.setWindowState(state);

    }

    @Override

    public int getState() {

        return windowState;

    }

    @Override

    public void setMaximizedBounds(Rectangle bounds) {

        // TODO: not implemented

    }

    @Override

    public void setBoundsPrivate(int x, int y, int width, int height) {

        setBounds(x, y, width, height, SET_BOUNDS | NO_EMBEDDED_CHECK);

    }

    @Override

    public Rectangle getBoundsPrivate() {

        throw new RuntimeException("not implemented");

    }

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

    @Override

    public void blockWindows(List<Window> windows) {

        //TODO: LWX will probably need some collectJavaToplevels to speed this up

        for (Window w : windows) {

            WindowPeer wp = (WindowPeer)w.getPeer();

            if (wp != null) {

                wp.setModalBlocked((Dialog)getTarget(), true);

            }

        }

    }