https://openjdk.java.net/ 
/*
 * Copyright (c) 2002, Oracle and/or its affiliates. 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.  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.
 */

/*
 * (C) Copyright IBM Corp. 2000 - All Rights Reserved
 *
 * The original version of this source code and documentation is
 * copyrighted and owned by IBM. These materials are provided
 * under terms of a License Agreement between IBM and Sun.
 * This technology is protected by multiple US and International
 * patents. This notice and attribution to IBM may not be removed.
 *
 */

package com.sun.inputmethods.internal.indicim;

import java.awt.im.spi.InputMethod;
import java.awt.im.spi.InputMethodContext;

import java.awt.AWTEvent;
import java.awt.Rectangle;

import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;

import java.lang.Character.Subset;

import java.util.Locale;

class IndicInputMethod implements InputMethod {

    private IndicInputMethodImpl impl;
    private Locale locale;

    IndicInputMethod(Locale theLocale, IndicInputMethodImpl theImplementation) {
        locale = theLocale;
        impl = theImplementation;
    }

    
Sets the input method context, which is used to dispatch input method
events to the client component and to request information from
the client component.


This method is called once immediately after instantiating this input
method.

Params:
  • context – the input method context for this input method
Throws:
/**
     * Sets the input method context, which is used to dispatch input method
     * events to the client component and to request information from
     * the client component.
     * <p>
     * This method is called once immediately after instantiating this input
     * method.
     *
     * @param context the input method context for this input method
     * @exception NullPointerException if <code>context</code> is null
     */
    public void setInputMethodContext(InputMethodContext context) {

        impl.setInputMethodContext(context);
    }

    
Attempts to set the input locale. If the input method supports the
desired locale, it changes its behavior to support input for the locale
and returns true.
Otherwise, it returns false and does not change its behavior.


This method is called

    

  • by InputContext.selectInputMethod, 
  • when switching to this input method through the user interface if the user specified a locale or if the previously selected input method's getLocale method returns a non-null value. 


Params:
  • locale – locale to input
Throws:
Returns:whether the specified locale is supported
/**
     * Attempts to set the input locale. If the input method supports the
     * desired locale, it changes its behavior to support input for the locale
     * and returns true.
     * Otherwise, it returns false and does not change its behavior.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#selectInputMethod InputContext.selectInputMethod},
     * <li>when switching to this input method through the user interface if the user
     *     specified a locale or if the previously selected input method's
     *     {@link java.awt.im.spi.InputMethod#getLocale getLocale} method
     *     returns a non-null value.
     * </ul>
     *
     * @param locale locale to input
     * @return whether the specified locale is supported
     * @exception NullPointerException if <code>locale</code> is null
     */
    public boolean setLocale(Locale locale) {

        if (locale.getLanguage().equals(this.locale.getLanguage())) {
            //System.out.println("returning true for locale " + locale);
            return true;
        }
        else {
            //System.out.println("returning false for locale " + locale);
            return false;
        }
    }

    
Returns the current input locale. Might return null in exceptional cases.


This method is called

    

