/*

 * 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.image.BufferedImage;

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.util.logging.PlatformLogger;

public class LWWindowPeer

    extends LWContainerPeer<Window, JComponent>

    implements WindowPeer, FramePeer, DialogPeer, FullScreenCapable

{

    public static enum PeerType {

        SIMPLEWINDOW,

        FRAME,

        DIALOG,

        EMBEDDEDFRAME

    }

    private static final sun.util.logging.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 int screenOn = -1;

    private GraphicsConfiguration graphicsConfig;

    private SurfaceData surfaceData;

    private final Object surfaceDataLock = new Object();

    private int backBufferCount;

    private BufferCapabilities backBufferCaps;

    // The back buffer is used for two purposes:

    // 1. To render all the lightweight peers

    // 2. To provide user with a BufferStrategy

    // Need to check if a single back buffer can be used for both

// TODO: VolatileImage

//    private VolatileImage backBuffer;

    private volatile BufferedImage backBuffer;

    private volatile int windowState = Frame.NORMAL;

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

    // MOUSE_ENTERED/EXITED notifications and by cursor manager to

    // find the component under cursor

    private static volatile LWComponentPeer lastMouseEventPeer = null;

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

    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;

    /**

     * Current modal blocker or null.

     *

     * Synchronization: peerTreeLock.

     */

    private LWWindowPeer blocker;

    public LWWindowPeer(Window target, PlatformComponent platformComponent,

                        PlatformWindow platformWindow)

    {

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

            // System.out.println("Delegate assigns alpha (we ignore setOpacity()):"

            // +this.opacity);

        }

        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

    public void initialize() {

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

        cachedFocusableWindow = getTarget().isFocusableWindow();

        setOpacity(getTarget().getOpacity());

        setOpaque(getTarget().isOpaque());

        super.initialize();

        updateInsets(platformWindow.getInsets());

    }

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

        }

        destroyBuffers();

        platformWindow.dispose();

        super.disposeImpl();

    }

    @Override

    public void setVisible(final boolean visible) {

        if (getSurfaceData() == null) {

            replaceSurfaceData();

        }

        if (isVisible() == visible) {

            return;

        }

        super.setVisible(visible);

        // TODO: update graphicsConfig, see 4868278

        // TODO: don't notify the delegate if our visibility is unchanged

        // it is important to call this method on EDT

        // to prevent the deadlocks during the painting of the lightweight delegates

        //TODO: WHY? This is a native-system related call. Perhaps NOT calling

        // the painting procedure right from the setVisible(), but rather relying

        // on the native Expose event (or, scheduling the repainting asynchronously)

        // is better?

        SwingUtilities.invokeLater(new Runnable() {

            @Override

            public void run() {

                platformWindow.setVisible(visible);

                if (isSimpleWindow()) {

                    LWKeyboardFocusManagerPeer manager = LWKeyboardFocusManagerPeer.

                        getInstance(getAppContext());

                    if (visible) {

                        updateFocusableWindowState();

                        changeFocusedWindow(true, true);

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

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

                        LWWindowPeer owner = getOwnerFrameDialog(LWWindowPeer.this);

                        if (owner != null) {

                            // KFM will do all the rest.

                            owner.changeFocusedWindow(true, false);

                        }

                    }

                }

            }

        });

    }

    @Override

    public GraphicsConfiguration getGraphicsConfiguration() {

        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 createBuffers(int numBuffers, BufferCapabilities caps)

        throws AWTException

    {

        try {

            // Assume this method is never called with numBuffers <= 1, as 0 is

            // unsupported, and 1 corresponds to a SingleBufferStrategy which

            // doesn't depend on the peer. Screen is considered as a separate

            // "buffer", that's why numBuffers - 1

            assert numBuffers > 1;

            replaceSurfaceData(numBuffers - 1, caps);

        } catch (InvalidPipeException z) {

            throw new AWTException(z.toString());

        }

    }

    @Override

    public final Image getBackBuffer() {

        synchronized (getStateLock()) {

            return backBuffer;

        }

    }

    @Override

    public void flip(int x1, int y1, int x2, int y2,

                     BufferCapabilities.FlipContents flipAction)

    {

        platformWindow.flip(x1, y1, x2, y2, flipAction);

    }

    @Override

    public final void destroyBuffers() {

        final Image oldBB = getBackBuffer();

        synchronized (getStateLock()) {

            backBuffer = null;

        }

        if (oldBB != null) {

            oldBB.flush();

        }

    }

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

        }

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

        cachedFocusableWindow = getTarget().isFocusableWindow();

        platformWindow.updateFocusableWindowState();

    }

    @Override

    public void setModalBlocked(Dialog blocker, boolean blocked) {

        synchronized (getPeerTreeLock()) {

            this.blocker = blocked ? (LWWindowPeer)blocker.getPeer() : null;

        }

    }

    @Override

    public void updateMinimumSize() {

        Dimension d = null;

        if (getTarget().isMinimumSizeSet()) {

            d = getTarget().getMinimumSize();

        }

        if (d == null) {

            d = new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT);

        }

        platformWindow.setMinimumSize(d.width, d.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;

            getPlatformWindow().setOpaque(isOpaque);

            replaceSurfaceData();

            repaintPeer();

        }

    }

    public final boolean isOpaque() {

        return isOpaque;

    }

    @Override

    public void updateWindow() {

        flushOffscreenGraphics();

    }

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

            }

        }

    }

    // ---- PEER NOTIFICATIONS ---- //

    public void notifyIconify(boolean iconify) {

        //The toplevel target is Frame and states are applicable to it.

        //Otherwise, the target is Window and it don't have state property.

        //Hopefully, no such events are posted in the queue so consider the

        //target as Frame in all cases.

        // REMIND: should we send it anyway if the state not changed since last

        // time?

        WindowEvent iconifyEvent = new WindowEvent(getTarget(),

                iconify ? WindowEvent.WINDOW_ICONIFIED

                        : WindowEvent.WINDOW_DEICONIFIED);