/*

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

import java.awt.event.*;

import java.awt.peer.ComponentPeer;

import java.awt.image.ColorModel;

import java.lang.ref.WeakReference;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import sun.util.logging.PlatformLogger;

import sun.awt.*;

import sun.awt.image.PixelConverter;

import sun.java2d.SunGraphics2D;

import sun.java2d.SurfaceData;

public class XWindow extends XBaseWindow implements X11ComponentPeer {

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

    private static PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XWindow");

    private static PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XWindow");

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

    private static PlatformLogger keyEventLog = PlatformLogger.getLogger("sun.awt.X11.kye.XWindow");

  /* If a motion comes in while a multi-click is pending,

   * allow a smudge factor so that moving the mouse by a small

   * amount does not wipe out the multi-click state variables.

   */

    private final static int AWT_MULTICLICK_SMUDGE = 4;

    // ButtonXXX events stuff

    static int rbutton = 0;

    static int lastX = 0, lastY = 0;

    static long lastTime = 0;

    static long lastButton = 0;

    static WeakReference lastWindowRef = null;

    static int clickCount = 0;

    // used to check if we need to re-create surfaceData.

    int oldWidth = -1;

    int oldHeight = -1;

    protected PropMwmHints mwm_hints;

    protected static XAtom wm_protocols;

    protected static XAtom wm_delete_window;

    protected static XAtom wm_take_focus;

    private boolean stateChanged; // Indicates whether the value on savedState is valid

    private int savedState; // Holds last known state of the top-level window

    XWindowAttributesData winAttr;

    protected X11GraphicsConfig graphicsConfig;

    protected AwtGraphicsConfigData graphicsConfigData;

    private boolean reparented;

    XWindow parent;

    Component target;

    private static int JAWT_LOCK_ERROR=0x00000001;

    private static int JAWT_LOCK_CLIP_CHANGED=0x00000002;

    private static int JAWT_LOCK_BOUNDS_CHANGED=0x00000004;

    private static int JAWT_LOCK_SURFACE_CHANGED=0x00000008;

    private int drawState = JAWT_LOCK_CLIP_CHANGED |

    JAWT_LOCK_BOUNDS_CHANGED |

    JAWT_LOCK_SURFACE_CHANGED;

    public static final String TARGET = "target",

        REPARENTED = "reparented"; // whether it is reparented by default

    SurfaceData surfaceData;

    XRepaintArea paintArea;

    // fallback default font object

    private static Font defaultFont;

    static synchronized Font getDefaultFont() {

        if (null == defaultFont) {

            defaultFont = new Font(Font.DIALOG, Font.PLAIN, 12);

        }

        return defaultFont;

    }

    /* A bitmask keeps the button's numbers as Button1Mask, Button2Mask, Button3Mask

     * which are allowed to

     * generate the CLICK event after the RELEASE has happened.

     * There are conditions that must be true for that sending CLICK event:

     * 1) button was initially PRESSED

     * 2) no movement or drag has happened until RELEASE

    */

    private int mouseButtonClickAllowed = 0;

    native int getNativeColor(Color clr, GraphicsConfiguration gc);

    native void getWMInsets(long window, long left, long top, long right, long bottom, long border);

    native long getTopWindow(long window, long rootWin);

    native void getWindowBounds(long window, long x, long y, long width, long height);

    private native static void initIDs();

    private static Field isPostedField;

    private static Field rawCodeField;

    private static Field primaryLevelUnicodeField;

    private static Field extendedKeyCodeField;

    static {

        initIDs();

    }

    XWindow(XCreateWindowParams params) {

        super(params);

    }

    XWindow() {

    }

    XWindow(long parentWindow, Rectangle bounds) {

        super(new XCreateWindowParams(new Object[] {

            BOUNDS, bounds,

            PARENT_WINDOW, Long.valueOf(parentWindow)}));

    }

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

        super(new XCreateWindowParams(new Object[] {

            BOUNDS, bounds,

            PARENT_WINDOW, Long.valueOf(parentWindow),

            TARGET, target}));

    }

    XWindow(Component target, long parentWindow) {

        this(target, parentWindow, new Rectangle(target.getBounds()));

    }

    XWindow(Component target) {

        this(target, (target.getParent() == null) ? 0 : getParentWindowID(target), new Rectangle(target.getBounds()));

    }

    XWindow(Object target) {

        this(null, 0, null);

    }

    /* This create is used by the XEmbeddedFramePeer since it has to create the window

       as a child of the netscape window. This netscape window is passed in as wid */

    XWindow(long parentWindow) {

        super(new XCreateWindowParams(new Object[] {

            PARENT_WINDOW, Long.valueOf(parentWindow),

            REPARENTED, Boolean.TRUE,

            EMBEDDED, Boolean.TRUE}));

    }

    protected void initGraphicsConfiguration() {

        graphicsConfig = (X11GraphicsConfig) target.getGraphicsConfiguration();

        graphicsConfigData = new AwtGraphicsConfigData(graphicsConfig.getAData());

    }

    void preInit(XCreateWindowParams params) {

        super.preInit(params);

        reparented = Boolean.TRUE.equals(params.get(REPARENTED));

        target = (Component)params.get(TARGET);

        initGraphicsConfiguration();

        AwtGraphicsConfigData gData = getGraphicsConfigurationData();

        X11GraphicsConfig config = (X11GraphicsConfig) getGraphicsConfiguration();

        XVisualInfo visInfo = gData.get_awt_visInfo();

        params.putIfNull(EVENT_MASK, XConstants.KeyPressMask | XConstants.KeyReleaseMask

            | XConstants.FocusChangeMask | XConstants.ButtonPressMask | XConstants.ButtonReleaseMask

            | XConstants.EnterWindowMask | XConstants.LeaveWindowMask | XConstants.PointerMotionMask

            | XConstants.ButtonMotionMask | XConstants.ExposureMask | XConstants.StructureNotifyMask);

        if (target != null) {

            params.putIfNull(BOUNDS, new Rectangle(target.getBounds()));

        } else {

            params.putIfNull(BOUNDS, new Rectangle(0, 0, MIN_SIZE, MIN_SIZE));

        }

        params.putIfNull(BORDER_PIXEL, Long.valueOf(0));

        getColorModel(); // fix 4948833: this call forces the color map to be initialized

        params.putIfNull(COLORMAP, gData.get_awt_cmap());

        params.putIfNull(DEPTH, gData.get_awt_depth());

        params.putIfNull(VISUAL_CLASS, Integer.valueOf((int)XConstants.InputOutput));

        params.putIfNull(VISUAL, visInfo.get_visual());

        params.putIfNull(VALUE_MASK, XConstants.CWBorderPixel | XConstants.CWEventMask | XConstants.CWColormap);

        Long parentWindow = (Long)params.get(PARENT_WINDOW);

        if (parentWindow == null || parentWindow.longValue() == 0) {

            XToolkit.awtLock();

            try {

                int screen = visInfo.get_screen();

                if (screen != -1) {

                    params.add(PARENT_WINDOW, XlibWrapper.RootWindow(XToolkit.getDisplay(), screen));

                } else {

                    params.add(PARENT_WINDOW, XToolkit.getDefaultRootWindow());

                }

            } finally {

                XToolkit.awtUnlock();

            }

        }

        paintArea = new XRepaintArea();

        if (target != null) {

            this.parent = getParentXWindowObject(target.getParent());

        }

        params.putIfNull(BACKING_STORE, XToolkit.getBackingStoreType());

        XToolkit.awtLock();

        try {

            if (wm_protocols == null) {

                wm_protocols = XAtom.get("WM_PROTOCOLS");

                wm_delete_window = XAtom.get("WM_DELETE_WINDOW");

                wm_take_focus = XAtom.get("WM_TAKE_FOCUS");

            }

        }

        finally {

            XToolkit.awtUnlock();

        }

        winAttr = new XWindowAttributesData();

        savedState = XUtilConstants.WithdrawnState;

    }

    void postInit(XCreateWindowParams params) {

        super.postInit(params);

        setWMClass(getWMClass());

        surfaceData = graphicsConfig.createSurfaceData(this);

        Color c;

        if (target != null && (c = target.getBackground()) != null) {

            // We need a version of setBackground that does not call repaint !!

            // and one that does not get overridden. The problem is that in postInit

            // we call setBackground and we dont have all the stuff initialized to

            // do a full paint for most peers. So we cannot call setBackground in postInit.

            // instead we need to call xSetBackground.

            xSetBackground(c);

        }

    }

    public GraphicsConfiguration getGraphicsConfiguration() {

        if (graphicsConfig == null) {

            initGraphicsConfiguration();

        }

        return graphicsConfig;

    }

    public AwtGraphicsConfigData getGraphicsConfigurationData() {

        if (graphicsConfigData == null) {

            initGraphicsConfiguration();

        }

        return graphicsConfigData;

    }

    protected String[] getWMClass() {

        return new String[] {XToolkit.getCorrectXIDString(getClass().getName()), XToolkit.getAWTAppClassName()};

    }

    void setReparented(boolean newValue) {

        reparented = newValue;

    }

    boolean isReparented() {

        return reparented;

    }

    static long getParentWindowID(Component target) {

        ComponentPeer peer = target.getParent().getPeer();

        Component temp = target.getParent();

        while (!(peer instanceof XWindow))

        {

            temp = temp.getParent();

            peer = temp.getPeer();

        }

        if (peer != null && peer instanceof XWindow)

            return ((XWindow)peer).getContentWindow();

        else return 0;

    }

    static XWindow getParentXWindowObject(Component target) {

        if (target == null) return null;

        Component temp = target.getParent();

        if (temp == null) return null;

        ComponentPeer peer = temp.getPeer();

        if (peer == null) return null;

        while ((peer != null) && !(peer instanceof XWindow))

        {

            temp = temp.getParent();

            peer = temp.getPeer();

        }

        if (peer != null && peer instanceof XWindow)

            return (XWindow) peer;

        else return null;

    }

    boolean isParentOf(XWindow win) {

        if (!(target instanceof Container) || win == null || win.getTarget() == null) {

            return false;

        }

        Container parent = ComponentAccessor.getParent_NoClientCode(win.target);

        while (parent != null && parent != target) {

            parent = ComponentAccessor.getParent_NoClientCode(parent);

        }

        return (parent == target);

    }

    public Object getTarget() {

        return target;

    }

    public Component getEventSource() {

        return target;

    }

    public ColorModel getColorModel(int transparency) {

        return graphicsConfig.getColorModel (transparency);

    }

    public ColorModel getColorModel() {

        if (graphicsConfig != null) {

            return graphicsConfig.getColorModel ();

        }

        else {

            return XToolkit.getStaticColorModel();

        }

    }

    Graphics getGraphics(SurfaceData surfData, Color afore, Color aback, Font afont) {

        if (surfData == null) return null;

        Component target = (Component) this.target;

        /* Fix for bug 4746122. Color and Font shouldn't be null */

        Color bgColor = aback;

        if (bgColor == null) {

            bgColor = SystemColor.window;

        }

        Color fgColor = afore;

        if (fgColor == null) {

            fgColor = SystemColor.windowText;

        }

        Font font = afont;

        if (font == null) {

            font = XWindow.getDefaultFont();

        }

        return new SunGraphics2D(surfData, fgColor, bgColor, font);

    }

    public Graphics getGraphics() {

        return getGraphics(surfaceData,

                           target.getForeground(),

                           target.getBackground(),

                           target.getFont());

    }

    public FontMetrics getFontMetrics(Font font) {

        return Toolkit.getDefaultToolkit().getFontMetrics(font);

    }

    public Rectangle getTargetBounds() {

        return target.getBounds();

    }

    /**

     * Returns true if the event has been handled and should not be

     * posted to Java.

     */

    boolean prePostEvent(AWTEvent e) {

        return false;

    }

    static Method m_sendMessage;

    static void sendEvent(final AWTEvent e) {

        if (isPostedField == null) {

            isPostedField = SunToolkit.getField(AWTEvent.class, "isPosted");

        }

        PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {

                public void run() {

                    try {

                        isPostedField.setBoolean(e, true);

                    } catch (IllegalArgumentException e) {

                        assert(false);

                    } catch (IllegalAccessException e) {

                        assert(false);

                    }

                    ((Component)e.getSource()).dispatchEvent(e);

                }

            }, PeerEvent.ULTIMATE_PRIORITY_EVENT);

        if (focusLog.isLoggable(PlatformLogger.FINER) && (e instanceof FocusEvent)) focusLog.finer("Sending " + e);

        XToolkit.postEvent(XToolkit.targetToAppContext(e.getSource()), pe);

    }