  • by InputContext.getLocale and 
  • when switching from this input method to a different one through the
    user interface.



Returns:the current input locale, or null
/**
     * Returns the current input locale. Might return null in exceptional cases.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#getLocale InputContext.getLocale} and
     * <li>when switching from this input method to a different one through the
     *     user interface.
     * </ul>
     *
     * @return the current input locale, or null
     */
    public Locale getLocale() {

        return locale;
    }

    
Sets the subsets of the Unicode character set that this input method
is allowed to input. Null may be passed in to indicate that all
characters are allowed.


This method is called



Params:
  • subsets – the subsets of the Unicode character set from which
characters may be input
/**
     * Sets the subsets of the Unicode character set that this input method
     * is allowed to input. Null may be passed in to indicate that all
     * characters are allowed.
     * <p>
     * This method is called
     * <ul>
     * <li>immediately after instantiating this input method,
     * <li>when switching to this input method from a different one, and
     * <li>by {@link java.awt.im.InputContext#setCharacterSubsets InputContext.setCharacterSubsets}.
     * </ul>
     *
     * @param subsets the subsets of the Unicode character set from which
     * characters may be input
     */
    public void setCharacterSubsets(Subset[] subsets) {
    }

    
Enables or disables this input method for composition,
depending on the value of the parameter enable.


An input method that is enabled for composition interprets incoming
events for both composition and control purposes, while a
disabled input method does not interpret events for composition.
Note however that events are passed on to the input method regardless
whether it is enabled or not, and that an input method that is disabled
for composition may still interpret events for control purposes,
including to enable or disable itself for composition.


This method is called



Params:
  • enable – whether to enable the input method for composition
Throws:
See Also:
/**
     * Enables or disables this input method for composition,
     * depending on the value of the parameter <code>enable</code>.
     * <p>
     * An input method that is enabled for composition interprets incoming
     * events for both composition and control purposes, while a
     * disabled input method does not interpret events for composition.
     * Note however that events are passed on to the input method regardless
     * whether it is enabled or not, and that an input method that is disabled
     * for composition may still interpret events for control purposes,
     * including to enable or disable itself for composition.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#setCompositionEnabled InputContext.setCompositionEnabled},
     * <li>when switching to this input method from a different one using the
     *     user interface or
     *     {@link java.awt.im.InputContext#selectInputMethod InputContext.selectInputMethod},
     *     if the previously selected input method's
     *     {@link java.awt.im.spi.InputMethod#isCompositionEnabled isCompositionEnabled}
     *     method returns without throwing an exception.
     * </ul>
     *
     * @param enable whether to enable the input method for composition
     * @throws UnsupportedOperationException if this input method does not
     * support the enabling/disabling operation
     * @see #isCompositionEnabled
     */
    public void setCompositionEnabled(boolean enable) {

        throw new UnsupportedOperationException();
    }

    
Determines whether this input method is enabled.
An input method that is enabled for composition interprets incoming
events for both composition and control purposes, while a
disabled input method does not interpret events for composition.


This method is called



Throws:
See Also:
Returns:true if this input method is enabled for
composition; false otherwise.
/**
     * Determines whether this input method is enabled.
     * An input method that is enabled for composition interprets incoming
     * events for both composition and control purposes, while a
     * disabled input method does not interpret events for composition.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#isCompositionEnabled InputContext.isCompositionEnabled} and
     * <li>when switching from this input method to a different one using the
     *     user interface or
     *     {@link java.awt.im.InputContext#selectInputMethod InputContext.selectInputMethod}.
     * </ul>
     *
     * @return <code>true</code> if this input method is enabled for
     * composition; <code>false</code> otherwise.
     * @throws UnsupportedOperationException if this input method does not
     * support checking whether it is enabled for composition
     * @see #setCompositionEnabled
     */
    public boolean isCompositionEnabled() {

        return true;
    }

    
Starts the reconversion operation. The input method obtains the text to be reconverted from the current client component using the InputMethodRequests.getSelectedText method. It can use other InputMethodRequests
methods to request additional information required for the
reconversion operation. The composed and committed text
produced by the operation is sent to the client component as a
sequence of InputMethodEvents. If the given text
cannot be reconverted, the same text should be sent to the
client component as committed text.

 This method is called by InputContext.reconvert. 
Throws:
/**
     * Starts the reconversion operation. The input method obtains the
     * text to be reconverted from the current client component using the
     * {@link java.awt.im.InputMethodRequests#getSelectedText InputMethodRequests.getSelectedText}
     * method. It can use other <code>InputMethodRequests</code>
     * methods to request additional information required for the
     * reconversion operation. The composed and committed text
     * produced by the operation is sent to the client component as a
     * sequence of <code>InputMethodEvent</code>s. If the given text
     * cannot be reconverted, the same text should be sent to the
     * client component as committed text.
     * <p>
     * This method is called by
     * {@link java.awt.im.InputContext#reconvert() InputContext.reconvert}.
     *
     * @throws UnsupportedOperationException if the input method does not
     * support the reconversion operation.
     */
    public void reconvert() {

        throw new UnsupportedOperationException("This input method does not reconvert.");
    }

    
Dispatches the event to the input method. If input method support is
enabled for the focussed component, incoming events of certain types
are dispatched to the current input method for this component before
they are dispatched to the component's methods or event listeners.
The input method decides whether it needs to handle the event. If it
does, it also calls the event's consume method; this
causes the event to not get dispatched to the component's event
processing methods or event listeners.


Events are dispatched if they are instances of InputEvent or its
subclasses.
This includes instances of the AWT classes KeyEvent and MouseEvent.

