/*

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

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.Insets;

import java.awt.Rectangle;

import java.awt.SystemColor;

import java.awt.Toolkit;

import java.awt.Window;

import java.awt.dnd.DropTarget;

import java.awt.dnd.peer.DropTargetPeer;

import java.awt.event.FocusEvent;

import java.awt.event.InputEvent;

import java.awt.event.InputMethodEvent;

import java.awt.event.KeyEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseWheelEvent;

import java.awt.event.PaintEvent;

import java.awt.event.WindowEvent;

import java.awt.event.InvocationEvent;

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.lang.reflect.*;

import java.security.*;

import java.util.Collection;

import java.util.Set;

import sun.util.logging.PlatformLogger;

import sun.awt.*;

import sun.awt.event.IgnorePaintEvent;

import sun.awt.image.SunVolatileImage;

import sun.awt.image.ToolkitImage;

import sun.java2d.BackBufferCapsProvider;

import sun.java2d.pipe.Region;

public class XComponentPeer extends XWindow implements ComponentPeer, DropTargetPeer,

    BackBufferCapsProvider

{

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XComponentPeer");

    private static final PlatformLogger buffersLog = PlatformLogger.getLogger("sun.awt.X11.XComponentPeer.multibuffer");

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XComponentPeer");

    private static final PlatformLogger fontLog = PlatformLogger.getLogger("sun.awt.X11.font.XComponentPeer");

    private static final PlatformLogger enableLog = PlatformLogger.getLogger("sun.awt.X11.enable.XComponentPeer");

    private static final PlatformLogger shapeLog = PlatformLogger.getLogger("sun.awt.X11.shape.XComponentPeer");

    boolean paintPending = false;

    boolean isLayouting = false;

    private boolean enabled;

    // Actually used only by XDecoratedPeer

    protected int boundsOperation;

    Color foreground;

    Color background;

    // Colors calculated as on Motif using MotifColorUtilties.

    // If you use these, call updateMotifColors() in the peer's Constructor and

    // setBackground().  Examples are XCheckboxPeer and XButtonPeer.

    Color darkShadow;

    Color lightShadow;

    Color selectColor;

    Font font;

    private long backBuffer = 0;

    private VolatileImage xBackBuffer = null;

    static Color[] systemColors;

    XComponentPeer() {

    }

    XComponentPeer (XCreateWindowParams params) {

        super(params);

    }

    XComponentPeer(Component target, long parentWindow, Rectangle bounds) {

        super(target, parentWindow, bounds);

    }

    /**

     * Standard peer constructor, with corresponding Component

     */

    XComponentPeer(Component target) {

        super(target);

    }

    void preInit(XCreateWindowParams params) {

        super.preInit(params);

        boundsOperation = DEFAULT_OPERATION;

    }

    void postInit(XCreateWindowParams params) {

        super.postInit(params);

        pSetCursor(target.getCursor());

        foreground = target.getForeground();

        background = target.getBackground();

        font = target.getFont();

        if (isInitialReshape()) {

            Rectangle r = target.getBounds();

            reshape(r.x, r.y, r.width, r.height);

        }

        setEnabled(target.isEnabled());

        if (target.isVisible()) {

            setVisible(true);

        }

    }

    protected boolean isInitialReshape() {

        return true;

    }

    public void reparent(ContainerPeer newNativeParent) {

        XComponentPeer newPeer = (XComponentPeer)newNativeParent;

        XToolkit.awtLock();

        try {

            XlibWrapper.XReparentWindow(XToolkit.getDisplay(), getWindow(), newPeer.getContentWindow(), x, y);

            parentWindow = newPeer;

        } finally {

            XToolkit.awtUnlock();

        }

    }

    public boolean isReparentSupported() {

        return System.getProperty("sun.awt.X11.XComponentPeer.reparentNotSupported", "false").equals("false");

    }

    public boolean isObscured() {

        Container container  = (target instanceof Container) ?

            (Container)target : target.getParent();

        if (container == null) {

            return true;

        }

        Container parent;

        while ((parent = container.getParent()) != null) {

            container = parent;

        }

        if (container instanceof Window) {

            XWindowPeer wpeer = (XWindowPeer)(container.getPeer());

            if (wpeer != null) {

                return (wpeer.winAttr.visibilityState !=

                        wpeer.winAttr.AWT_UNOBSCURED);

            }

        }

        return true;

    }

    public boolean canDetermineObscurity() {

        return true;

    }

    /*************************************************

     * FOCUS STUFF

     *************************************************/

    /**

     * Keeps the track of focused state of the _NATIVE_ window

     */

    boolean bHasFocus = false;

    /**

     * Descendants should use this method to determine whether or not native window

     * has focus.

     */

    final public boolean hasFocus() {

        return bHasFocus;

    }

    /**

     * Called when component receives focus

     */

    public void focusGained(FocusEvent e) {

        focusLog.fine("{0}", e);

        bHasFocus = true;

    }

    /**

     * Called when component loses focus

     */

    public void focusLost(FocusEvent e) {

        focusLog.fine("{0}", e);

        bHasFocus = false;

    }

    public boolean isFocusable() {

        /* should be implemented by other sub-classes */

        return false;

    }

    private static Class seClass;

    private static Constructor seCtor;

    final static AWTEvent wrapInSequenced(AWTEvent event) {

        try {

            if (seClass == null) {

                seClass = Class.forName("java.awt.SequencedEvent");

            }

            if (seCtor == null) {

                seCtor = (Constructor) AccessController.doPrivileged(new PrivilegedExceptionAction() {

                        public Object run() throws Exception {

                            Constructor ctor = seClass.getConstructor(new Class[] { AWTEvent.class });

                            ctor.setAccessible(true);

                            return ctor;

                        }

                    });

            }

            return (AWTEvent) seCtor.newInstance(new Object[] { event });

        }

        catch (ClassNotFoundException e) {

            throw new NoClassDefFoundError("java.awt.SequencedEvent.");

        }

        catch (PrivilegedActionException ex) {

            throw new NoClassDefFoundError("java.awt.SequencedEvent.");

        }

        catch (InstantiationException e) {

            assert false;

        }

        catch (IllegalAccessException e) {

            assert false;

        }

        catch (InvocationTargetException e) {

            assert false;

        }

        return null;

    }

    // TODO: consider moving it to KeyboardFocusManagerPeerImpl

    final public boolean requestFocus(Component lightweightChild, boolean temporary,

                                      boolean focusedWindowChangeAllowed, long time,

                                      CausedFocusEvent.Cause cause)

    {

        if (XKeyboardFocusManagerPeer.

            processSynchronousLightweightTransfer(target, lightweightChild, temporary,

                                                  focusedWindowChangeAllowed, time))

        {

            return true;

        }

        int result = XKeyboardFocusManagerPeer.

            shouldNativelyFocusHeavyweight(target, lightweightChild,

                                           temporary, focusedWindowChangeAllowed,

                                           time, cause);

        switch (result) {

          case XKeyboardFocusManagerPeer.SNFH_FAILURE:

              return false;

          case XKeyboardFocusManagerPeer.SNFH_SUCCESS_PROCEED:

              // Currently we just generate focus events like we deal with lightweight instead of calling

              // XSetInputFocus on native window

              if (focusLog.isLoggable(PlatformLogger.FINER)) focusLog.finer("Proceeding with request to " +

                  lightweightChild + " in " + target);

              /**

               * The problems with requests in non-focused window arise because shouldNativelyFocusHeavyweight

               * checks that native window is focused while appropriate WINDOW_GAINED_FOCUS has not yet

               * been processed - it is in EventQueue. Thus, SNFH allows native request and stores request record

               * in requests list - and it breaks our requests sequence as first record on WGF should be the last

               * focus owner which had focus before WLF. So, we should not add request record for such requests

               * but store this component in mostRecent - and return true as before for compatibility.

               */

              Window parentWindow = SunToolkit.getContainingWindow(target);

              if (parentWindow == null) {

                  return rejectFocusRequestHelper("WARNING: Parent window is null");

              }

              XWindowPeer wpeer = (XWindowPeer)parentWindow.getPeer();

              if (wpeer == null) {

                  return rejectFocusRequestHelper("WARNING: Parent window's peer is null");

              }

              /*

               * Passing null 'actualFocusedWindow' as we don't want to restore focus on it

               * when a component inside a Frame is requesting focus.

               * See 6314575 for details.

               */

              boolean res = wpeer.requestWindowFocus(null);

              if (focusLog.isLoggable(PlatformLogger.FINER)) focusLog.finer("Requested window focus: " + res);

              // If parent window can be made focused and has been made focused(synchronously)

              // then we can proceed with children, otherwise we retreat.

              if (!(res && parentWindow.isFocused())) {

                  return rejectFocusRequestHelper("Waiting for asynchronous processing of the request");

              }

              return XKeyboardFocusManagerPeer.deliverFocus(lightweightChild,

                                                            (Component)target,

                                                            temporary,

                                                            focusedWindowChangeAllowed,

                                                            time, cause);

              // Motif compatibility code

          case XKeyboardFocusManagerPeer.SNFH_SUCCESS_HANDLED:

              // Either lightweight or excessive request - all events are generated.

              return true;

        }

        return false;

    }

    private boolean rejectFocusRequestHelper(String logMsg) {

        if (focusLog.isLoggable(PlatformLogger.FINER)) focusLog.finer(logMsg);

        XKeyboardFocusManagerPeer.removeLastFocusRequest(target);

        return false;

    }

    void handleJavaFocusEvent(AWTEvent e) {

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

        if (e.getID() == FocusEvent.FOCUS_GAINED) {

            focusGained((FocusEvent)e);

        } else {

            focusLost((FocusEvent)e);

        }

    }

    void handleJavaWindowFocusEvent(AWTEvent e) {

    }

    /*************************************************

     * END OF FOCUS STUFF

     *************************************************/

    public void setVisible(boolean b) {

        xSetVisible(b);

    }

    public void hide() {

        setVisible(false);

    }

    /**

     * @see java.awt.peer.ComponentPeer

     */

    public void setEnabled(final boolean value) {

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

            enableLog.fine("{0}ing {1}", (value ? "Enabl" : "Disabl"), this);

        }

        boolean status = value;

        // If any of our heavyweight ancestors are disable, we should be too

        // See 6176875 for more information

        final Container cp = SunToolkit.getNativeContainer(target);

        if (cp != null) {

            status &= ((XComponentPeer) cp.getPeer()).isEnabled();

        }

        synchronized (getStateLock()) {

            if (enabled == status) {

                return;

            }

            enabled = status;

        }

        if (target instanceof Container) {

            final Component[] list = ((Container) target).getComponents();

            for (final Component child : list) {

                final ComponentPeer p = child.getPeer();

                if (p != null) {

                    p.setEnabled(status && child.isEnabled());

                }

            }

        }

        repaint();

    }

    //

    // public so aw/Window can call it

    //

    public final boolean isEnabled() {

        synchronized (getStateLock()) {

            return enabled;

        }

    }

    @Override

    public void paint(final Graphics g) {

        super.paint(g);

        // allow target to change the picture

        target.paint(g);

    }

    public Graphics getGraphics() {

        return getGraphics(surfaceData, getPeerForeground(), getPeerBackground(), getPeerFont());

    }

    public void print(Graphics g) {

        // clear rect here to emulate X clears rect before Expose

        g.setColor(target.getBackground());

        g.fillRect(0, 0, target.getWidth(), target.getHeight());

        g.setColor(target.getForeground());

        // paint peer

        paintPeer(g);

        // allow target to change the picture

        target.print(g);

    }

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

        this.x = x;

        this.y = y;

        this.width = width;

        this.height = height;

        xSetBounds(x,y,width,height);

        validateSurface();

        layout();

    }

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

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

    }

    public void coalescePaintEvent(PaintEvent e) {

        Rectangle r = e.getUpdateRect();

        if (!(e instanceof IgnorePaintEvent)) {

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

        }

        if (true) {

            switch(e.getID()) {

              case PaintEvent.UPDATE:

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

                      log.finer("XCP coalescePaintEvent : UPDATE : add : x = " +

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

                  }

                  return;

              case PaintEvent.PAINT:

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

                      log.finer("XCP coalescePaintEvent : PAINT : add : x = " +

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

                  }

                  return;

            }

        }

    }

    XWindowPeer getParentTopLevel() {

        AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor();

        Container parent = (target instanceof Container) ? ((Container)target) : (compAccessor.getParent(target));

        // Search for parent window

        while (parent != null && !(parent instanceof Window)) {

            parent = compAccessor.getParent(parent);

        }

        if (parent != null) {

            return (XWindowPeer)compAccessor.getPeer(parent);

        } else {

            return null;

        }

    }

    /* This method is intended to be over-ridden by peers to perform user interaction */

    void handleJavaMouseEvent(MouseEvent e) {

        switch (e.getID()) {

          case MouseEvent.MOUSE_PRESSED:

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

                  !target.isFocusOwner() &&

                  XKeyboardFocusManagerPeer.shouldFocusOnClick(target))

              {

                  XWindowPeer parentXWindow = getParentTopLevel();

                  Window parentWindow = ((Window)parentXWindow.getTarget());

                  // Simple windows are non-focusable in X terms but focusable in Java terms.

                  // As X-non-focusable they don't receive any focus events - we should generate them

                  // by ourselfves.

//                   if (parentXWindow.isFocusableWindow() /*&& parentXWindow.isSimpleWindow()*/ &&

//                       !(getCurrentNativeFocusedWindow() == parentWindow))

//                   {

//                       setCurrentNativeFocusedWindow(parentWindow);

//                       WindowEvent wfg = new WindowEvent(parentWindow, WindowEvent.WINDOW_GAINED_FOCUS);

//                       parentWindow.dispatchEvent(wfg);

//                   }

                  XKeyboardFocusManagerPeer.requestFocusFor(target, CausedFocusEvent.Cause.MOUSE_EVENT);

              }

              break;

        }

    }