/*

 * Post an event to the event queue.

 */

// NOTE: This method may be called by privileged threads.

//       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    void postEvent(AWTEvent event) {

        XToolkit.postEvent(XToolkit.targetToAppContext(event.getSource()), event);

    }

    static void postEventStatic(AWTEvent event) {

        XToolkit.postEvent(XToolkit.targetToAppContext(event.getSource()), event);

    }

    public void postEventToEventQueue(final AWTEvent event) {

        //fix for 6239938 : Choice drop-down does not disappear when it loses focus, on XToolkit

        if (!prePostEvent(event)) {

            //event hasn't been handled and must be posted to EventQueue

            postEvent(event);

        }

    }

    // overriden in XCanvasPeer

    protected boolean doEraseBackground() {

        return true;

    }

    // We need a version of setBackground that does not call repaint !!

    // and one that does not get overridden. The problem is that in postInit

    // we call setBackground and we dont have all the stuff initialized to

    // do a full paint for most peers. So we cannot call setBackground in postInit.

    final public void xSetBackground(Color c) {

        XToolkit.awtLock();

        try {

            winBackground(c);

            // fix for 6558510: handle sun.awt.noerasebackground flag,

            // see doEraseBackground() and preInit() methods in XCanvasPeer

            if (!doEraseBackground()) {

                return;

            }

            // 6304250: XAWT: Items in choice show a blue border on OpenGL + Solaris10 when background color is set

            // Note: When OGL is enabled, surfaceData.pixelFor() will not

            // return a pixel value appropriate for passing to

            // XSetWindowBackground().  Therefore, we will use the ColorModel

            // for this component in order to calculate a pixel value from

            // the given RGB value.

            ColorModel cm = getColorModel();

            int pixel = PixelConverter.instance.rgbToPixel(c.getRGB(), cm);

            XlibWrapper.XSetWindowBackground(XToolkit.getDisplay(), getContentWindow(), pixel);

        }

        finally {

            XToolkit.awtUnlock();

        }

    }

    public void setBackground(Color c) {

        xSetBackground(c);

    }

    Color backgroundColor;

    void winBackground(Color c) {

        backgroundColor = c;

    }

    public Color getWinBackground() {

        Color c = null;

        if (backgroundColor != null) {

            c = backgroundColor;

        } else if (parent != null) {

            c = parent.getWinBackground();

        }

        if (c instanceof SystemColor) {

            c = new Color(c.getRGB());

        }

        return c;

    }

    public boolean isEmbedded() {

        return embedded;

    }

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

        if (!isVisible()) {

            return;

        }

        Graphics g = getGraphics();

        if (g != null) {

            try {

                g.setClip(x,y,width,height);

                paint(g);

            } finally {

                g.dispose();

            }

        }

    }

    public  void repaint() {

        if (!isVisible()) {

            return;

        }