/*

 * Copyright 2002-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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.DefaultKeyboardFocusManager;

import java.awt.Dimension;

import java.awt.Event;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.Insets;

import java.awt.KeyboardFocusManager;

import java.awt.MenuBar;

import java.awt.Point;

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

import java.awt.peer.ComponentPeer;

import java.awt.peer.ContainerPeer;

import java.awt.peer.LightweightPeer;

import java.awt.peer.PanelPeer;

import java.awt.peer.WindowPeer;

import java.lang.reflect.*;

import java.security.*;

import java.util.Collection;

import java.util.HashSet;

import java.util.Set;

import java.util.Vector;

import java.util.logging.*;

import sun.awt.*;

import sun.awt.event.IgnorePaintEvent;

import sun.awt.image.SunVolatileImage;

import sun.awt.image.ToolkitImage;

import sun.java2d.pipe.Region;

public class XComponentPeer extends XWindow implements ComponentPeer, DropTargetPeer, XConstants {

    /* FIX ME: these constants copied from java.awt.KeyboardFocusManager */

    static final int SNFH_FAILURE = 0;

    static final int SNFH_SUCCESS_HANDLED = 1;

    static final int SNFH_SUCCESS_PROCEED = 2;

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

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

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

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

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

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

    boolean paintPending = false;

    boolean isLayouting = false;

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

        Color c;

        Font  f;

        Cursor cursor;

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

        }

        enabled = target.isEnabled();

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

        // See 6176875 for more information

        Component comp = target;

        while( !(comp == null || comp instanceof Window) ) {

            comp = comp.getParent();

            if( comp != null && !comp.isEnabled() && !comp.isLightweight() ){

                setEnabled(false);

                break;

            }

        }

        enableLog.log(Level.FINE, "Initial enable state: {0}", new Object[] {Boolean.valueOf(enabled)});

        if (target.isVisible()) {

            show();

        }

    }

    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;

    }

    static XComponentPeer getNativeContainer(Component comp) {

        if (comp == null) {

            return null;

        }

        synchronized(comp.getTreeLock()) {

            while (comp != null && (ComponentAccessor.getPeer(comp) instanceof LightweightPeer)) {

                comp = ComponentAccessor.getParent_NoClientCode(comp);

            }

            if (comp != null) {

                ComponentPeer peer = ComponentAccessor.getPeer(comp);

                if (peer != null && peer instanceof XComponentPeer) {

                    return (XComponentPeer)peer;

                }

            }

        }

        return null;

    }

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

     * 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.log(Level.FINE, "{0}", new Object[] {e});

        bHasFocus = true;

    }

    /**

     * Called when component loses focus

     */

    public void focusLost(FocusEvent e) {

        focusLog.log(Level.FINE, "{0}", new Object[] {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;

    }

    /**

     * Returns whether or not this component should be given focus on mouse click.

     * Default implementation return whether or not this peer is "focusable"

     * Descendants might want to override it to extend/restrict conditions at which this

     * component should be focused by click (see MCanvasPeer and MPanelPeer)

     */

    protected boolean shouldFocusOnClick() {

        return isFocusable();

    }

    /**

     * Checks whether or not this component would be focused by native system if it would be allowed to do so.

     * Currently it checks that it displayable, visible, enabled and focusable.

     */

    static boolean canBeFocusedByClick(Component component) {

        if (component == null) {

            return false;

        } else {

            return component.isDisplayable() && component.isVisible() && component.isEnabled() && component.isFocusable();

        }

    }

    static Window getContainingWindow(Component comp) {

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

            comp = comp.getParent();

        }

        return (Window)comp;

    }

    static Method processSynchronousLightweightTransferMethod;

    static boolean processSynchronousLightweightTransfer(Component heavyweight, Component descendant,

                                                  boolean temporary, boolean focusedWindowChangeAllowed,

                                                  long time)

    {

        try {

            if (processSynchronousLightweightTransferMethod == null) {

                processSynchronousLightweightTransferMethod =

                    (Method)AccessController.doPrivileged(

                        new PrivilegedExceptionAction() {

                                public Object run() throws IllegalAccessException, NoSuchMethodException

                                {

                                    Method m = KeyboardFocusManager.class.

                                        getDeclaredMethod("processSynchronousLightweightTransfer",

                                                          new Class[] {Component.class, Component.class,

                                                                       Boolean.TYPE, Boolean.TYPE,

                                                                       Long.TYPE});

                                    m.setAccessible(true);

                                    return m;

                                }

                            });

            }

            Object[] params = new Object[] {

                        heavyweight,

                        descendant,

                        Boolean.valueOf(temporary),

                        Boolean.valueOf(focusedWindowChangeAllowed),

                        Long.valueOf(time)

                    };

            return ((Boolean)processSynchronousLightweightTransferMethod.invoke(null, params)).booleanValue();

        } catch (PrivilegedActionException pae) {

            pae.printStackTrace();

            return false;

        } catch (IllegalAccessException iae) {

            iae.printStackTrace();

            return false;

        } catch (IllegalArgumentException iaee) {

            iaee.printStackTrace();

            return false;

        } catch (InvocationTargetException ite) {

            ite.printStackTrace();

            return false;

        }

    }

    static Method requestFocusWithCause;

    static void callRequestFocus(Component target, CausedFocusEvent.Cause cause) {

        if (requestFocusWithCause == null) {

            requestFocusWithCause = SunToolkit.getMethod(Component.class, "requestFocus", new Class[] {CausedFocusEvent.Cause.class});

        }

        if (requestFocusWithCause != null) {

            try {

                requestFocusWithCause.invoke(target, new Object[] {cause});

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

    }

    final public boolean requestFocus(Component lightweightChild, boolean temporary,

                                      boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)

    {

        if (processSynchronousLightweightTransfer(target, lightweightChild, temporary,

                                                  focusedWindowChangeAllowed, time))

        {

            return true;

        }

        int result = XKeyboardFocusManagerPeer

            .shouldNativelyFocusHeavyweight(target, lightweightChild,

                                            temporary, focusedWindowChangeAllowed, time, cause);

        switch (result) {

          case SNFH_FAILURE:

              return false;

          case SNFH_SUCCESS_PROCEED:

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

              // XSetInputFocus on native window

              if (focusLog.isLoggable(Level.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 = getContainingWindow(target);

              if (parentWindow != null) {

                  // and check that it is focused

                  if (!parentWindow.isFocused()) {

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

                      /*

                       * Fix for 6314575.

                       * Shouldn't restore focus on 'actualFocusedWindow'

                       * when a component inside a Frame is requesting it.

                       */

                      wpeer.setActualFocusedWindow(null);

                      boolean res = wpeer.requestWindowFocus();

                      if (focusLog.isLoggable(Level.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())) {

                          focusLog.finer("Waiting for asynchronous processing of window focus request");

                          KeyboardFocusManagerPeerImpl.removeLastFocusRequest(target);

                          return false;

                      }

                  }

              } else {

                  if (focusLog.isLoggable(Level.FINER)) focusLog.finer("WARNING: Parent window is null");

                  return false;

              }

              // NOTE: We simulate heavyweight behavior of Motif - component receives focus right

              // after request, not after event. Normally, we should better listen for event

              // by listeners.

              return XKeyboardFocusManagerPeer.simulateMotifRequestFocus(lightweightChild, target, temporary,

                                                                         focusedWindowChangeAllowed, time, cause);

              // Motif compatibility code

          case SNFH_SUCCESS_HANDLED:

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

              return true;

        }

        return false;

    }

    void handleJavaFocusEvent(AWTEvent e) {

        if (focusLog.isLoggable(Level.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 show() {

        setVisible(true);

    }

    public void hide() {

        setVisible(false);

    }

    /**

     * @see java.awt.peer.ComponentPeer

     */

    public void setEnabled(boolean value) {

        enableLog.log(Level.FINE, "{0}ing {1}", new Object[] {(value?"Enabl":"Disabl"), this});

        boolean repaintNeeded = (enabled != value);

        enabled = value;

        if (target instanceof Container) {

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

            for (int i = 0; i < list.length; ++i) {

                boolean childEnabled = list[i].isEnabled();

                ComponentPeer p = list[i].getPeer();

                if ( p != null ) {

                    p.setEnabled(value && childEnabled);

                }

            }

        }

        if (repaintNeeded) {

            repaint();

        }