/*

 * Copyright 2002-2008 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.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.KeyboardFocusManager;

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.awt.peer.LightweightPeer;

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

import sun.java2d.pipe.Region;

public class XComponentPeer extends XWindow implements ComponentPeer, DropTargetPeer,

    BackBufferCapsProvider

{

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

            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;

    }

    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;

    }

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

                  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(Level.FINER)) focusLog.finer(logMsg);

        XKeyboardFocusManagerPeer.removeLastFocusRequest(target);

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

        }

    }

    //

    // public so aw/Window can call it

    //

    public boolean isEnabled() {

        return enabled;

    }

    public void enable() {

        setEnabled(true);

    }

    public void disable() {

        setEnabled(false);

    }

    public void paint(Graphics g) {

    }

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

        repaint();

    }

    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

        paint(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:

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

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

                  return;

              case PaintEvent.PAINT:

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

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

                  return;

            }

        }

    }

    XWindowPeer getParentTopLevel() {

        Container parent = (target instanceof Container) ? ((Container)target) : (ComponentAccessor.getParent_NoClientCode(target));

        // Search for parent window

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

            parent = ComponentAccessor.getParent_NoClientCode(parent);

        }

        if (parent != null) {

            return (XWindowPeer)ComponentAccessor.getPeer(parent);

        } else {

            return null;

        }

    }

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