/*

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

import java.awt.AWTEvent;

import java.awt.AWTException;

import java.awt.Component;

import java.awt.Container;

import java.awt.EventQueue;

import java.awt.Window;

import java.awt.event.InputMethodEvent;

import java.awt.font.TextAttribute;

import java.awt.font.TextHitInfo;

import java.awt.peer.ComponentPeer;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.lang.ref.WeakReference;

import java.util.StringTokenizer;

import java.util.regex.Pattern;

/**

 * Input Method Adapter for XIM

 *

 * @author JavaSoft International

 */

    /*

     * The following XIM* values must be the same as those defined in

     * Xlib.h

     */

    private static final int XIMReverse = (1<<0);

    private static final int XIMUnderline = (1<<1);

    private static final int XIMHighlight = (1<<2);

    private static final int XIMPrimary = (1<<5);

    private static final int XIMSecondary = (1<<6);

    private static final int XIMTertiary = (1<<7);

    /*

     * visible position values

     */

    private Locale locale;

    private static boolean isXIMOpened = false;

    protected Container clientComponentWindow = null;

    private static Map<TextAttribute, ?>[] highlightStyles;

    //reset the XIC if necessary

    private WeakReference<Component> needResetXICClient = new WeakReference<>(null);

    // The use of compositionEnableSupported is to reduce unnecessary

    // native calls if set/isCompositionEnabled

    // throws UnsupportedOperationException.

    // It is set to false if that exception is thrown first time

    // either of the two methods are called.

    // The savedCompositionState indicates the composition mode when

    // endComposition or setCompositionEnabled is called. It doesn't always

    // reflect the actual composition state because it doesn't get updated

    // when the user changes the composition state through direct interaction

    // with the input method. It is used to save the composition mode when

    // focus is traversed across different client components sharing the

    // same java input context. Also if set/isCompositionEnabled are not

    // supported, it remains false.

    // variables to keep track of preedit context.

    // these variables need to be accessed within AWT_LOCK/UNLOCK

    // private data (X11InputMethodData structure defined in

    // awt_InputMethod.c) for native methods

    // this structure needs to be accessed within AWT_LOCK/UNLOCK

    // Initialize highlight mapping table

    static {

        @SuppressWarnings({"unchecked", "rawtypes"})

        Map<TextAttribute, ?> styles[] = new Map[4];

        HashMap<TextAttribute, Object> map;

        // UNSELECTED_RAW_TEXT_HIGHLIGHT

        map = new HashMap<>(1);

        map.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);

        styles[0] = Collections.unmodifiableMap(map);

        // SELECTED_RAW_TEXT_HIGHLIGHT

        map = new HashMap<>(1);

        map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);

        styles[1] = Collections.unmodifiableMap(map);

        // UNSELECTED_CONVERTED_TEXT_HIGHLIGHT

        map = new HashMap<>(1);

        map.put(TextAttribute.INPUT_METHOD_UNDERLINE,

                TextAttribute.UNDERLINE_LOW_ONE_PIXEL);

        styles[2] = Collections.unmodifiableMap(map);

        // SELECTED_CONVERTED_TEXT_HIGHLIGHT

        map = new HashMap<>(1);

        map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);

        styles[3] = Collections.unmodifiableMap(map);

        highlightStyles = styles;

    }

    static {

        initIDs();

    }

    /**

     * Constructs an X11InputMethod instance. It initializes the XIM

     * environment if it's not done yet.

     *

     * @exception AWTException if XOpenIM() failed.

     */

        // supports only the locale in which the VM is started

        locale = X11InputMethodDescriptor.getSupportedLocale();

        if (initXIM() == false) {

            throw new AWTException("Cannot open X Input Method");

        }

    }

    @SuppressWarnings("deprecation")

    protected void finalize() throws Throwable {

        dispose();

        super.finalize();

    }

    /**

     * Invokes openIM() that invokes XOpenIM() if it's not opened yet.

     * @return  true if openXIM() is successful or it's already been opened.

     */

    private synchronized boolean initXIM() {

        if (isXIMOpened == false)

            isXIMOpened = openXIM();

        return isXIMOpened;

    }

    protected abstract boolean openXIM();

    protected boolean isDisposed() {

        return disposed;

    }

    protected abstract void setXICFocus(ComponentPeer peer,

                                    boolean value, boolean active);

    /**

     * Does nothing - this adapter doesn't use the input method context.

     *

     * @see java.awt.im.spi.InputMethod#setInputMethodContext

     */

    public void setInputMethodContext(InputMethodContext context) {

    }

    /**

     * Set locale to input. If input method doesn't support specified locale,

     * false will be returned and its behavior is not changed.

     *

     * @param lang locale to input

     * @return the true is returned when specified locale is supported.

     */

    public boolean setLocale(Locale lang) {

        if (lang.equals(locale)) {

            return true;

        }

        // special compatibility rule for Japanese and Korean

        if (locale.equals(Locale.JAPAN) && lang.equals(Locale.JAPANESE) ||

                locale.equals(Locale.KOREA) && lang.equals(Locale.KOREAN)) {

            return true;

        }

        return false;

    }

    /**

     * Returns current input locale.

     */

    public Locale getLocale() {

        return locale;

    }

    /**

     * Does nothing - XIM doesn't let you specify which characters you expect.

     *

     * @see java.awt.im.spi.InputMethod#setCharacterSubsets

     */

    public void setCharacterSubsets(Subset[] subsets) {

    }

    /**

     * Dispatch event to input method. InputContext dispatch event with this

     * method. Input method set consume flag if event is consumed in

     * input method.

     *

     * @param e event

     */

    public void dispatchEvent(AWTEvent e) {

    }

    protected final void resetXICifneeded(){

        /* needResetXIC is used to indicate whether to call

           resetXIC on the active client. resetXIC will always be

           called on the passive client when endComposition is called.

        */

        if (needResetXIC && haveActiveClient() &&

            getClientComponent() != needResetXICClient.get()){

            resetXIC();

            // needs to reset the last xic focussed component.

            lastXICFocussedComponent = null;

            isLastXICActive = false;

            needResetXICClient.clear();

            needResetXIC = false;

        }

    }

    /**

     * Reset the composition state to the current composition state.

     */

    /**

     * Query and then return the current composition state.

     * @return the composition state if isCompositionEnabled call

     * is successful. Otherwise, it returns false.

     */

        boolean compositionState = false;

        if (compositionEnableSupported) {

            try {

                compositionState = isCompositionEnabled();

            } catch (UnsupportedOperationException e) {

                compositionEnableSupported = false;

            }

        }

        return compositionState;

    }

    /**

     * Activate input method.

     */

    protected abstract boolean createXIC();

    /**

     * Deactivate input method.

     */

    /**

     * Explicitly disable the native IME. Native IME is not disabled when

     * deactivate is called.

     */

    public void disableInputMethod() {

        if (lastXICFocussedComponent != null) {

            setXICFocus(getPeer(lastXICFocussedComponent), false, isLastXICActive);

            lastXICFocussedComponent = null;

            isLastXICActive = false;

            resetXIC();

            needResetXICClient.clear();

            needResetXIC = false;

        }

    }

    // implements java.awt.im.spi.InputMethod.hideWindows

    /**

     * @see java.awt.Toolkit#mapInputMethodHighlight

     */

    public static Map<TextAttribute, ?> mapInputMethodHighlight(InputMethodHighlight highlight) {

        int index;

        int state = highlight.getState();

        if (state == InputMethodHighlight.RAW_TEXT) {

            index = 0;

        } else if (state == InputMethodHighlight.CONVERTED_TEXT) {

            index = 2;

        } else {

            return null;

        }

        if (highlight.isSelected()) {

            index += 1;

        }

        return highlightStyles[index];

    }

    /**

     * @see sun.awt.im.InputMethodAdapter#setAWTFocussedComponent

     */

    protected void setAWTFocussedComponent(Component component) {

        if (component == null) {

            return;

        }

        if (isActive) {

            // deactivate/activate are being suppressed during a focus change -

            // this may happen when an input method window is made visible

            boolean ac = haveActiveClient();

            setXICFocus(getPeer(awtFocussedComponent), false, ac);

            setXICFocus(getPeer(component), true, ac);

        }

        awtFocussedComponent = component;

    }

    /**

     * @see sun.awt.im.InputMethodAdapter#stopListening

     */

    protected void stopListening() {

        // It is desirable to disable XIM by calling XSetICValues with

        // XNPreeditState == XIMPreeditDisable.  But Solaris 2.6 and

        // Solaris 7 do not implement this correctly without a patch,

        // so just call resetXIC here.  Prior endComposition call commits

        // the existing composed text.

        endComposition();

        // disable the native input method so that the other input

        // method could get the input focus.

        disableInputMethod();

        if (needResetXIC) {

            resetXIC();

            needResetXICClient.clear();

            needResetXIC = false;

        }

    }

    /**

     * Returns the Window instance in which the client component is

     * contained. If not found, null is returned. (IS THIS POSSIBLE?)

     */

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

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

        Component client = getClientComponent();

        Container container;

        if (client instanceof Container) {

            container = (Container) client;

        } else {

            container = getParent(client);

        }

        while (container != null && !(container instanceof java.awt.Window)) {

            container = getParent(container);

        }

        return (Window) container;

    }

    protected abstract Container getParent(Component client);

    /**

     * Returns peer of the given client component. If the given client component

     * doesn't have peer, peer of the native container of the client is returned.

     */

    protected abstract ComponentPeer getPeer(Component client);

    /**

     * Used to protect preedit data

     */

    protected abstract void awtLock();

    protected abstract void awtUnlock();

    /**

     * Creates an input method event from the arguments given

     * and posts it on the AWT event queue. For arguments,

     * see InputMethodEvent. Called by input method.

     *

     * @see java.awt.event.InputMethodEvent#InputMethodEvent

     */

                                      AttributedCharacterIterator text,

                                      int committedCharacterCount,

                                      TextHitInfo caret,

                                      TextHitInfo visiblePosition,

                                      long when) {

        Component source = getClientComponent();

        if (source != null) {

            InputMethodEvent event = new InputMethodEvent(source,

                id, when, text, committedCharacterCount, caret, visiblePosition);

            SunToolkit.postEvent(SunToolkit.targetToAppContext(source), (AWTEvent)event);

        }

    }

    private void postInputMethodEvent(int id,

                                      AttributedCharacterIterator text,

                                      int committedCharacterCount,

                                      TextHitInfo caret,

                                      TextHitInfo visiblePosition) {

        postInputMethodEvent(id, text, committedCharacterCount,

                             caret, visiblePosition, EventQueue.getMostRecentEventTime());

    }

    /**

     * Dispatches committed text from XIM to the awt event queue. This

     * method is invoked from the event handler in canvas.c in the

     * AWT Toolkit thread context and thus inside the AWT Lock.

     * @param   str     committed text

     * @param   when    when

     */

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

    //       This functionality is implemented in a package-private method

    //       to insure that it cannot be overridden by client subclasses.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    void dispatchCommittedText(String str, long when) {

        if (str == null)

            return;

        if (composedText == null) {

            AttributedString attrstr = new AttributedString(str);

            postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,

                                 attrstr.getIterator(),

                                 str.length(),

                                 null,

                                 null,

                                 when);

        } else {

            // if there is composed text, wait until the preedit

            // callback is invoked.

            committedText = str;

        }

    }

    private void dispatchCommittedText(String str) {

        dispatchCommittedText(str, EventQueue.getMostRecentEventTime());

    }

    /**

     * Updates composed text with XIM preedit information and

     * posts composed text to the awt event queue. The args of

     * this method correspond to the XIM preedit callback

     * information. The XIM highlight attributes are translated via

     * fixed mapping (i.e., independent from any underlying input

     * method engine). This method is invoked in the AWT Toolkit

     * (X event loop) thread context and thus inside the AWT Lock.

     */

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

    //       This functionality is implemented in a package-private method

    //       to insure that it cannot be overridden by client subclasses.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

                                           int chgStyles[],

                                           int chgOffset,

                                           int chgLength,

                                           int caretPosition,

    /**

     * Flushes composed and committed text held in this context.

     * This method is invoked in the AWT Toolkit (X event loop) thread context

     * and thus inside the AWT Lock.

     */

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

    //       This functionality is implemented in a package-private method

    //       to insure that it cannot be overridden by client subclasses.

    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!

    void flushText() {

        String flush = (committedText != null ? committedText : "");

        if (composedText != null) {

            flush += composedText.toString();

        }

        if (!flush.equals("")) {

            AttributedString attrstr = new AttributedString(flush);

            postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,

                                 attrstr.getIterator(),

                                 flush.length(),