/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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.
*/
/**
* Input Method Adapter for XIM
*
* @author JavaSoft International
*/
/*
* The following XIM* values must be the same as those defined in
* Xlib.h
*/
/*
* visible position values
*/
private static boolean isXIMOpened = false;
private boolean isLastXICActive = false;
private boolean isLastTemporary = false;
private boolean isActive = false;
private boolean isActiveClient = false;
private boolean disposed = false;
//reset the XIC if necessary
private boolean needResetXIC = false;
// 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.
private boolean compositionEnableSupported = true;
// 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.
private boolean savedCompositionState = false;
// variables to keep track of preedit context.
// private data (X11InputMethodData structure defined in
// awt_InputMethod.c) for native methods
// Initialize highlight mapping table
static {
// UNSELECTED_RAW_TEXT_HIGHLIGHT
// SELECTED_RAW_TEXT_HIGHLIGHT
// UNSELECTED_CONVERTED_TEXT_HIGHLIGHT
// SELECTED_CONVERTED_TEXT_HIGHLIGHT
}
static {
initIDs();
}
/**
* Initialize JNI field and method IDs for fields that may be
accessed from C.
*/
private static native void 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
if (initXIM() == false) {
throw new AWTException("Cannot open X Input Method");
}
}
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;
}
/**
* Does nothing - this adapter doesn't use the input method context.
*
* @see java.awt.im.spi.InputMethod#setInputMethodContext
*/
}
/**
* 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.
*/
return true;
}
// special compatibility rule for Japanese and Korean
return true;
}
return false;
}
/**
* Returns current input locale.
*/
return locale;
}
/**
* Does nothing - XIM doesn't let you specify which characters you expect.
*
* @see java.awt.im.spi.InputMethod#setCharacterSubsets
*/
}
/**
* 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
*/
}
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() &&
resetXIC();
// needs to reset the last xic focussed component.
isLastXICActive = false;
needResetXIC = false;
}
}
/**
* Reset the composition state to the current composition state.
*/
private void resetCompositionState() {
if (compositionEnableSupported) {
try {
/* Restore the composition mode to the last saved composition
mode. */
} catch (UnsupportedOperationException e) {
compositionEnableSupported = false;
}
}
}
/**
* Query and then return the current composition state.
* @returns the composition state if isCompositionEnabled call
* is successful. Otherwise, it returns false.
*/
private boolean getCompositionState() {
boolean compositionState = false;
if (compositionEnableSupported) {
try {
} catch (UnsupportedOperationException e) {
compositionEnableSupported = false;
}
}
return compositionState;
}
/**
* Activate input method.
*/
public synchronized void activate() {
if (clientComponentWindow == null)
return;
if (lastXICFocussedComponent != null){
}
if (pData == 0) {
if (!createXIC()) {
return;
}
disposed = false;
}
/* reset input context if necessary and set the XIC focus
*/
if (lastXICFocussedComponent != null) {
}
/* If the last XIC focussed component has a different peer as the
current focussed component, change the XIC focus to the newly
focussed component.
*/
isLastXICActive != haveActiveClient()) {
if (lastXICFocussedComponentPeer != null) {
}
if (awtFocussedComponentPeer != null) {
}
}
isActive = true;
}
protected abstract boolean createXIC();
/**
* Deactivate input method.
*/
boolean isAc = haveActiveClient();
/* Usually as the client component, let's call it component A,
loses the focus, this method is called. Then when another client
component, let's call it component B, gets the focus, activate is first called on
the previous focused compoent which is A, then endComposition is called on A,
deactivate is called on A again. And finally activate is called on the newly
focused component B. Here is the call sequence.
A loses focus B gains focus
-------------> deactivate A -------------> activate A -> endComposition A ->
deactivate A -> activate B ----....
So in order to carry the composition mode across the components sharing the same
input context, we save it when deactivate is called so that when activate is
called, it can be restored correctly till activate is called on the newly focused
component. (See also sun/awt/im/InputContext and bug 6184471).
Last note, getCompositionState should be called before setXICFocus since
setXICFocus here sets the XIC to 0.
*/
if (isTemporary){
//turn the status window off...
}
/* Delay resetting the XIC focus until activate is called and the newly
focussed component has a different peer as the last focussed component.
*/
isActive = false;
}
/**
* Explicitly disable the native IME. Native IME is not disabled when
* deactivate is called.
*/
public void disableInputMethod() {
if (lastXICFocussedComponent != null) {
isLastXICActive = false;
resetXIC();
needResetXIC = false;
}
}
// implements java.awt.im.spi.InputMethod.hideWindows
public void hideWindows() {
// ??? need real implementation
}
/**
* @see java.awt.Toolkit#mapInputMethodHighlight
*/
int index;
index = 0;
index = 2;
} else {
return null;
}
if (highlight.isSelected()) {
index += 1;
}
return highlightStyles[index];
}
/**
* @see sun.awt.im.InputMethodAdapter#setAWTFocussedComponent
*/
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();
}
}
/**
* @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.
// disable the native input method so that the other input
// method could get the input focus.
if (needResetXIC) {
resetXIC();
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!
} else {
}
}
}
/**
* 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.
*/
/**
* 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
*/
long when) {
}
}
}
/**
* 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 long 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!
return;
if (composedText == null) {
null,
null,
when);
} else {
// if there is composed text, wait until the preedit
// callback is invoked.
committedText = str;
}
}
}
/**
* 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,
long when) {
if (disposed) {
return;
}
//Workaround for deadlock bug on solaris2.6_zh bug#4170760
&& chgOffset == 0
&& chgLength == 0
&& caretPosition == 0
&& composedText == null
&& committedText == null)
return;
if (composedText == null) {
// TODO: avoid reallocation of those buffers
}
if (chgLength > 0) {
} else {
// optimization for the special case to replace the
// entire previous text
} else {
composedText.length());
} else {
// in case to remove substring from chgOffset
// to the end
}
}
}
}
}
}
composedText = null;
rawFeedbacks = null;
// if there is any outstanding committed text stored by
// dispatchCommittedText(), it has to be sent to the
// client component.
if (committedText != null) {
return;
}
// otherwise, send null text to delete client's composed
// text.
null,
0,
null,
null,
when);
return;
}
// Now sending the composed text to the client
int composedOffset;
// if there is any partially committed text, concatenate it to
// the composed text.
if (committedText != null) {
} else {
composedOffset = 0;
}
int currentFeedback;
int nextFeedback;
int startOffset = 0;
int currentOffset;
int visiblePosition = 0;
if (visiblePosition == 0) {
if (visiblePosition != 0) {
if (visiblePosition == XIMVisibleToBackward)
else
}
}
if (currentFeedback != nextFeedback) {
}
}
if (currentOffset >= 0) {
}
when);
}
/**
* 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() {
if (composedText != null) {
}
null,
null,
composedText = null;
}
}
/*
* Subclasses should override disposeImpl() instead of dispose(). Client
* code should always invoke dispose(), never disposeImpl().
*/
protected synchronized void disposeImpl() {
disposeXIC();
awtLock();
composedText = null;
rawFeedbacks = null;
awtUnlock();
}
/**
* Frees all X Window resources associated with this object.
*
* @see java.awt.im.spi.InputMethod#dispose
*/
public final void dispose() {
boolean call_disposeImpl = false;
if (!disposed) {
synchronized (this) {
if (!disposed) {
disposed = call_disposeImpl = true;
}
}
}
if (call_disposeImpl) {
disposeImpl();
}
}
/**
* Returns null.
*
* @see java.awt.im.spi.InputMethod#getControlObject
*/
return null;
}
/**
* @see java.awt.im.spi.InputMethod#removeNotify
*/
public synchronized void removeNotify() {
dispose();
}
/**
* @see java.awt.im.spi.InputMethod#setCompositionEnabled(boolean)
*/
/* If the composition state is successfully changed, set
the savedCompositionState to 'enable'. Otherwise, simply
return.
setCompositionEnabledNative may throw UnsupportedOperationException.
Don't try to catch it since the method may be called by clients.
Use package private mthod 'resetCompositionState' if you want the
exception to be caught.
*/
if (setCompositionEnabledNative(enable)) {
}
}
/**
* @see java.awt.im.spi.InputMethod#isCompositionEnabled
*/
public boolean isCompositionEnabled() {
/* isCompositionEnabledNative may throw UnsupportedOperationException.
Don't try to catch it since this method may be called by clients.
Use package private method 'getCompositionState' if you want the
exception to be caught.
*/
return isCompositionEnabledNative();
}
/**
* 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.
*
*/
public void endComposition() {
if (disposed) {
return;
}
/* Before calling resetXIC, record the current composition mode
so that it can be restored later. */
boolean active = haveActiveClient();
needResetXIC = true;
return;
}
/* needResetXIC is only set to true for active client. So passive
client should not reset the flag to false. */
if (active) {
needResetXIC = false;
}
// Remove any existing composed text by posting an InputMethodEvent
// with null composed text. It would be desirable to wait for a
// dispatchComposedText call from X input method engine, but some
// input method does not conform to the XIM specification and does
// not call the preedit callback to erase preedit text on calling
// XmbResetIC. To work around this problem, do it here by ourselves.
awtLock();
composedText = null;
null,
0,
null,
null);
}
awtUnlock();
// Restore the preedit state if it was enabled
if (savedCompositionState) {
}
}
/**
* Returns a string with information about the current input method server, or null.
* On both Linux & SunOS, the value of environment variable XMODIFIERS is
* returned if set. Otherwise, on SunOS, $HOME/.dtprofile will be parsed
* to find out the language service engine (atok or wnn) since there is
* no API in Xlib which returns the information of native
* IM server or language service and we want to try our best to return as much
* information as possible.
*
* Note: This method could return null on Linux if XMODIFIERS is not set properly or
* if any IOException is thrown.
* See man page of XSetLocaleModifiers(3X11) for the usgae of XMODIFIERS,
* atok12setup(1) and wnn6setup(1) for the information written to
* $HOME/.dtprofile when you run these two commands.
*
*/
// If XMODIFIERS is set, return the value
if (xmodifiers != null) {
if (imIndex != -1) {
}
"/.dtprofile");
try {
while (tokens.hasMoreTokens()) {
break;
}
}
}
}
} catch(IOException ioex) {
// Since this method is provided for internal testing only,
// we dump the stack trace for the ease of debugging.
}
}
return imInfo;
}
/**
* Performs mapping from an XIM visible feedback value to Java IM highlight.
* @return Java input method highlight
*/
switch (feedback) {
case XIMUnderline:
break;
case XIMReverse:
break;
case XIMHighlight:
break;
case XIMPrimary:
break;
case XIMSecondary:
break;
case XIMTertiary:
break;
default:
break;
}
return highlight;
}
// initial capacity size for string buffer, etc.
/**
* IntBuffer is an inner class that manipulates an int array and
* provides UNIX file io stream-like programming interfaces to
* access it. (An alternative would be to use ArrayList which may
* be too expensive for the work.)
*/
private final class IntBuffer {
private int[] intArray;
private int size;
private int index;
intArray = new int[initialCapacity];
size = 0;
index = 0;
}
}
}
}
}
void removeAll() {
size = 0;
index = 0;
}
void rewind() {
index = 0;
}
int getNext() {
return -1;
}
void unget() {
if (index != 0)
index--;
}
int getOffset() {
return index;
}
StringBuffer s = new StringBuffer();
for (int i = 0; i < size;) {
if (i < size)
s.append(",");
}
return s.toString();
}
}
/*
* Native methods
*/
private native void disposeXIC();
private native boolean isCompositionEnabledNative();
private native void turnoffStatusWindow();
}