rev 50172 : 8201429: Support AIX Input Method Editor (IME) for AWT Input Method Framework (IMF)

   1 /*
   2  * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.awt;
  27 
  28 import java.util.Collections;
  29 import java.util.Locale;
  30 import java.util.Map;
  31 import java.util.HashMap;
  32 import java.awt.AWTEvent;
  33 import java.awt.AWTException;
  34 import java.awt.Component;
  35 import java.awt.Container;
  36 import java.awt.EventQueue;
  37 import java.awt.Window;
  38 import java.awt.im.InputMethodHighlight;
  39 import java.awt.im.spi.InputMethodContext;
  40 import sun.awt.im.InputMethodAdapter;
  41 import java.awt.event.InputMethodEvent;
  42 import java.awt.font.TextAttribute;
  43 import java.awt.font.TextHitInfo;


  44 import java.awt.peer.ComponentPeer;
  45 import java.lang.Character.Subset;
  46 import java.text.AttributedString;
  47 import java.text.AttributedCharacterIterator;
  48 
  49 import java.io.File;
  50 import java.io.FileReader;
  51 import java.io.BufferedReader;
  52 import java.io.IOException;

  53 import java.lang.ref.WeakReference;
  54 import sun.util.logging.PlatformLogger;





  55 import java.util.StringTokenizer;
  56 import java.util.regex.Pattern;
  57 


  58 
  59 /**
  60  * Input Method Adapter for XIM
  61  *
  62  * @author JavaSoft International
  63  */
  64 public abstract class X11InputMethod extends InputMethodAdapter {
  65     private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11InputMethod");
  66     /*
  67      * The following XIM* values must be the same as those defined in
  68      * Xlib.h
  69      */
  70     private static final int XIMReverse = (1<<0);
  71     private static final int XIMUnderline = (1<<1);
  72     private static final int XIMHighlight = (1<<2);
  73     private static final int XIMPrimary = (1<<5);
  74     private static final int XIMSecondary = (1<<6);
  75     private static final int XIMTertiary = (1<<7);
  76 
  77     /*
  78      * visible position values
  79      */
  80     private static final int XIMVisibleToForward = (1<<8);
  81     private static final int XIMVisibleToBackward = (1<<9);
  82     private static final int XIMVisibleCenter = (1<<10);
  83     private static final int XIMVisibleMask = (XIMVisibleToForward|
  84                                                XIMVisibleToBackward|
  85                                                XIMVisibleCenter);
  86 
  87     private Locale locale;
  88     private static boolean isXIMOpened = false;
  89     protected Container clientComponentWindow = null;
  90     private Component awtFocussedComponent = null;
  91     private Component lastXICFocussedComponent = null;
  92     private boolean   isLastXICActive = false;
  93     private boolean   isLastTemporary = false;
  94     private boolean   isActive = false;
  95     private boolean   isActiveClient = false;
  96     private static Map<TextAttribute, ?>[] highlightStyles;
  97     private boolean disposed = false;
  98 
  99     //reset the XIC if necessary
 100     private boolean   needResetXIC = false;
 101     private WeakReference<Component> needResetXICClient = new WeakReference<>(null);
 102 
 103     // The use of compositionEnableSupported is to reduce unnecessary
 104     // native calls if set/isCompositionEnabled
 105     // throws UnsupportedOperationException.
 106     // It is set to false if that exception is thrown first time
 107     // either of the two methods are called.
 108     private boolean compositionEnableSupported = true;
 109     // The savedCompositionState indicates the composition mode when
 110     // endComposition or setCompositionEnabled is called. It doesn't always
 111     // reflect the actual composition state because it doesn't get updated
 112     // when the user changes the composition state through direct interaction
 113     // with the input method. It is used to save the composition mode when
 114     // focus is traversed across different client components sharing the
 115     // same java input context. Also if set/isCompositionEnabled are not
 116     // supported, it remains false.
 117     private boolean savedCompositionState = false;
 118 
 119     // variables to keep track of preedit context.
 120     // these variables need to be accessed within AWT_LOCK/UNLOCK
 121     private String committedText = null;
 122     private StringBuffer composedText = null;
 123     private IntBuffer rawFeedbacks;
 124 
 125     // private data (X11InputMethodData structure defined in
 126     // awt_InputMethod.c) for native methods
 127     // this structure needs to be accessed within AWT_LOCK/UNLOCK
 128     private transient long pData = 0; // accessed by native
 129 
 130     // Initialize highlight mapping table
 131     static {
 132         @SuppressWarnings({"unchecked", "rawtypes"})
 133         Map<TextAttribute, ?> styles[] = new Map[4];
 134         HashMap<TextAttribute, Object> map;
 135 
 136         // UNSELECTED_RAW_TEXT_HIGHLIGHT
 137         map = new HashMap<>(1);
 138         map.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
 139         styles[0] = Collections.unmodifiableMap(map);
 140 
 141         // SELECTED_RAW_TEXT_HIGHLIGHT
 142         map = new HashMap<>(1);
 143         map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);
 144         styles[1] = Collections.unmodifiableMap(map);
 145 
 146         // UNSELECTED_CONVERTED_TEXT_HIGHLIGHT
 147         map = new HashMap<>(1);
 148         map.put(TextAttribute.INPUT_METHOD_UNDERLINE,
 149                 TextAttribute.UNDERLINE_LOW_ONE_PIXEL);
 150         styles[2] = Collections.unmodifiableMap(map);
 151 
 152         // SELECTED_CONVERTED_TEXT_HIGHLIGHT
 153         map = new HashMap<>(1);
 154         map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);
 155         styles[3] = Collections.unmodifiableMap(map);
 156 
 157         highlightStyles = styles;
 158     }
 159 
 160     static {
 161         initIDs();
 162     }
 163 
 164     /**
 165      * Initialize JNI field and method IDs for fields that may be
 166        accessed from C.
 167      */
 168     private static native void initIDs();
 169 
 170     /**
 171      * Constructs an X11InputMethod instance. It initializes the XIM
 172      * environment if it's not done yet.
 173      *
 174      * @exception AWTException if XOpenIM() failed.
 175      */
 176     public X11InputMethod() throws AWTException {
 177         // supports only the locale in which the VM is started
 178         locale = X11InputMethodDescriptor.getSupportedLocale();
 179         if (initXIM() == false) {
 180             throw new AWTException("Cannot open X Input Method");
 181         }
 182     }
 183 
 184     @SuppressWarnings("deprecation")
 185     protected void finalize() throws Throwable {
 186         dispose();
 187         super.finalize();
 188     }
 189 
 190     /**
 191      * Invokes openIM() that invokes XOpenIM() if it's not opened yet.
 192      * @return  true if openXIM() is successful or it's already been opened.
 193      */
 194     private synchronized boolean initXIM() {
 195         if (isXIMOpened == false)
 196             isXIMOpened = openXIM();
 197         return isXIMOpened;
 198     }
 199 
 200     protected abstract boolean openXIM();
 201 
 202     protected boolean isDisposed() {
 203         return disposed;
 204     }
 205 
 206     protected abstract void setXICFocus(ComponentPeer peer,
 207                                     boolean value, boolean active);
 208 
 209     /**
 210      * Does nothing - this adapter doesn't use the input method context.
 211      *
 212      * @see java.awt.im.spi.InputMethod#setInputMethodContext
 213      */
 214     public void setInputMethodContext(InputMethodContext context) {
 215     }
 216 
 217     /**
 218      * Set locale to input. If input method doesn't support specified locale,
 219      * false will be returned and its behavior is not changed.
 220      *
 221      * @param lang locale to input
 222      * @return the true is returned when specified locale is supported.
 223      */
 224     public boolean setLocale(Locale lang) {
 225         if (lang.equals(locale)) {
 226             return true;
 227         }
 228         // special compatibility rule for Japanese and Korean
 229         if (locale.equals(Locale.JAPAN) && lang.equals(Locale.JAPANESE) ||
 230                 locale.equals(Locale.KOREA) && lang.equals(Locale.KOREAN)) {
 231             return true;
 232         }
 233         return false;
 234     }
 235 
 236     /**
 237      * Returns current input locale.
 238      */
 239     public Locale getLocale() {
 240         return locale;
 241     }
 242 
 243     /**
 244      * Does nothing - XIM doesn't let you specify which characters you expect.
 245      *
 246      * @see java.awt.im.spi.InputMethod#setCharacterSubsets
 247      */
 248     public void setCharacterSubsets(Subset[] subsets) {
 249     }
 250 
 251     /**
 252      * Dispatch event to input method. InputContext dispatch event with this
 253      * method. Input method set consume flag if event is consumed in
 254      * input method.
 255      *
 256      * @param e event
 257      */
 258     public void dispatchEvent(AWTEvent e) {
 259     }
 260 
 261 
 262     protected final void resetXICifneeded(){
 263         /* needResetXIC is used to indicate whether to call
 264            resetXIC on the active client. resetXIC will always be
 265            called on the passive client when endComposition is called.
 266         */
 267         if (needResetXIC && haveActiveClient() &&
 268             getClientComponent() != needResetXICClient.get()){
 269             resetXIC();
 270 
 271             // needs to reset the last xic focussed component.
 272             lastXICFocussedComponent = null;
 273             isLastXICActive = false;
 274 
 275             needResetXICClient.clear();
 276             needResetXIC = false;
 277         }
 278     }
 279 
 280     /**
 281      * Reset the composition state to the current composition state.
 282      */
 283     private void resetCompositionState() {
 284         if (compositionEnableSupported) {
 285             try {
 286                 /* Restore the composition mode to the last saved composition
 287                    mode. */
 288                 setCompositionEnabled(savedCompositionState);
 289             } catch (UnsupportedOperationException e) {
 290                 compositionEnableSupported = false;
 291             }
 292         }
 293     }
 294 
 295     /**
 296      * Query and then return the current composition state.
 297      * @return the composition state if isCompositionEnabled call
 298      * is successful. Otherwise, it returns false.
 299      */
 300     private boolean getCompositionState() {
 301         boolean compositionState = false;
 302         if (compositionEnableSupported) {
 303             try {
 304                 compositionState = isCompositionEnabled();
 305             } catch (UnsupportedOperationException e) {
 306                 compositionEnableSupported = false;
 307             }
 308         }
 309         return compositionState;
 310     }
 311 
 312     /**
 313      * Activate input method.
 314      */
 315     public synchronized void activate() {
 316         clientComponentWindow = getClientComponentWindow();
 317         if (clientComponentWindow == null)
 318             return;
 319 
 320         if (lastXICFocussedComponent != null){
 321             if (log.isLoggable(PlatformLogger.Level.FINE)) {
 322                 log.fine("XICFocused {0}, AWTFocused {1}",
 323                          lastXICFocussedComponent, awtFocussedComponent);
 324             }
 325         }
 326 
 327         if (pData == 0) {
 328             if (!createXIC()) {
 329                 return;
 330             }
 331             disposed = false;
 332         }
 333 
 334         /*  reset input context if necessary and set the XIC focus
 335         */
 336         resetXICifneeded();
 337         ComponentPeer lastXICFocussedComponentPeer = null;
 338         ComponentPeer awtFocussedComponentPeer = getPeer(awtFocussedComponent);
 339 
 340         if (lastXICFocussedComponent != null) {
 341            lastXICFocussedComponentPeer = getPeer(lastXICFocussedComponent);
 342         }
 343 
 344         /* If the last XIC focussed component has a different peer as the
 345            current focussed component, change the XIC focus to the newly
 346            focussed component.
 347         */
 348         if (isLastTemporary || lastXICFocussedComponentPeer != awtFocussedComponentPeer ||
 349             isLastXICActive != haveActiveClient()) {
 350             if (lastXICFocussedComponentPeer != null) {
 351                 setXICFocus(lastXICFocussedComponentPeer, false, isLastXICActive);
 352             }
 353             if (awtFocussedComponentPeer != null) {
 354                 setXICFocus(awtFocussedComponentPeer, true, haveActiveClient());
 355             }
 356             lastXICFocussedComponent = awtFocussedComponent;
 357             isLastXICActive = haveActiveClient();
 358         }
 359         resetCompositionState();
 360         isActive = true;
 361     }
 362 
 363     protected abstract boolean createXIC();
 364 
 365     /**
 366      * Deactivate input method.
 367      */
 368     public synchronized void deactivate(boolean isTemporary) {
 369         boolean   isAc =  haveActiveClient();
 370         /* Usually as the client component, let's call it component A,
 371            loses the focus, this method is called. Then when another client
 372            component, let's call it component B,  gets the focus, activate is first called on
 373            the previous focused compoent which is A, then endComposition is called on A,
 374            deactivate is called on A again. And finally activate is called on the newly
 375            focused component B. Here is the call sequence.
 376 
 377            A loses focus               B gains focus
 378            -------------> deactivate A -------------> activate A -> endComposition A ->
 379            deactivate A -> activate B ----....
 380 
 381            So in order to carry the composition mode across the components sharing the same
 382            input context, we save it when deactivate is called so that when activate is
 383            called, it can be restored correctly till activate is called on the newly focused
 384            component. (See also sun/awt/im/InputContext and bug 6184471).
 385            Last note, getCompositionState should be called before setXICFocus since
 386            setXICFocus here sets the XIC to 0.
 387         */
 388         savedCompositionState = getCompositionState();
 389 
 390         if (isTemporary){
 391             //turn the status window off...
 392             turnoffStatusWindow();
 393         }
 394 
 395         /* Delay resetting the XIC focus until activate is called and the newly
 396            focussed component has a different peer as the last focussed component.
 397         */
 398         lastXICFocussedComponent = awtFocussedComponent;
 399         isLastXICActive = isAc;
 400         isLastTemporary = isTemporary;
 401         isActive = false;
 402     }
 403 
 404     /**
 405      * Explicitly disable the native IME. Native IME is not disabled when
 406      * deactivate is called.
 407      */
 408     public void disableInputMethod() {
 409         if (lastXICFocussedComponent != null) {
 410             setXICFocus(getPeer(lastXICFocussedComponent), false, isLastXICActive);
 411             lastXICFocussedComponent = null;
 412             isLastXICActive = false;
 413 
 414             resetXIC();
 415             needResetXICClient.clear();
 416             needResetXIC = false;
 417         }
 418     }
 419 
 420     // implements java.awt.im.spi.InputMethod.hideWindows
 421     public void hideWindows() {
 422         // ??? need real implementation
 423     }
 424 
 425     /**
 426      * @see java.awt.Toolkit#mapInputMethodHighlight
 427      */
 428     public static Map<TextAttribute, ?> mapInputMethodHighlight(InputMethodHighlight highlight) {
 429         int index;
 430         int state = highlight.getState();
 431         if (state == InputMethodHighlight.RAW_TEXT) {
 432             index = 0;
 433         } else if (state == InputMethodHighlight.CONVERTED_TEXT) {
 434             index = 2;
 435         } else {
 436             return null;
 437         }
 438         if (highlight.isSelected()) {
 439             index += 1;
 440         }
 441         return highlightStyles[index];
 442     }
 443 
 444     /**
 445      * @see sun.awt.im.InputMethodAdapter#setAWTFocussedComponent
 446      */
 447     protected void setAWTFocussedComponent(Component component) {
 448         if (component == null) {
 449             return;
 450         }
 451         if (isActive) {
 452             // deactivate/activate are being suppressed during a focus change -
 453             // this may happen when an input method window is made visible
 454             boolean ac = haveActiveClient();
 455             setXICFocus(getPeer(awtFocussedComponent), false, ac);
 456             setXICFocus(getPeer(component), true, ac);
 457         }
 458         awtFocussedComponent = component;
 459     }
 460 
 461     /**
 462      * @see sun.awt.im.InputMethodAdapter#stopListening
 463      */
 464     protected void stopListening() {
 465         // It is desirable to disable XIM by calling XSetICValues with
 466         // XNPreeditState == XIMPreeditDisable.  But Solaris 2.6 and
 467         // Solaris 7 do not implement this correctly without a patch,
 468         // so just call resetXIC here.  Prior endComposition call commits
 469         // the existing composed text.
 470         endComposition();
 471         // disable the native input method so that the other input
 472         // method could get the input focus.
 473         disableInputMethod();
 474         if (needResetXIC) {
 475             resetXIC();
 476             needResetXICClient.clear();
 477             needResetXIC = false;
 478         }
 479     }
 480 
 481     /**
 482      * Returns the Window instance in which the client component is
 483      * contained. If not found, null is returned. (IS THIS POSSIBLE?)
 484      */
 485     // NOTE: This method may be called by privileged threads.
 486     //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
 487     private Window getClientComponentWindow() {
 488         Component client = getClientComponent();
 489         Container container;
 490 
 491         if (client instanceof Container) {
 492             container = (Container) client;
 493         } else {
 494             container = getParent(client);
 495         }
 496 
 497         while (container != null && !(container instanceof java.awt.Window)) {
 498             container = getParent(container);
 499         }
 500         return (Window) container;
 501     }
 502 
 503     protected abstract Container getParent(Component client);
 504 
 505     /**
 506      * Returns peer of the given client component. If the given client component
 507      * doesn't have peer, peer of the native container of the client is returned.
 508      */
 509     protected abstract ComponentPeer getPeer(Component client);
 510 
 511     /**
 512      * Used to protect preedit data
 513      */
 514     protected abstract void awtLock();
 515     protected abstract void awtUnlock();
 516 
 517     /**
 518      * Creates an input method event from the arguments given
 519      * and posts it on the AWT event queue. For arguments,
 520      * see InputMethodEvent. Called by input method.
 521      *
 522      * @see java.awt.event.InputMethodEvent#InputMethodEvent
 523      */
 524     private void postInputMethodEvent(int id,
 525                                       AttributedCharacterIterator text,
 526                                       int committedCharacterCount,
 527                                       TextHitInfo caret,
 528                                       TextHitInfo visiblePosition,
 529                                       long when) {
 530         Component source = getClientComponent();
 531         if (source != null) {
 532             InputMethodEvent event = new InputMethodEvent(source,
 533                 id, when, text, committedCharacterCount, caret, visiblePosition);
 534             SunToolkit.postEvent(SunToolkit.targetToAppContext(source), (AWTEvent)event);
 535         }
 536     }
 537 
 538     private void postInputMethodEvent(int id,
 539                                       AttributedCharacterIterator text,
 540                                       int committedCharacterCount,
 541                                       TextHitInfo caret,
 542                                       TextHitInfo visiblePosition) {
 543         postInputMethodEvent(id, text, committedCharacterCount,
 544                              caret, visiblePosition, EventQueue.getMostRecentEventTime());
 545     }
 546 
 547     /**
 548      * Dispatches committed text from XIM to the awt event queue. This
 549      * method is invoked from the event handler in canvas.c in the
 550      * AWT Toolkit thread context and thus inside the AWT Lock.
 551      * @param   str     committed text
 552      * @param   when    when
 553      */
 554     // NOTE: This method may be called by privileged threads.
 555     //       This functionality is implemented in a package-private method
 556     //       to insure that it cannot be overridden by client subclasses.
 557     //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
 558     void dispatchCommittedText(String str, long when) {
 559         if (str == null)
 560             return;
 561 
 562         if (composedText == null) {
 563             AttributedString attrstr = new AttributedString(str);
 564             postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
 565                                  attrstr.getIterator(),
 566                                  str.length(),
 567                                  null,
 568                                  null,
 569                                  when);
 570         } else {
 571             // if there is composed text, wait until the preedit
 572             // callback is invoked.
 573             committedText = str;
 574         }
 575     }
 576 
 577     private void dispatchCommittedText(String str) {
 578         dispatchCommittedText(str, EventQueue.getMostRecentEventTime());
 579     }
 580 
 581     /**
 582      * Updates composed text with XIM preedit information and
 583      * posts composed text to the awt event queue. The args of
 584      * this method correspond to the XIM preedit callback
 585      * information. The XIM highlight attributes are translated via
 586      * fixed mapping (i.e., independent from any underlying input
 587      * method engine). This method is invoked in the AWT Toolkit
 588      * (X event loop) thread context and thus inside the AWT Lock.
 589      */
 590     // NOTE: This method may be called by privileged threads.
 591     //       This functionality is implemented in a package-private method
 592     //       to insure that it cannot be overridden by client subclasses.
 593     //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
 594     void dispatchComposedText(String chgText,
 595                                            int chgStyles[],
 596                                            int chgOffset,
 597                                            int chgLength,
 598                                            int caretPosition,
 599                                            long when) {
 600         if (disposed) {
 601             return;
 602         }
 603 
 604         //Workaround for deadlock bug on solaris2.6_zh bug#4170760
 605         if (chgText == null
 606             && chgStyles == null
 607             && chgOffset == 0
 608             && chgLength == 0
 609             && caretPosition == 0
 610             && composedText == null
 611             && committedText == null)
 612             return;
 613 
 614         if (composedText == null) {
 615             // TODO: avoid reallocation of those buffers
 616             composedText = new StringBuffer(INITIAL_SIZE);
 617             rawFeedbacks = new IntBuffer(INITIAL_SIZE);
 618         }
 619         if (chgLength > 0) {
 620             if (chgText == null && chgStyles != null) {
 621                 rawFeedbacks.replace(chgOffset, chgStyles);
 622             } else {
 623                 if (chgLength == composedText.length()) {
 624                     // optimization for the special case to replace the
 625                     // entire previous text
 626                     composedText = new StringBuffer(INITIAL_SIZE);
 627                     rawFeedbacks = new IntBuffer(INITIAL_SIZE);
 628                 } else {
 629                     if (composedText.length() > 0) {
 630                         if (chgOffset+chgLength < composedText.length()) {
 631                             String text;
 632                             text = composedText.toString().substring(chgOffset+chgLength,
 633                                                                      composedText.length());
 634                             composedText.setLength(chgOffset);
 635                             composedText.append(text);
 636                         } else {
 637                             // in case to remove substring from chgOffset
 638                             // to the end
 639                             composedText.setLength(chgOffset);
 640                         }
 641                         rawFeedbacks.remove(chgOffset, chgLength);
 642                     }
 643                 }
 644             }
 645         }
 646         if (chgText != null) {
 647             composedText.insert(chgOffset, chgText);
 648             if (chgStyles != null)
 649                 rawFeedbacks.insert(chgOffset, chgStyles);
 650         }
 651 
 652         if (composedText.length() == 0) {
 653             composedText = null;
 654             rawFeedbacks = null;
 655 
 656             // if there is any outstanding committed text stored by
 657             // dispatchCommittedText(), it has to be sent to the
 658             // client component.
 659             if (committedText != null) {
 660                 dispatchCommittedText(committedText, when);
 661                 committedText = null;
 662                 return;
 663             }
 664 
 665             // otherwise, send null text to delete client's composed
 666             // text.
 667             postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
 668                                  null,
 669                                  0,
 670                                  null,
 671                                  null,
 672                                  when);
 673 
 674             return;
 675         }
 676 
 677         // Now sending the composed text to the client
 678         int composedOffset;
 679         AttributedString inputText;
 680 
 681         // if there is any partially committed text, concatenate it to
 682         // the composed text.
 683         if (committedText != null) {
 684             composedOffset = committedText.length();
 685             inputText = new AttributedString(committedText + composedText);
 686             committedText = null;
 687         } else {
 688             composedOffset = 0;
 689             inputText = new AttributedString(composedText.toString());
 690         }
 691 
 692         int currentFeedback;
 693         int nextFeedback;
 694         int startOffset = 0;
 695         int currentOffset;
 696         int visiblePosition = 0;
 697         TextHitInfo visiblePositionInfo = null;
 698 
 699         rawFeedbacks.rewind();
 700         currentFeedback = rawFeedbacks.getNext();
 701         rawFeedbacks.unget();
 702         while ((nextFeedback = rawFeedbacks.getNext()) != -1) {
 703             if (visiblePosition == 0) {
 704                 visiblePosition = nextFeedback & XIMVisibleMask;
 705                 if (visiblePosition != 0) {
 706                     int index = rawFeedbacks.getOffset() - 1;
 707 
 708                     if (visiblePosition == XIMVisibleToBackward)
 709                         visiblePositionInfo = TextHitInfo.leading(index);
 710                     else
 711                         visiblePositionInfo = TextHitInfo.trailing(index);
 712                 }
 713             }
 714             nextFeedback &= ~XIMVisibleMask;
 715             if (currentFeedback != nextFeedback) {
 716                 rawFeedbacks.unget();
 717                 currentOffset = rawFeedbacks.getOffset();
 718                 inputText.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
 719                                        convertVisualFeedbackToHighlight(currentFeedback),
 720                                        composedOffset + startOffset,
 721                                        composedOffset + currentOffset);
 722                 startOffset = currentOffset;
 723                 currentFeedback = nextFeedback;
 724             }
 725         }
 726         currentOffset = rawFeedbacks.getOffset();
 727         if (currentOffset >= 0) {
 728             inputText.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
 729                                    convertVisualFeedbackToHighlight(currentFeedback),
 730                                    composedOffset + startOffset,
 731                                    composedOffset + currentOffset);
 732         }
 733 
 734         postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
 735                              inputText.getIterator(),
 736                              composedOffset,
 737                              TextHitInfo.leading(caretPosition),
 738                              visiblePositionInfo,
 739                              when);
 740     }
 741 
 742     /**
 743      * Flushes composed and committed text held in this context.
 744      * This method is invoked in the AWT Toolkit (X event loop) thread context
 745      * and thus inside the AWT Lock.
 746      */
 747     // NOTE: This method may be called by privileged threads.
 748     //       This functionality is implemented in a package-private method
 749     //       to insure that it cannot be overridden by client subclasses.
 750     //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
 751     void flushText() {
 752         String flush = (committedText != null ? committedText : "");
 753         if (composedText != null) {
 754             flush += composedText.toString();
 755         }
 756 
 757         if (!flush.equals("")) {
 758             AttributedString attrstr = new AttributedString(flush);
 759             postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
 760                                  attrstr.getIterator(),
 761                                  flush.length(),
 762                                  null,
 763                                  null,
 764                                  EventQueue.getMostRecentEventTime());
 765             composedText = null;
 766             committedText = null;
 767         }
 768     }
 769 
 770     /*
 771      * Subclasses should override disposeImpl() instead of dispose(). Client
 772      * code should always invoke dispose(), never disposeImpl().
 773      */
 774     protected synchronized void disposeImpl() {
 775         disposeXIC();
 776         awtLock();
 777         composedText = null;
 778         committedText = null;
 779         rawFeedbacks = null;
 780         awtUnlock();
 781         awtFocussedComponent = null;
 782         lastXICFocussedComponent = null;
 783     }
 784 
 785     /**
 786      * Frees all X Window resources associated with this object.
 787      *
 788      * @see java.awt.im.spi.InputMethod#dispose
 789      */
 790     public final void dispose() {
 791         boolean call_disposeImpl = false;
 792 
 793         if (!disposed) {
 794             synchronized (this) {
 795                 if (!disposed) {
 796                     disposed = call_disposeImpl = true;
 797                 }
 798             }
 799         }
 800 
 801         if (call_disposeImpl) {
 802             disposeImpl();
 803         }
 804     }
 805 
 806     /**
 807      * Returns null.
 808      *
 809      * @see java.awt.im.spi.InputMethod#getControlObject
 810      */
 811     public Object getControlObject() {
 812         return null;
 813     }
 814 
 815     /**
 816      * @see java.awt.im.spi.InputMethod#removeNotify
 817      */
 818     public synchronized void removeNotify() {
 819         dispose();
 820     }
 821 
 822     /**
 823      * @see java.awt.im.spi.InputMethod#setCompositionEnabled(boolean)
 824      */
 825     public void setCompositionEnabled(boolean enable) {
 826         /* If the composition state is successfully changed, set
 827            the savedCompositionState to 'enable'. Otherwise, simply
 828            return.
 829            setCompositionEnabledNative may throw UnsupportedOperationException.
 830            Don't try to catch it since the method may be called by clients.
 831            Use package private mthod 'resetCompositionState' if you want the
 832            exception to be caught.
 833         */
 834         if (setCompositionEnabledNative(enable)) {
 835             savedCompositionState = enable;
 836         }
 837     }
 838 
 839     /**
 840      * @see java.awt.im.spi.InputMethod#isCompositionEnabled
 841      */
 842     public boolean isCompositionEnabled() {
 843         /* isCompositionEnabledNative may throw UnsupportedOperationException.
 844            Don't try to catch it since this method may be called by clients.
 845            Use package private method 'getCompositionState' if you want the
 846            exception to be caught.
 847         */
 848         return isCompositionEnabledNative();
 849     }
 850 
 851     /**
 852      * Ends any input composition that may currently be going on in this
 853      * context. Depending on the platform and possibly user preferences,
 854      * this may commit or delete uncommitted text. Any changes to the text
 855      * are communicated to the active component using an input method event.
 856      *
 857      * <p>
 858      * A text editing component may call this in a variety of situations,
 859      * for example, when the user moves the insertion point within the text
 860      * (but outside the composed text), or when the component's text is
 861      * saved to a file or copied to the clipboard.
 862      *
 863      */
 864     public void endComposition() {
 865         if (disposed) {
 866             return;
 867         }
 868 
 869         /* Before calling resetXIC, record the current composition mode
 870            so that it can be restored later. */
 871         savedCompositionState = getCompositionState();
 872         boolean active = haveActiveClient();
 873         if (active && composedText == null && committedText == null){
 874             needResetXIC = true;
 875             needResetXICClient = new WeakReference<>(getClientComponent());
 876             return;
 877         }
 878 
 879         String text = resetXIC();
 880         /* needResetXIC is only set to true for active client. So passive
 881            client should not reset the flag to false. */
 882         if (active) {
 883             needResetXIC = false;
 884         }
 885 
 886         // Remove any existing composed text by posting an InputMethodEvent
 887         // with null composed text.  It would be desirable to wait for a
 888         // dispatchComposedText call from X input method engine, but some
 889         // input method does not conform to the XIM specification and does
 890         // not call the preedit callback to erase preedit text on calling
 891         // XmbResetIC.  To work around this problem, do it here by ourselves.
 892         awtLock();
 893         composedText = null;
 894         postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
 895                              null,
 896                              0,
 897                              null,
 898                              null);

 899 
 900         if (text != null && text.length() > 0) {
 901             dispatchCommittedText(text);




 902         }
 903         awtUnlock();
 904 
 905         // Restore the preedit state if it was enabled
 906         if (savedCompositionState) {
 907             resetCompositionState();
 908         }
 909     }
 910 
 911     /**
 912      * Returns a string with information about the current input method server, or null.
 913      * On both Linux & SunOS, the value of environment variable XMODIFIERS is
 914      * returned if set. Otherwise, on SunOS, $HOME/.dtprofile will be parsed
 915      * to find out the language service engine (atok or wnn) since there is
 916      * no API in Xlib which returns the information of native
 917      * IM server or language service and we want to try our best to return as much
 918      * information as possible.
 919      *
 920      * Note: This method could return null on Linux if XMODIFIERS is not set properly or
 921      * if any IOException is thrown.
 922      * See man page of XSetLocaleModifiers(3X11) for the usgae of XMODIFIERS,
 923      * atok12setup(1) and wnn6setup(1) for the information written to
 924      * $HOME/.dtprofile when you run these two commands.
 925      *
 926      */
 927     public String getNativeInputMethodInfo() {
 928         String xmodifiers = System.getenv("XMODIFIERS");
 929         String imInfo = null;
 930 
 931         // If XMODIFIERS is set, return the value
 932         if (xmodifiers != null) {
 933             int imIndex = xmodifiers.indexOf("@im=");
 934             if (imIndex != -1) {
 935                 imInfo = xmodifiers.substring(imIndex + 4);
 936             }
 937         } else if (System.getProperty("os.name").startsWith("SunOS")) {
 938             File dtprofile = new File(System.getProperty("user.home") +
 939                                       "/.dtprofile");
 940             String languageEngineInfo = null;
 941             try {
 942                 BufferedReader br = new BufferedReader(new FileReader(dtprofile));
 943                 String line = null;
 944 
 945                 while ( languageEngineInfo == null && (line = br.readLine()) != null) {
 946                     if (line.contains("atok") || line.contains("wnn")) {
 947                         StringTokenizer tokens =  new StringTokenizer(line);
 948                         while (tokens.hasMoreTokens()) {
 949                             String token = tokens.nextToken();
 950                             if (Pattern.matches("atok.*setup", token) ||
 951                                 Pattern.matches("wnn.*setup", token)){
 952                                 languageEngineInfo = token.substring(0, token.indexOf("setup"));
 953                                 break;
 954                             }
 955                         }
 956                     }
 957                 }
 958 
 959                 br.close();
 960             } catch(IOException ioex) {
 961                 // Since this method is provided for internal testing only,
 962                 // we dump the stack trace for the ease of debugging.
 963                 ioex.printStackTrace();
 964             }
 965 
 966             imInfo = "htt " + languageEngineInfo;
 967         }
 968 
 969         return imInfo;
 970     }
 971 
 972 
 973     /**
 974      * Performs mapping from an XIM visible feedback value to Java IM highlight.
 975      * @return Java input method highlight
 976      */
 977     private InputMethodHighlight convertVisualFeedbackToHighlight(int feedback) {
 978         InputMethodHighlight highlight;
 979 
 980         switch (feedback) {
 981         case XIMUnderline:
 982             highlight = InputMethodHighlight.UNSELECTED_CONVERTED_TEXT_HIGHLIGHT;
 983             break;
 984         case XIMReverse:
 985             highlight = InputMethodHighlight.SELECTED_CONVERTED_TEXT_HIGHLIGHT;
 986             break;
 987         case XIMHighlight:
 988             highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
 989             break;

 990         case XIMPrimary:
 991             highlight = InputMethodHighlight.UNSELECTED_CONVERTED_TEXT_HIGHLIGHT;
 992             break;
 993         case XIMSecondary:
 994             highlight = InputMethodHighlight.SELECTED_CONVERTED_TEXT_HIGHLIGHT;
 995             break;
 996         case XIMTertiary:
 997             highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
 998             break;
 999         default:
1000             highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
1001             break;
1002         }
1003         return highlight;
1004     }
1005 
1006     // initial capacity size for string buffer, etc.
1007     private static final int INITIAL_SIZE = 64;
1008 
1009     /**
1010      * IntBuffer is an inner class that manipulates an int array and
1011      * provides UNIX file io stream-like programming interfaces to
1012      * access it. (An alternative would be to use ArrayList which may
1013      * be too expensive for the work.)
1014      */
1015     private final class IntBuffer {
1016         private int[] intArray;
1017         private int size;
1018         private int index;
1019 
1020         IntBuffer(int initialCapacity) {
1021             intArray = new int[initialCapacity];
1022             size = 0;
1023             index = 0;
1024         }
1025 
1026         void insert(int offset, int[] values) {
1027             int newSize = size + values.length;
1028             if (intArray.length < newSize) {
1029                 int[] newIntArray = new int[newSize * 2];
1030                 System.arraycopy(intArray, 0, newIntArray, 0, size);
1031                 intArray = newIntArray;
1032             }
1033             System.arraycopy(intArray, offset, intArray, offset+values.length,
1034                              size - offset);
1035             System.arraycopy(values, 0, intArray, offset, values.length);
1036             size += values.length;
1037             if (index > offset)
1038                 index = offset;
1039         }
1040 
1041         void remove(int offset, int length) {
1042             if (offset + length != size)
1043                 System.arraycopy(intArray, offset+length, intArray, offset,
1044                                  size - offset - length);
1045             size -= length;
1046             if (index > offset)
1047                 index = offset;
1048         }
1049 
1050         void replace(int offset, int[] values) {
1051             System.arraycopy(values, 0, intArray, offset, values.length);
1052         }
1053 
1054         void removeAll() {
1055             size = 0;
1056             index = 0;
1057         }
1058 
1059         void rewind() {
1060             index = 0;
1061         }
1062 
1063         int getNext() {
1064             if (index == size)
1065                 return -1;
1066             return intArray[index++];
1067         }
1068 
1069         void unget() {
1070             if (index != 0)
1071                 index--;
1072         }
1073 
1074         int getOffset() {
1075             return index;
1076         }
1077 
1078         public String toString() {
1079             StringBuffer s = new StringBuffer();
1080             for (int i = 0; i < size;) {
1081                 s.append(intArray[i++]);
1082                 if (i < size)
1083                     s.append(",");
1084             }
1085             return s.toString();
1086         }
1087     }
1088 
1089     /*
1090      * Native methods
1091      */











1092     private native String resetXIC();
1093     private native void disposeXIC();
1094     private native boolean setCompositionEnabledNative(boolean enable);

1095     private native boolean isCompositionEnabledNative();
1096     private native void turnoffStatusWindow();
1097 }
--- EOF ---