/*

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

import java.awt.dnd.DropTarget;

import java.awt.dnd.DropTargetListener;

import java.awt.event.*;

import java.awt.image.ColorModel;

import java.awt.image.ImageObserver;

import java.awt.image.ImageProducer;

import java.awt.image.VolatileImage;

import java.awt.peer.*;

import sun.awt.*;

import sun.awt.motif.X11FontMetrics;

import java.lang.reflect.*;

import java.util.logging.*;

import java.util.*;

import static sun.awt.X11.XEmbedHelper.*;

import java.security.AccessController;

import sun.security.action.GetBooleanAction;

public class XEmbedCanvasPeer extends XCanvasPeer implements WindowFocusListener, KeyEventPostProcessor, ModalityListener, WindowIDProvider {

    private static final Logger xembedLog = Logger.getLogger("sun.awt.X11.xembed.XEmbedCanvasPeer");

    boolean applicationActive; // Whether the application is active(has focus)

    XEmbedServer xembed = new XEmbedServer(); // Helper object, contains XEmbed intrinsics

    Map<Long, AWTKeyStroke> accelerators = new HashMap<Long, AWTKeyStroke>(); // Maps accelerator ID into AWTKeyStroke

    Map<AWTKeyStroke, Long> accel_lookup = new HashMap<AWTKeyStroke, Long>(); // Maps AWTKeyStroke into accelerator ID

    Set<GrabbedKey> grabbed_keys = new HashSet<GrabbedKey>(); // A set of keys grabbed by client

    Object ACCEL_LOCK = accelerators; // Lock object for working with accelerators;

    Object GRAB_LOCK = grabbed_keys; // Lock object for working with keys grabbed by client

    XEmbedCanvasPeer() {}

    XEmbedCanvasPeer(XCreateWindowParams params) {

        super(params);

    }

    XEmbedCanvasPeer(Component target) {

        super(target);

    }

    protected void postInit(XCreateWindowParams params) {

        super.postInit(params);

        installActivateListener();

        installAcceleratorListener();

        installModalityListener();

        // XEmbed canvas should be non-traversable.

        // FIXME: Probably should be removed and enforced setting of it by the users

        target.setFocusTraversalKeysEnabled(false);

    }

    protected void preInit(XCreateWindowParams params) {

        super.preInit(params);

        params.put(EVENT_MASK,

                   XConstants.KeyPressMask       | XConstants.KeyReleaseMask

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

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

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

    }

    void installModalityListener() {

        ((SunToolkit)Toolkit.getDefaultToolkit()).addModalityListener(this);

    }

    void deinstallModalityListener() {

        ((SunToolkit)Toolkit.getDefaultToolkit()).removeModalityListener(this);

    }

    void installAcceleratorListener() {

        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor(this);

    }

    void deinstallAcceleratorListener() {

        KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventPostProcessor(this);

    }

    void installActivateListener() {

        // FIXME: should watch for hierarchy changes

        Window toplevel = getTopLevel(target);

        if (toplevel != null) {

            toplevel.addWindowFocusListener(this);

            applicationActive = toplevel.isFocused();

        }

    }

    void deinstallActivateListener() {

        Window toplevel = getTopLevel(target);

        if (toplevel != null) {

            toplevel.removeWindowFocusListener(this);

        }

    }

    boolean isXEmbedActive() {

        return xembed.handle != 0;

    }

    boolean isApplicationActive() {

        return applicationActive;

    }

    void initDispatching() {

        if (xembedLog.isLoggable(Level.FINE)) xembedLog.fine("Init embedding for " + Long.toHexString(xembed.handle));

        XToolkit.awtLock();

        try {

            XToolkit.addEventDispatcher(xembed.handle, xembed);

            XlibWrapper.XSelectInput(XToolkit.getDisplay(), xembed.handle,

                                     XConstants.StructureNotifyMask | XConstants.PropertyChangeMask);

            XDropTargetRegistry.getRegistry().registerXEmbedClient(getWindow(), xembed.handle);

        } finally {

            XToolkit.awtUnlock();

        }

        xembed.processXEmbedInfo();

        notifyChildEmbedded();

    }

    void endDispatching() {

        xembedLog.fine("End dispatching for " + Long.toHexString(xembed.handle));

        XToolkit.awtLock();

        try {

            XDropTargetRegistry.getRegistry().unregisterXEmbedClient(getWindow(), xembed.handle);

            // We can't deselect input since someone else might be interested in it

            XToolkit.removeEventDispatcher(xembed.handle, xembed);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    void embedChild(long child) {

        if (xembed.handle != 0) {

            detachChild();

        }

        xembed.handle = child;

        initDispatching();

    }

    void childDestroyed() {

        xembedLog.fine("Child " + Long.toHexString(xembed.handle) + " has self-destroyed.");

        endDispatching();

        xembed.handle = 0;

    }

    public void handleEvent(AWTEvent e) {

        super.handleEvent(e);

        if (isXEmbedActive()) {

            switch (e.getID()) {

              case FocusEvent.FOCUS_GAINED:

                  canvasFocusGained((FocusEvent)e);

                  break;

              case FocusEvent.FOCUS_LOST:

                  canvasFocusLost((FocusEvent)e);

                  break;

              case KeyEvent.KEY_PRESSED:

              case KeyEvent.KEY_RELEASED:

                  if (!((InputEvent)e).isConsumed()) {

                      forwardKeyEvent((KeyEvent)e);

                  }

                  break;

            }

        }

    }

    public void dispatchEvent(XEvent ev) {

        super.dispatchEvent(ev);

        switch (ev.get_type()) {

          case XConstants.CreateNotify:

              XCreateWindowEvent cr = ev.get_xcreatewindow();

              if (xembedLog.isLoggable(Level.FINEST)) {

                  xembedLog.finest("Message on embedder: " + cr);

              }

              if (xembedLog.isLoggable(Level.FINER)) {

                  xembedLog.finer("Create notify for parent " + Long.toHexString(cr.get_parent()) +

                                  ", window " + Long.toHexString(cr.get_window()));

              }

              embedChild(cr.get_window());

              break;

          case XConstants.DestroyNotify:

              XDestroyWindowEvent dn = ev.get_xdestroywindow();

              if (xembedLog.isLoggable(Level.FINEST)) {

                  xembedLog.finest("Message on embedder: " + dn);

              }

              if (xembedLog.isLoggable(Level.FINER)) {

                  xembedLog.finer("Destroy notify for parent: " + dn);

              }

              childDestroyed();

              break;

          case XConstants.ReparentNotify:

              XReparentEvent rep = ev.get_xreparent();

              if (xembedLog.isLoggable(Level.FINEST)) {

                  xembedLog.finest("Message on embedder: " + rep);

              }

              if (xembedLog.isLoggable(Level.FINER)) {

                  xembedLog.finer("Reparent notify for parent " + Long.toHexString(rep.get_parent()) +

                                  ", window " + Long.toHexString(rep.get_window()) +

                                  ", event " + Long.toHexString(rep.get_event()));

              }

              if (rep.get_parent() == getWindow()) {

                  // Reparented into us - embed it

                  embedChild(rep.get_window());

              } else {

                  // Reparented out of us - detach it

                  childDestroyed();

              }

              break;

        }

    }

    public Dimension getPreferredSize() {

        if (isXEmbedActive()) {

            XToolkit.awtLock();

            try {

                long p_hints = XlibWrapper.XAllocSizeHints();

                XSizeHints hints = new XSizeHints(p_hints);

                XlibWrapper.XGetWMNormalHints(XToolkit.getDisplay(), xembed.handle, p_hints, XlibWrapper.larg1);

                Dimension res = new Dimension(hints.get_width(), hints.get_height());

                XlibWrapper.XFree(p_hints);

                return res;

            } finally {

                XToolkit.awtUnlock();

            }

        } else {

            return super.getPreferredSize();

        }

    }

    public Dimension getMinimumSize() {

        if (isXEmbedActive()) {

            XToolkit.awtLock();

            try {

                long p_hints = XlibWrapper.XAllocSizeHints();

                XSizeHints hints = new XSizeHints(p_hints);

                XlibWrapper.XGetWMNormalHints(XToolkit.getDisplay(), xembed.handle, p_hints, XlibWrapper.larg1);

                Dimension res = new Dimension(hints.get_min_width(), hints.get_min_height());

                XlibWrapper.XFree(p_hints);

                return res;

            } finally {

                XToolkit.awtUnlock();

            }

        } else {

            return super.getMinimumSize();

        }

    }

    public void dispose() {

        if (isXEmbedActive()) {

            detachChild();

        }

        deinstallActivateListener();

        deinstallModalityListener();

        deinstallAcceleratorListener();

        // BUG: Focus traversal doesn't become enabled after the one round of embedding

        //target.setFocusTraversalKeysEnabled(true);

        super.dispose();

    }

    // Focusable is true in order to enable focus traversal through this Canvas

    public boolean isFocusable() {

        return true;

    }

    Window getTopLevel(Component comp) {

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

            comp = comp.getParent();

        }

        return (Window)comp;

    }

    Rectangle getClientBounds() {

        XToolkit.awtLock();

        try {

            XWindowAttributes wattr = new XWindowAttributes();

            try {

                XToolkit.WITH_XERROR_HANDLER(XToolkit.IgnoreBadWindowHandler);

                int status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),

                                                              xembed.handle, wattr.pData);

                XToolkit.RESTORE_XERROR_HANDLER();

                if (status == 0 ||

                    (XToolkit.saved_error != null &&

                     XToolkit.saved_error.get_error_code() != XConstants.Success)) {

                    return null;

                }

                return new Rectangle(wattr.get_x(), wattr.get_y(), wattr.get_width(), wattr.get_height());

            } finally {

                wattr.dispose();

            }

        } finally {

            XToolkit.awtUnlock();

        }

    }

    void childResized() {

        if (xembedLog.isLoggable(Level.FINER)) {

            Rectangle bounds = getClientBounds();

            xembedLog.finer("Child resized: " + bounds);

            // It is not required to update embedder's size when client size changes

            // However, since there is no any means to get client size it seems to be the

            // only way to provide it. However, it contradicts with Java layout concept -

            // so it is disabled for now.

//             Rectangle my_bounds = getBounds();

//             setBounds(my_bounds.x, my_bounds.y, bounds.width, bounds.height, SET_BOUNDS);

        }

        XToolkit.postEvent(XToolkit.targetToAppContext(target), new ComponentEvent(target, ComponentEvent.COMPONENT_RESIZED));

    }

    void focusNext() {

        if (isXEmbedActive()) {

            xembedLog.fine("Requesting focus for the next component after embedder");

            postEvent(new InvocationEvent(target, new Runnable() {

                    public void run() {

                        KeyboardFocusManager.getCurrentKeyboardFocusManager().focusNextComponent(target);

                    }

                }));

        } else {

            xembedLog.fine("XEmbed is not active - denying focus next");

        }

    }

    void focusPrev() {

        if (isXEmbedActive()) {

            xembedLog.fine("Requesting focus for the next component after embedder");

            postEvent(new InvocationEvent(target, new Runnable() {

                    public void run() {

                        KeyboardFocusManager.getCurrentKeyboardFocusManager().focusPreviousComponent(target);

                    }

                }));

        } else {

            xembedLog.fine("XEmbed is not active - denying focus prev");

        }

    }

    void requestXEmbedFocus() {

        if (isXEmbedActive()) {

            xembedLog.fine("Requesting focus for client");

            postEvent(new InvocationEvent(target, new Runnable() {

                    public void run() {

                        target.requestFocus();

                    }

                }));

        } else {

            xembedLog.fine("XEmbed is not active - denying request focus");

        }

    }

    void notifyChildEmbedded() {

        xembed.sendMessage(xembed.handle, XEMBED_EMBEDDED_NOTIFY, getWindow(), Math.min(xembed.version, XEMBED_VERSION), 0);

        if (isApplicationActive()) {

            xembedLog.fine("Sending WINDOW_ACTIVATE during initialization");

            xembed.sendMessage(xembed.handle, XEMBED_WINDOW_ACTIVATE);

            if (hasFocus()) {

                xembedLog.fine("Sending FOCUS_GAINED during initialization");

                xembed.sendMessage(xembed.handle, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT, 0, 0);

            }

        }

    }

    void detachChild() {

        if (xembedLog.isLoggable(Level.FINE)) xembedLog.fine("Detaching child " + Long.toHexString(xembed.handle));

        /**

         *  XEmbed specification:

         *  "The embedder can unmap the client and reparent the client window to the root window. If the

         *  client receives an ReparentNotify event, it should check the parent field of the XReparentEvent

         *  structure. If this is the root window of the window's screen, then the protocol is finished and

         *  there is no further interaction. If it is a window other than the root window, then the protocol

         *  continues with the new parent acting as the embedder window."

         */

        XToolkit.awtLock();

        try {

            XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), xembed.handle);

            XlibWrapper.XReparentWindow(XToolkit.getDisplay(), xembed.handle, XToolkit.getDefaultRootWindow(), 0, 0);

        } finally {

            XToolkit.awtUnlock();

        }

        endDispatching();

        xembed.handle = 0;

    }

    public void windowGainedFocus(WindowEvent e) {

        applicationActive = true;

        if (isXEmbedActive()) {

            xembedLog.fine("Sending WINDOW_ACTIVATE");

            xembed.sendMessage(xembed.handle, XEMBED_WINDOW_ACTIVATE);

        }

    }

    public void windowLostFocus(WindowEvent e) {

        applicationActive = false;

        if (isXEmbedActive()) {

            xembedLog.fine("Sending WINDOW_DEACTIVATE");

            xembed.sendMessage(xembed.handle, XEMBED_WINDOW_DEACTIVATE);

        }

    }

    void canvasFocusGained(FocusEvent e) {

        if (isXEmbedActive()) {

            xembedLog.fine("Forwarding FOCUS_GAINED");

            int flavor = XEMBED_FOCUS_CURRENT;

            if (e instanceof CausedFocusEvent) {

                CausedFocusEvent ce = (CausedFocusEvent)e;

                if (ce.getCause() == CausedFocusEvent.Cause.TRAVERSAL_FORWARD) {

                    flavor = XEMBED_FOCUS_FIRST;

                } else if (ce.getCause() == CausedFocusEvent.Cause.TRAVERSAL_BACKWARD) {

                    flavor = XEMBED_FOCUS_LAST;

                }

            }

            xembed.sendMessage(xembed.handle, XEMBED_FOCUS_IN, flavor, 0, 0);

        }

    }

    void canvasFocusLost(FocusEvent e) {

        if (isXEmbedActive() && !e.isTemporary()) {

            xembedLog.fine("Forwarding FOCUS_LOST");

            int num = 0;

            if (AccessController.doPrivileged(new GetBooleanAction("sun.awt.xembed.testing"))) {

                Component opp = e.getOppositeComponent();

                try {

                    num = Integer.parseInt(opp.getName());

                } catch (NumberFormatException nfe) {

                }

            }

            xembed.sendMessage(xembed.handle, XEMBED_FOCUS_OUT, num, 0, 0);

        }

    }

    static Field bdataField;

    static byte[] getBData(KeyEvent e) {

        try {

            if (bdataField == null) {

                bdataField = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");

            }

            return (byte[])bdataField.get(e);

        } catch (IllegalAccessException ex) {

            return null;

        }

    }

    void forwardKeyEvent(KeyEvent e) {

        xembedLog.fine("Try to forward key event");

        byte[] bdata = getBData(e);

        long data = Native.toData(bdata);

        if (data == 0) {

            return;

        }

        try {

            XKeyEvent ke = new XKeyEvent(data);

            ke.set_window(xembed.handle);

            if (xembedLog.isLoggable(Level.FINE)) xembedLog.fine("Forwarding native key event: " + ke);

            XToolkit.awtLock();

            try {

                XlibWrapper.XSendEvent(XToolkit.getDisplay(), xembed.handle, false, XConstants.NoEventMask, data);

            } finally {

                XToolkit.awtUnlock();

            }

        } finally {

            XlibWrapper.unsafe.freeMemory(data);

        }

    }

    /**

     * Grab/ungrab key functionality is an unofficial API supported by

     * GTK.  Unfortunately, it doesn't support accelerator API, so,

     * since this is the ONLY shortcut-processing API available, we

     * must support it.  See XEmbed.NON_STANDARD_XEMBED_GTK_*

     * messages.  The format of these messages is as follows:

     * - request from client:

     * data[1] = NON_STANDARD_XEMBED_GTK_GRAB_KEY or NON_STANDARD_XEMBED_GTK_UNGRAB_KEY

     * data[3] = X keysym

     * data[4] = X modifiers

     *

     * - response from server (in case the grabbed key has been pressed):

     * forwarded XKeyEvent that matches keysym/modifiers pair

     */

    void grabKey(final long keysym, final long modifiers) {

        postEvent(new InvocationEvent(target, new Runnable() {

                public void run() {

                    GrabbedKey grab = new GrabbedKey(keysym, modifiers);

                    if (xembedLog.isLoggable(Level.FINE)) xembedLog.fine("Grabbing key: " + grab);

                    synchronized(GRAB_LOCK) {

                        grabbed_keys.add(grab);

                    }

                }

            }));

    }

    void ungrabKey(final long keysym, final long modifiers) {

        postEvent(new InvocationEvent(target, new Runnable() {

                public void run() {

                    GrabbedKey grab = new GrabbedKey(keysym, modifiers);

                    if (xembedLog.isLoggable(Level.FINE)) xembedLog.fine("UnGrabbing key: " + grab);

                    synchronized(GRAB_LOCK) {

                        grabbed_keys.remove(grab);

                    }

                }