/*

 * 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.windows;

import java.awt.*;

import java.awt.peer.*;

import java.awt.image.VolatileImage;

import sun.awt.RepaintArea;

import sun.awt.CausedFocusEvent;

import sun.awt.image.SunVolatileImage;

import sun.awt.image.ToolkitImage;

import java.awt.image.BufferedImage;

import java.awt.image.ImageProducer;

import java.awt.image.ImageObserver;

import java.awt.image.ColorModel;

import java.awt.event.PaintEvent;

import java.awt.event.InvocationEvent;

import java.awt.event.KeyEvent;

import java.awt.event.FocusEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseWheelEvent;

import java.awt.event.InputEvent;

import sun.awt.Win32GraphicsConfig;

import sun.awt.Win32GraphicsEnvironment;

import sun.java2d.InvalidPipeException;

import sun.java2d.SurfaceData;

import sun.java2d.ScreenUpdateManager;

import sun.java2d.d3d.D3DSurfaceData;

import sun.java2d.opengl.OGLSurfaceData;

import sun.java2d.pipe.Region;

import sun.awt.DisplayChangedListener;

import sun.awt.PaintEventDispatcher;

import sun.awt.SunToolkit;

import sun.awt.event.IgnorePaintEvent;

import java.awt.dnd.DropTarget;

import java.awt.dnd.peer.DropTargetPeer;

import sun.awt.AWTAccessor;

import sun.util.logging.PlatformLogger;

public abstract class WComponentPeer extends WObjectPeer

    implements ComponentPeer, DropTargetPeer

{

    /**

     * Handle to native window

     */

    protected volatile long hwnd;

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.windows.WComponentPeer");

    private static final PlatformLogger shapeLog = PlatformLogger.getLogger("sun.awt.windows.shape.WComponentPeer");

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.windows.focus.WComponentPeer");

    // ComponentPeer implementation

    SurfaceData surfaceData;

    private RepaintArea paintArea;

    protected Win32GraphicsConfig winGraphicsConfig;

    boolean isLayouting = false;

    boolean paintPending = false;

    int     oldWidth = -1;

    int     oldHeight = -1;

    private int numBackBuffers = 0;

    private VolatileImage backBuffer = null;

    private BufferCapabilities backBufferCaps = null;

    // foreground, background and color are cached to avoid calling back

    // into the Component.

    private Color foreground;

    private Color background;

    private Font font;

    public native boolean isObscured();

    public boolean canDetermineObscurity() { return true; }

    // DropTarget support

    int nDropTargets;

    long nativeDropTargetContext; // native pointer

    public synchronized native void pShow();

    public synchronized native void hide();

    public synchronized native void enable();

    public synchronized native void disable();

    public long getHWnd() {

        return hwnd;

    }

    /* New 1.1 API */

    public native Point getLocationOnScreen();

    /* New 1.1 API */

    public void setVisible(boolean b) {

        if (b) {

            show();

        } else {

            hide();

        }

    }

    public void show() {

        Dimension s = ((Component)target).getSize();

        oldHeight = s.height;

        oldWidth = s.width;

        pShow();

    }

    /* New 1.1 API */

    public void setEnabled(boolean b) {

        if (b) {

            enable();

        } else {

            disable();

        }

    }

    public int serialNum = 0;

    private native void reshapeNoCheck(int x, int y, int width, int height);

    /* New 1.1 API */

    public void setBounds(int x, int y, int width, int height, int op) {

        // Should set paintPending before reahape to prevent

        // thread race between paint events

        // Native components do redraw after resize

        paintPending = (width != oldWidth) || (height != oldHeight);

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

            reshapeNoCheck(x, y, width, height);

        } else {

            reshape(x, y, width, height);

        }

        if ((width != oldWidth) || (height != oldHeight)) {

            // Only recreate surfaceData if this setBounds is called

            // for a resize; a simple move should not trigger a recreation

            try {

                replaceSurfaceData();

            } catch (InvalidPipeException e) {

                // REMIND : what do we do if our surface creation failed?

            }

            oldWidth = width;

            oldHeight = height;

        }

        serialNum++;

    }

    /*

     * Called from native code (on Toolkit thread) in order to

     * dynamically layout the Container during resizing

     */

    void dynamicallyLayoutContainer() {

        // If we got the WM_SIZING, this must be a Container, right?

        // In fact, it must be the top-level Container.

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

            Container parent = WToolkit.getNativeContainer((Component)target);

            if (parent != null) {

                log.fine("Assertion (parent == null) failed");

            }

        }

        final Container cont = (Container)target;

        WToolkit.executeOnEventHandlerThread(cont, new Runnable() {

            public void run() {

                // Discarding old paint events doesn't seem to be necessary.

                cont.invalidate();

                cont.validate();

                if (surfaceData instanceof D3DSurfaceData.D3DWindowSurfaceData ||

                    surfaceData instanceof OGLSurfaceData)

                {

                    // When OGL or D3D is enabled, it is necessary to

                    // replace the SurfaceData for each dynamic layout

                    // request so that the viewport stays in sync

                    // with the window bounds.

                    try {

                        replaceSurfaceData();

                    } catch (InvalidPipeException e) {

                        // REMIND: this is unlikely to occur for OGL, but

                        // what do we do if surface creation fails?

                    }

                }

                // Forcing a paint here doesn't seem to be necessary.

                // paintDamagedAreaImmediately();

            }

        });

    }

    /*

     * Paints any portion of the component that needs updating

     * before the call returns (similar to the Win32 API UpdateWindow)

     */

    void paintDamagedAreaImmediately() {

        // force Windows to send any pending WM_PAINT events so

        // the damage area is updated on the Java side

        updateWindow();

        // make sure paint events are transferred to main event queue

        // for coalescing

        WToolkit.getWToolkit().flushPendingEvents();

        // paint the damaged area

        paintArea.paint(target, shouldClearRectBeforePaint());

    }

    native synchronized void updateWindow();

    public void paint(Graphics g) {

        ((Component)target).paint(g);

    }

    public void repaint(long tm, int x, int y, int width, int height) {

    }

    private static final double BANDING_DIVISOR = 4.0;

    private native int[] createPrintedPixels(int srcX, int srcY,

                                             int srcW, int srcH,

                                             int alpha);

    public void print(Graphics g) {

        Component comp = (Component)target;

        // To conserve memory usage, we will band the image.

        int totalW = comp.getWidth();

        int totalH = comp.getHeight();

        int hInc = (int)(totalH / BANDING_DIVISOR);

        if (hInc == 0) {

            hInc = totalH;

        }

        for (int startY = 0; startY < totalH; startY += hInc) {

            int endY = startY + hInc - 1;

            if (endY >= totalH) {

                endY = totalH - 1;

            }

            int h = endY - startY + 1;

            Color bgColor = comp.getBackground();

            int[] pix = createPrintedPixels(0, startY, totalW, h,

                                            bgColor == null ? 255 : bgColor.getAlpha());

            if (pix != null) {

                BufferedImage bim = new BufferedImage(totalW, h,

                                              BufferedImage.TYPE_INT_ARGB);

                bim.setRGB(0, 0, totalW, h, pix, 0, totalW);

                g.drawImage(bim, 0, startY, null);

                bim.flush();

            }

        }

        comp.print(g);

    }

    public void coalescePaintEvent(PaintEvent e) {

        Rectangle r = e.getUpdateRect();

        if (!(e instanceof IgnorePaintEvent)) {

            paintArea.add(r, e.getID());

        }

        if (log.isLoggable(PlatformLogger.FINEST)) {

            switch(e.getID()) {

            case PaintEvent.UPDATE:

                log.finest("coalescePaintEvent: UPDATE: add: x = " +

                    r.x + ", y = " + r.y + ", width = " + r.width + ", height = " + r.height);

                return;

            case PaintEvent.PAINT:

                log.finest("coalescePaintEvent: PAINT: add: x = " +

                    r.x + ", y = " + r.y + ", width = " + r.width + ", height = " + r.height);

                return;

            }

        }

    }

    public synchronized native void reshape(int x, int y, int width, int height);

    // returns true if the event has been handled and shouldn't be propagated

    // though handleEvent method chain - e.g. WTextFieldPeer returns true

    // on handling '\n' to prevent it from being passed to native code

    public boolean handleJavaKeyEvent(KeyEvent e) { return false; }

    public void handleJavaMouseEvent(MouseEvent e) {

        switch (e.getID()) {

          case MouseEvent.MOUSE_PRESSED:

              // Note that Swing requests focus in its own mouse event handler.

              if (target == e.getSource() &&

                  !((Component)target).isFocusOwner() &&

                  WKeyboardFocusManagerPeer.shouldFocusOnClick((Component)target))

              {

                  WKeyboardFocusManagerPeer.requestFocusFor((Component)target,

                                                            CausedFocusEvent.Cause.MOUSE_EVENT);

              }

              break;

        }

    }

    native void nativeHandleEvent(AWTEvent e);

    public void handleEvent(AWTEvent e) {

        int id = e.getID();

        if ((e instanceof InputEvent) && !((InputEvent)e).isConsumed() &&

            ((Component)target).isEnabled())

        {

            if (e instanceof MouseEvent && !(e instanceof MouseWheelEvent)) {

                handleJavaMouseEvent((MouseEvent) e);

            } else if (e instanceof KeyEvent) {

                if (handleJavaKeyEvent((KeyEvent)e)) {

                    return;

                }

            }

        }

        switch(id) {

            case PaintEvent.PAINT:

                // Got native painting

                paintPending = false;

                // Fallthrough to next statement

            case PaintEvent.UPDATE:

                // Skip all painting while layouting and all UPDATEs

                // while waiting for native paint

                if (!isLayouting && ! paintPending) {

                    paintArea.paint(target,shouldClearRectBeforePaint());

                }

                return;

            case FocusEvent.FOCUS_LOST:

            case FocusEvent.FOCUS_GAINED:

                handleJavaFocusEvent((FocusEvent)e);

            default:

            break;

        }

        // Call the native code

        nativeHandleEvent(e);

    }

    void handleJavaFocusEvent(FocusEvent fe) {

        if (focusLog.isLoggable(PlatformLogger.FINER)) focusLog.finer(fe.toString());

        setFocus(fe.getID() == FocusEvent.FOCUS_GAINED);

    }

    native void setFocus(boolean doSetFocus);

    public Dimension getMinimumSize() {

        return ((Component)target).getSize();

    }

    public Dimension getPreferredSize() {

        return getMinimumSize();

    }

    // Do nothing for heavyweight implementation

    public void layout() {}

    public Rectangle getBounds() {

        return ((Component)target).getBounds();

    }

    public boolean isFocusable() {

        return false;

    }

    /*

     * Return the GraphicsConfiguration associated with this peer, either

     * the locally stored winGraphicsConfig, or that of the target Component.

     */

    public GraphicsConfiguration getGraphicsConfiguration() {

        if (winGraphicsConfig != null) {

            return winGraphicsConfig;

        }

        else {

            // we don't need a treelock here, since

            // Component.getGraphicsConfiguration() gets it itself.

            return ((Component)target).getGraphicsConfiguration();

        }

    }

    public SurfaceData getSurfaceData() {

        return surfaceData;

    }

    /**

     * Creates new surfaceData object and invalidates the previous

     * surfaceData object.

     * Replacing the surface data should never lock on any resources which are

     * required by other threads which may have them and may require

     * the tree-lock.

     * This is a degenerate version of replaceSurfaceData(numBackBuffers), so

     * just call that version with our current numBackBuffers.

     */

    public void replaceSurfaceData() {

        replaceSurfaceData(this.numBackBuffers, this.backBufferCaps);

    }

    public void createScreenSurface(boolean isResize)

    {

        Win32GraphicsConfig gc = (Win32GraphicsConfig)getGraphicsConfiguration();

        ScreenUpdateManager mgr = ScreenUpdateManager.getInstance();

        surfaceData = mgr.createScreenSurface(gc, this, numBackBuffers, isResize);

    }

    /**

     * Multi-buffer version of replaceSurfaceData.  This version is called

     * by createBuffers(), which needs to acquire the same locks in the same

     * order, but also needs to perform additional functions inside the

     * locks.

     */

    public void replaceSurfaceData(int newNumBackBuffers,

                                   BufferCapabilities caps)

    {

        SurfaceData oldData = null;

        VolatileImage oldBB = null;

        synchronized(((Component)target).getTreeLock()) {

            synchronized(this) {

                if (pData == 0) {

                    return;

                }

                numBackBuffers = newNumBackBuffers;

                ScreenUpdateManager mgr = ScreenUpdateManager.getInstance();

                oldData = surfaceData;

                mgr.dropScreenSurface(oldData);

                createScreenSurface(true);

                if (oldData != null) {

                    oldData.invalidate();

                }

                oldBB = backBuffer;

                if (numBackBuffers > 0) {

                    // set the caps first, they're used when creating the bb

                    backBufferCaps = caps;

                    Win32GraphicsConfig gc =

                        (Win32GraphicsConfig)getGraphicsConfiguration();

                    backBuffer = gc.createBackBuffer(this);

                } else if (backBuffer != null) {

                    backBufferCaps = null;

                    backBuffer = null;

                }

            }

        }

        // it would be better to do this before we create new ones,

        // but then we'd run into deadlock issues

        if (oldData != null) {

            oldData.flush();

            // null out the old data to make it collected faster

            oldData = null;

        }

        if (oldBB != null) {

            oldBB.flush();

            // null out the old data to make it collected faster

            oldData = null;

        }

    }

    public void replaceSurfaceDataLater() {

        Runnable r = new Runnable() {

            public void run() {

                // Shouldn't do anything if object is disposed in meanwhile

                // No need for sync as disposeAction in Window is performed

                // on EDT

                if (!isDisposed()) {

                    try {

                        replaceSurfaceData();

                    } catch (InvalidPipeException e) {

                    // REMIND : what do we do if our surface creation failed?

                    }

                }

            }

        };

        // Fix 6255371.

        if (!PaintEventDispatcher.getPaintEventDispatcher().queueSurfaceDataReplacing((Component)target, r)) {

            postEvent(new InvocationEvent(Toolkit.getDefaultToolkit(), r));

        }

    }

    public boolean updateGraphicsData(GraphicsConfiguration gc) {

        winGraphicsConfig = (Win32GraphicsConfig)gc;

        try {

            replaceSurfaceData();

        } catch (InvalidPipeException e) {

            // REMIND : what do we do if our surface creation failed?

        }

        return false;

    }

    //This will return null for Components not yet added to a Container

    public ColorModel getColorModel() {

        GraphicsConfiguration gc = getGraphicsConfiguration();

        if (gc != null) {

            return gc.getColorModel();