 This method is called by InputContext.dispatchEvent. 
Params:
  • event – the event being dispatched to the input method
Throws:
/**
     * Dispatches the event to the input method. If input method support is
     * enabled for the focussed component, incoming events of certain types
     * are dispatched to the current input method for this component before
     * they are dispatched to the component's methods or event listeners.
     * The input method decides whether it needs to handle the event. If it
     * does, it also calls the event's <code>consume</code> method; this
     * causes the event to not get dispatched to the component's event
     * processing methods or event listeners.
     * <p>
     * Events are dispatched if they are instances of InputEvent or its
     * subclasses.
     * This includes instances of the AWT classes KeyEvent and MouseEvent.
     * <p>
     * This method is called by {@link java.awt.im.InputContext#dispatchEvent InputContext.dispatchEvent}.
     *
     * @param event the event being dispatched to the input method
     * @exception NullPointerException if <code>event</code> is null
     */
    public void dispatchEvent(AWTEvent event) {

        if (event instanceof KeyEvent) {

            KeyEvent keyEvent = (KeyEvent) event;
            if (event.getID() == KeyEvent.KEY_TYPED) {
                impl.handleKeyTyped(keyEvent);
            }
            //System.out.println("handled event " + event);
        }
        else {
            //System.out.println("did not handle event " + event);
        }
    }

    
Notifies this input method of changes in the client window location or state. This method is called while this input method is the current input method of its input context and notifications for it are enabled (see 
InputMethodContext.enableClientWindowNotification). Calls to this method are temporarily suspended if the input context's removeNotify method is called, and resume when the input method is activated for a new client component. It is called in the following situations: 
    

  • 
when the window containing the current client component changes
in location, size, visibility, iconification state, or when the
window is closed.
    • 

  • 
from  enableClientWindowNotification(inputMethod,
true) if the current client component exists,
    • 

  • 
when activating the input method for the first time after it
called
enableClientWindowNotification(inputMethod,
true) if during the call no current client component was
available,
    • 

  • 
when activating the input method for a new client component
after the input context's removeNotify method has been
called.
    • 



Params:
  • bounds – client window's bounds on the screen; or null if the client window is iconified or invisible
/**
     * Notifies this input method of changes in the client window
     * location or state. This method is called while this input
     * method is the current input method of its input context and
     * notifications for it are enabled (see {@link
     * InputMethodContext#enableClientWindowNotification
     * InputMethodContext.enableClientWindowNotification}). Calls
     * to this method are temporarily suspended if the input context's
     * {@link java.awt.im.InputContext#removeNotify removeNotify}
     * method is called, and resume when the input method is activated
     * for a new client component. It is called in the following
     * situations:
     * <ul>
     * <li>
     * when the window containing the current client component changes
     * in location, size, visibility, iconification state, or when the
     * window is closed.</li>
     * <li>
     * from <code> enableClientWindowNotification(inputMethod,
     * true)</code> if the current client component exists,</li>
     * <li>
     * when activating the input method for the first time after it
     * called
     * <code>enableClientWindowNotification(inputMethod,
     * true)</code> if during the call no current client component was
     * available,</li>
     * <li>
     * when activating the input method for a new client component
     * after the input context's removeNotify method has been
     * called.</li>
     * </ul>
     * @param bounds client window's {@link
     * java.awt.Component#getBounds bounds} on the screen; or null if
     * the client window is iconified or invisible
     */
    public void notifyClientWindowChange(Rectangle bounds) {
    }

    
Activates the input method for immediate input processing.


If an input method provides its own windows, it should make sure
at this point that all necessary windows are open and visible.


This method is called


The method is only called when the input method is inactive.
A newly instantiated input method is assumed to be inactive.

/**
     * Activates the input method for immediate input processing.
     * <p>
     * If an input method provides its own windows, it should make sure
     * at this point that all necessary windows are open and visible.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#dispatchEvent InputContext.dispatchEvent}
     *     when a client component receives a FOCUS_GAINED event,
     * <li>when switching to this input method from a different one using the
     *     user interface or
     *     {@link java.awt.im.InputContext#selectInputMethod InputContext.selectInputMethod}.
     * </ul>
     * The method is only called when the input method is inactive.
     * A newly instantiated input method is assumed to be inactive.
     */
    public void activate() {
        //System.out.println("activated");
    }

    
Deactivates the input method. The isTemporary argument has the same meaning as in FocusEvent.isTemporary. 
 If an input method provides its own windows, only windows that relate to the current composition (such as a lookup choice window) should be closed at this point. It is possible that the input method will be immediately activated again for a different client component, and closing and reopening more persistent windows (such as a control panel) would create unnecessary screen flicker. Before an instance of a different input method class is activated, hideWindows is called on the current input method. 

This method is called


The method is only called when the input method is active.

Params:
  • isTemporary – whether the focus change is temporary
/**
     * Deactivates the input method.
     * The isTemporary argument has the same meaning as in
     * {@link java.awt.event.FocusEvent#isTemporary FocusEvent.isTemporary}.
     * <p>
     * If an input method provides its own windows, only windows that relate
     * to the current composition (such as a lookup choice window) should be
     * closed at this point.
     * It is possible that the input method will be immediately activated again
     * for a different client component, and closing and reopening more
     * persistent windows (such as a control panel) would create unnecessary
     * screen flicker.
     * Before an instance of a different input method class is activated,
     * {@link #hideWindows} is called on the current input method.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#dispatchEvent InputContext.dispatchEvent}
     *     when a client component receives a FOCUS_LOST event,
     * <li>when switching from this input method to a different one using the
     *     user interface or
     *     {@link java.awt.im.InputContext#selectInputMethod InputContext.selectInputMethod},
     * <li>before {@link #removeNotify removeNotify} if the current client component is
     *     removed.
     * </ul>
     * The method is only called when the input method is active.
     *
     * @param isTemporary whether the focus change is temporary
     */
    public void deactivate(boolean isTemporary) {
        //System.out.println("deactivated");
    }

    
Closes or hides all windows opened by this input method instance or
its class.


This method is called

    

