/*

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

import java.awt.AWTException;

import java.awt.BufferCapabilities;

import java.awt.Color;

import java.awt.Component;

import java.awt.Container;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics;

import java.awt.GraphicsConfiguration;

import java.awt.Image;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.Toolkit;

import java.awt.Window;

import java.awt.dnd.DropTarget;

import java.awt.dnd.peer.DropTargetPeer;

import java.awt.event.AWTEventListener;

import java.awt.event.ComponentEvent;

import java.awt.event.FocusEvent;

import java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseWheelEvent;

import java.awt.event.PaintEvent;

import java.awt.image.ColorModel;

import java.awt.image.ImageObserver;

import java.awt.image.ImageProducer;

import java.awt.image.VolatileImage;

import java.awt.peer.ComponentPeer;

import java.awt.peer.ContainerPeer;

import java.awt.peer.KeyboardFocusManagerPeer;

import java.lang.reflect.Field;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.concurrent.atomic.AtomicBoolean;

import javax.swing.JComponent;

import javax.swing.RepaintManager;

import javax.swing.SwingUtilities;

import com.sun.java.swing.SwingUtilities3;

import sun.awt.AWTAccessor;

import sun.awt.PaintEventDispatcher;

import sun.awt.RepaintArea;

import sun.awt.SunToolkit;

import sun.awt.event.IgnorePaintEvent;

import sun.awt.image.SunVolatileImage;

import sun.awt.image.ToolkitImage;

import sun.java2d.SunGraphics2D;

import sun.java2d.opengl.OGLRenderQueue;

import sun.java2d.pipe.Region;

import sun.util.logging.PlatformLogger;

public abstract class LWComponentPeer<T extends Component, D extends JComponent>

    implements ComponentPeer, DropTargetPeer

{

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

    /**

     * State lock is to be used for modifications to this peer's fields (e.g.

     * bounds, background, font, etc.) It should be the last lock in the lock

     * chain

     */

    private final Object stateLock = new Object();

    /**

     * The lock to operate with the peers hierarchy. AWT tree lock is not used

     * as there are many peers related ops to be done on the toolkit thread, and

     * we don't want to depend on a public lock on this thread

     */

    private static final Object peerTreeLock = new Object();

    /**

     * The associated AWT object.

     */

    private final T target;

    /**

     * Container peer. It may not be the peer of the target's direct parent, for

     * example, in the case of hw/lw mixing. However, let's skip this scenario

     * for the time being. We also assume the container peer is not null, which

     * might also be false if addNotify() is called for a component outside of

     * the hierarchy. The exception is LWWindowPeers: their containers are

     * always null

     */

    private final LWContainerPeer<?, ?> containerPeer;

    /**

     * Handy reference to the top-level window peer. Window peer is borrowed

     * from the containerPeer in constructor, and should also be updated when

     * the component is reparented to another container

     */

    private final LWWindowPeer windowPeer;

    private final AtomicBoolean disposed = new AtomicBoolean(false);

    // Bounds are relative to parent peer

    private final Rectangle bounds = new Rectangle();

    private Region region;

    // Component state. Should be accessed under the state lock

    private boolean visible = false;

    private boolean enabled = true;

    private Color background;

    private Color foreground;

    private Font font;

    /**

     * Paint area to coalesce all the paint events and store the target dirty

     * area.

     */

    private final RepaintArea targetPaintArea;

    //   private volatile boolean paintPending;

    private volatile boolean isLayouting;

    private final D delegate;

    private Container delegateContainer;

    private Component delegateDropTarget;

    private final Object dropTargetLock = new Object();

    private int fNumDropTargets = 0;

    private PlatformDropTarget fDropTarget = null;

    private final PlatformComponent platformComponent;

    /**

     * Character with reasonable value between the minimum width and maximum.

     */

    static final char WIDE_CHAR = '0';

    /**

     * The back buffer provide user with a BufferStrategy.

     */

    private Image backBuffer;

    /**

     * All Swing delegates use delegateContainer as a parent. This container

     * intentionally do not use parent of the peer.

     */

    @SuppressWarnings("serial")// Safe: outer class is non-serializable.

    private final class DelegateContainer extends Container {

        {

            enableEvents(0xFFFFFFFF);

        }

        @Override

        public boolean isLightweight() {

            return false;

        }

        @Override

        public Point getLocation() {

            return getLocationOnScreen();

        }

        @Override

        public Point getLocationOnScreen() {

            return LWComponentPeer.this.getLocationOnScreen();

        }

        @Override

        public int getX() {

            return getLocation().x;

        }

        @Override

        public int getY() {

            return getLocation().y;

        }

    }

    LWComponentPeer(final T target, final PlatformComponent platformComponent) {

        targetPaintArea = new LWRepaintArea();

        this.target = target;

        this.platformComponent = platformComponent;

        // Container peer is always null for LWWindowPeers, so

        // windowPeer is always null for them as well. On the other

        // hand, LWWindowPeer shouldn't use windowPeer at all

        final Container container = SunToolkit.getNativeContainer(target);

        containerPeer = (LWContainerPeer) LWToolkit.targetToPeer(container);

        windowPeer = containerPeer != null ? containerPeer.getWindowPeerOrSelf()

                                           : null;

        // don't bother about z-order here as updateZOrder()

        // will be called from addNotify() later anyway

        if (containerPeer != null) {

            containerPeer.addChildPeer(this);

        }

        // the delegate must be created after the target is set

        AWTEventListener toolkitListener = null;

        synchronized (Toolkit.getDefaultToolkit()) {

            try {

                toolkitListener = getToolkitAWTEventListener();

                setToolkitAWTEventListener(null);

                synchronized (getDelegateLock()) {

                    delegate = createDelegate();

                    if (delegate != null) {

                        delegate.setVisible(false);

                        delegateContainer = new DelegateContainer();

                        delegateContainer.add(delegate);

                        delegateContainer.addNotify();

                        delegate.addNotify();

                        resetColorsAndFont(delegate);

                        delegate.setOpaque(true);

                    } else {

                        return;

                    }

                }

            } finally {

                setToolkitAWTEventListener(toolkitListener);

            }

            // todo swing: later on we will probably have one global RM

            SwingUtilities3.setDelegateRepaintManager(delegate, new RepaintManager() {

                @Override

                public void addDirtyRegion(final JComponent c, final int x, final int y, final int w, final int h) {

                    repaintPeer(SwingUtilities.convertRectangle(

                            c, new Rectangle(x, y, w, h), getDelegate()));

                }

            });

        }

    }

    /**

     * This method must be called under Toolkit.getDefaultToolkit() lock

     * and followed by setToolkitAWTEventListener()

     */

    protected final AWTEventListener getToolkitAWTEventListener() {

        return AccessController.doPrivileged(new PrivilegedAction<AWTEventListener>() {

            public AWTEventListener run() {

                Toolkit toolkit = Toolkit.getDefaultToolkit();

                try {

                    Field field = Toolkit.class.getDeclaredField("eventListener");

                    field.setAccessible(true);

                    return (AWTEventListener) field.get(toolkit);

                } catch (Exception e) {

                    throw new InternalError(e.toString());

                }

            }

        });

    }

    protected final void setToolkitAWTEventListener(final AWTEventListener listener) {

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                Toolkit toolkit = Toolkit.getDefaultToolkit();

                try {

                    Field field = Toolkit.class.getDeclaredField("eventListener");

                    field.setAccessible(true);

                    field.set(toolkit, listener);

                } catch (Exception e) {

                    throw new InternalError(e.toString());

                }

                return null;

            }

        });

    }

    /**

     * This method is called under getDelegateLock().

     * Overridden in subclasses.

     */

    D createDelegate() {

        return null;

    }

    final D getDelegate() {

        return delegate;

    }

    /**

     * This method should be called under getDelegateLock().

     */

    Component getDelegateFocusOwner() {

        return getDelegate();

    }

    /**

     * Initializes this peer. The call to initialize() is not placed to

     * LWComponentPeer ctor to let the subclass ctor to finish completely first.

     * Instead, it's the LWToolkit object who is responsible for initialization.

     * Note that we call setVisible() at the end of initialization.

     */

    public final void initialize() {

        platformComponent.initialize(getPlatformWindow());

        initializeImpl();

        setVisible(target.isVisible());

    }

    /**

     * Fetching general properties from the target. Should be overridden in

     * subclasses to initialize specific peers properties.

     */

    void initializeImpl() {

        // note that these methods can be overridden by the user and

        // can return some strange values like null.

        setBackground(target.getBackground());

        setForeground(target.getForeground());

        setFont(target.getFont());

        setBounds(target.getBounds());

        setEnabled(target.isEnabled());

    }

    private static void resetColorsAndFont(final Container c) {

        c.setBackground(null);

        c.setForeground(null);

        c.setFont(null);

        for (int i = 0; i < c.getComponentCount(); i++) {

            resetColorsAndFont((Container) c.getComponent(i));

        }

    }

    final Object getStateLock() {

        return stateLock;

    }

    /**

     * Synchronize all operations with the Swing delegates under AWT tree lock,

     * using a new separate lock to synchronize access to delegates may lead

     * deadlocks. Think of it as a 'virtual EDT'.

     *

     * @return DelegateLock

     */

    final Object getDelegateLock() {

        return getTarget().getTreeLock();

    }

    protected static final Object getPeerTreeLock() {

        return peerTreeLock;

    }

    public final T getTarget() {

        return target;

    }

    // Just a helper method

    // Returns the window peer or null if this is a window peer

    protected final LWWindowPeer getWindowPeer() {

        return windowPeer;

    }

    // Returns the window peer or 'this' if this is a window peer

    protected LWWindowPeer getWindowPeerOrSelf() {

        return getWindowPeer();

    }

    // Just a helper method

    protected final LWContainerPeer<?, ?> getContainerPeer() {

        return containerPeer;

    }

    public PlatformWindow getPlatformWindow() {

        LWWindowPeer windowPeer = getWindowPeer();

        return windowPeer.getPlatformWindow();

    }

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

    // Just a helper method

    public LWToolkit getLWToolkit() {

        return LWToolkit.getLWToolkit();

    }

    @Override

    public final void dispose() {

        if (disposed.compareAndSet(false, true)) {

            disposeImpl();

        }

    }

    protected void disposeImpl() {

        destroyBuffers();

        LWContainerPeer<?, ?> cp = getContainerPeer();

        if (cp != null) {

            cp.removeChildPeer(this);

        }

        platformComponent.dispose();

        LWToolkit.targetDisposedPeer(getTarget(), this);

    }

    public final boolean isDisposed() {

        return disposed.get();

    }

    /*

     * GraphicsConfiguration is borrowed from the parent peer. The

     * return value must not be null.

     *

     * Overridden in LWWindowPeer.

     */

    @Override

    public GraphicsConfiguration getGraphicsConfiguration() {

        // Don't check windowPeer for null as it can only happen

        // for windows, but this method is overridden in

        // LWWindowPeer and doesn't call super()

        return getWindowPeer().getGraphicsConfiguration();

    }

    // Just a helper method

    public final LWGraphicsConfig getLWGC() {

        return (LWGraphicsConfig) getGraphicsConfiguration();

    }

    /*

     * Overridden in LWWindowPeer to replace its surface

     * data and back buffer.

     */

    @Override

    public boolean updateGraphicsData(GraphicsConfiguration gc) {

        // TODO: not implemented

//        throw new RuntimeException("Has not been implemented yet.");

        return false;

    }

    @Override

    public Graphics getGraphics() {

        final Graphics g = getOnscreenGraphics();

        if (g != null) {

            synchronized (getPeerTreeLock()){

                applyConstrain(g);

            }

        }

        return g;

    }

    /*

     * Peer Graphics is borrowed from the parent peer, while

     * foreground and background colors and font are specific to

     * this peer.

     */

    public final Graphics getOnscreenGraphics() {

        final LWWindowPeer wp = getWindowPeerOrSelf();

        return wp.getOnscreenGraphics(getForeground(), getBackground(),

                                      getFont());

    }

    private void applyConstrain(final Graphics g) {

        final SunGraphics2D sg2d = (SunGraphics2D) g;

        final Rectangle size = localToWindow(getSize());

        sg2d.constrain(size.x, size.y, size.width, size.height, getVisibleRegion());

    }

    Region getVisibleRegion() {

        return computeVisibleRect(this, getRegion());

    }

    static final Region computeVisibleRect(final LWComponentPeer<?, ?> c,

                                           Region region) {

        final LWContainerPeer<?, ?> p = c.getContainerPeer();

        if (p != null) {

            final Rectangle r = c.getBounds();

            region = region.getTranslatedRegion(r.x, r.y);

            region = region.getIntersection(p.getRegion());

            region = region.getIntersection(p.getContentSize());

            region = p.cutChildren(region, c);

            region = computeVisibleRect(p, region);

            region = region.getTranslatedRegion(-r.x, -r.y);

        }

        return region;

    }

    @Override

    public ColorModel getColorModel() {

        // Is it a correct implementation?

        return getGraphicsConfiguration().getColorModel();

    }

    public boolean isTranslucent() {

        // Translucent windows of the top level are supported only

        return false;

    }