  • before calling activate on an instance of a different input method class, 
  • before calling dispose on this input method. 

The method is only called when the input method is inactive.

/**
     * Closes or hides all windows opened by this input method instance or
     * its class.
     * <p>
     * This method is called
     * <ul>
     * <li>before calling {@link #activate activate} on an instance of a different input
     *     method class,
     * <li>before calling {@link #dispose dispose} on this input method.
     * </ul>
     * The method is only called when the input method is inactive.
     */
    public void hideWindows() {
    }

    
Notifies the input method that a client component has been
removed from its containment hierarchy, or that input method
support has been disabled for the component.

 This method is called by InputContext.removeNotify. 

The method is only called when the input method is inactive.

/**
     * Notifies the input method that a client component has been
     * removed from its containment hierarchy, or that input method
     * support has been disabled for the component.
     * <p>
     * This method is called by {@link java.awt.im.InputContext#removeNotify InputContext.removeNotify}.
     * <p>
     * The method is only called when the input method is inactive.
     */
    public void removeNotify() {
    }

    
Ends any input composition that may currently be going on in this
context. Depending on the platform and possibly user preferences,
this may commit or delete uncommitted text. Any changes to the text
are communicated to the active component using an input method event.


A text editing component may call this in a variety of situations,
for example, when the user moves the insertion point within the text
(but outside the composed text), or when the component's text is
saved to a file or copied to the clipboard.


This method is called



/**
     * Ends any input composition that may currently be going on in this
     * context. Depending on the platform and possibly user preferences,
     * this may commit or delete uncommitted text. Any changes to the text
     * are communicated to the active component using an input method event.
     *
     * <p>
     * A text editing component may call this in a variety of situations,
     * for example, when the user moves the insertion point within the text
     * (but outside the composed text), or when the component's text is
     * saved to a file or copied to the clipboard.
     * <p>
     * This method is called
     * <ul>
     * <li>by {@link java.awt.im.InputContext#endComposition InputContext.endComposition},
     * <li>by {@link java.awt.im.InputContext#dispatchEvent InputContext.dispatchEvent}
     *     when switching to a different client component
     * <li>when switching from this input method to a different one using the
     *     user interface or
     *     {@link java.awt.im.InputContext#selectInputMethod InputContext.selectInputMethod}.
     * </ul>
     */
    public void endComposition() {

        impl.endComposition();
    }

    
Disposes of the input method and releases the resources used by it.
In particular, the input method should dispose windows and close files that are no
longer needed.

 This method is called by InputContext.dispose. 

The method is only called when the input method is inactive.
No method of this interface is called on this instance after dispose.

/**
     * Disposes of the input method and releases the resources used by it.
     * In particular, the input method should dispose windows and close files that are no
     * longer needed.
     * <p>
     * This method is called by {@link java.awt.im.InputContext#dispose InputContext.dispose}.
     * <p>
     * The method is only called when the input method is inactive.
     * No method of this interface is called on this instance after dispose.
     */
    public void dispose() {
    }

    
Returns a control object from this input method, or null. A
control object provides methods that control the behavior of the
input method or obtain information from the input method. The type
of the object is an input method specific class. Clients have to
compare the result against known input method control object
classes and cast to the appropriate class to invoke the methods
provided.

 This method is called by InputContext.getInputMethodControlObject. 
Returns:a control object from this input method, or null
/**
     * Returns a control object from this input method, or null. A
     * control object provides methods that control the behavior of the
     * input method or obtain information from the input method. The type
     * of the object is an input method specific class. Clients have to
     * compare the result against known input method control object
     * classes and cast to the appropriate class to invoke the methods
     * provided.
     * <p>
     * This method is called by
     * {@link java.awt.im.InputContext#getInputMethodControlObject InputContext.getInputMethodControlObject}.
     *
     * @return a control object from this input method, or null
     */
    public Object getControlObject() {

        return null;
    }
}