1 /*
2 * Copyright (c) 1997, 2018, 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.awt.AWTException;
29 import java.awt.EventQueue;
30 import java.awt.event.InputMethodEvent;
31 import java.awt.font.TextAttribute;
32 import java.awt.font.TextHitInfo;
33 import java.awt.peer.ComponentPeer;
34 import java.text.AttributedString;
35
36 import sun.util.logging.PlatformLogger;
37
38 /**
39 * Input Method Adapter for XIM for AIX
40 *
41 * @author JavaSoft International
42 */
43 public abstract class X11InputMethod extends X11InputMethodBase {
44
45 // to keep the instance of activating if IM resumed
46 static protected X11InputMethod activatedInstance = null;
47
48 /**
49 * Constructs an X11InputMethod instance. It initializes the XIM
50 * environment if it's not done yet.
51 *
52 * @exception AWTException if XOpenIM() failed.
53 */
54 public X11InputMethod() throws AWTException {
55 super();
56 }
57
58 /**
59 * Reset the composition state to the current composition state.
60 */
61 protected void resetCompositionState() {
62 if (compositionEnableSupported && haveActiveClient()) {
63 try {
64 /* Restore the composition mode to the last saved composition
65 mode. */
66 setCompositionEnabled(savedCompositionState);
67 } catch (UnsupportedOperationException e) {
68 compositionEnableSupported = false;
69 }
70 }
71 }
72
73 /**
74 * Activate input method.
75 */
76 public synchronized void activate() {
77 activatedInstance = this;
78 clientComponentWindow = getClientComponentWindow();
79 if (clientComponentWindow == null)
80 return;
81
82 if (lastXICFocussedComponent != null) {
83 if (log.isLoggable(PlatformLogger.Level.FINE)) {
84 log.fine("XICFocused {0}, AWTFocused {1}",
85 lastXICFocussedComponent, awtFocussedComponent);
86 }
87 if (lastXICFocussedComponent != awtFocussedComponent) {
88 ComponentPeer lastXICFocussedComponentPeer = getPeer(lastXICFocussedComponent);
89 if (lastXICFocussedComponentPeer != null) {
90 setXICFocus(lastXICFocussedComponentPeer, false, isLastXICActive);
91 }
92 }
93 lastXICFocussedComponent = null;
94 }
95
96 if (pData == 0) {
97 if (!createXIC()) {
98 return;
99 }
100 disposed = false;
101 }
102
103 /* reset input context if necessary and set the XIC focus
104 */
105 resetXICifneeded();
106 ComponentPeer awtFocussedComponentPeer = getPeer(awtFocussedComponent);
107 setStatusAreaVisible(true, pData);
108
109 if (awtFocussedComponentPeer != null) {
110 setXICFocus(awtFocussedComponentPeer, true, haveActiveClient());
111 }
112 lastXICFocussedComponent = awtFocussedComponent;
113 isLastXICActive = haveActiveClient();
114 isActive = true;
115 if (savedCompositionState) {
116 resetCompositionState();
117 }
118 }
119
120 /**
121 * Deactivate input method.
122 */
123 public synchronized void deactivate(boolean isTemporary) {
124 boolean isAc = haveActiveClient();
125 /* Usually as the client component, let's call it component A,
126 loses the focus, this method is called. Then when another client
127 component, let's call it component B, gets the focus, activate is first called on
128 the previous focused compoent which is A, then endComposition is called on A,
129 deactivate is called on A again. And finally activate is called on the newly
130 focused component B. Here is the call sequence.
131
132 A loses focus B gains focus
133 -------------> deactivate A -------------> activate A -> endComposition A ->
134 deactivate A -> activate B ----....
135
136 So in order to carry the composition mode across the components sharing the same
137 input context, we save it when deactivate is called so that when activate is
138 called, it can be restored correctly till activate is called on the newly focused
139 component. (See also sun/awt/im/InputContext and bug 6184471).
140 Last note, getCompositionState should be called before setXICFocus since
141 setXICFocus here sets the XIC to 0.
142 */
143 activatedInstance = null;
144 savedCompositionState = getCompositionState();
145
146 if (isTemporary) {
147 //turn the status window off...
148 turnoffStatusWindow();
149 /* Delay resetting the XIC focus until activate is called and the newly
150 * Focused component has a different peer as the last focused component.
151 */
152 lastXICFocussedComponent = awtFocussedComponent;
153 } else {
154 if (awtFocussedComponent != null ) {
155 ComponentPeer awtFocussedComponentPeer = getPeer(awtFocussedComponent);
156 if (awtFocussedComponentPeer != null) {
157 setXICFocus(awtFocussedComponentPeer, false, isAc);
158 }
159 }
160 lastXICFocussedComponent = null;
161 }
162
163 isLastXICActive = isAc;
164 isLastTemporary = isTemporary;
165 isActive = false;
166 setStatusAreaVisible(false, pData);
167 }
168
169 // implements java.awt.im.spi.InputMethod.hideWindows
170 public void hideWindows() {
171 if (pData != 0) {
172 setStatusAreaVisible(false, pData);
173 turnoffStatusWindow();
174 }
175 }
176
177 /**
178 * Updates composed text with XIM preedit information and
179 * posts composed text to the awt event queue. The args of
180 * this method correspond to the XIM preedit callback
181 * information. The XIM highlight attributes are translated via
182 * fixed mapping (i.e., independent from any underlying input
183 * method engine). This method is invoked in the AWT Toolkit
184 * (X event loop) thread context and thus inside the AWT Lock.
185 */
186 // NOTE: This method may be called by privileged threads.
187 // This functionality is implemented in a package-private method
188 // to insure that it cannot be overridden by client subclasses.
189 // DO NOT INVOKE CLIENT CODE ON THIS THREAD!
190 void dispatchComposedText(String chgText,
191 int chgStyles[],
192 int chgOffset,
193 int chgLength,
194 int caretPosition,
195 long when) {
196 if (disposed) {
197 return;
198 }
199
200 // Workaround for deadlock bug on solaris2.6_zh bug#4170760
201 if (chgText == null
202 && chgStyles == null
203 && chgOffset == 0
204 && chgLength == 0
205 && caretPosition == 0
206 && composedText == null
207 && committedText == null)
208 return;
209
210 // Recalculate chgOffset and chgLength for supplementary char
211 if (composedText != null) {
212 int tmpChgOffset=chgOffset;
213 int tmpChgLength=chgLength;
214 int index = 0;
215 for (int i=0;i < tmpChgOffset; i++,index++){
216 if (index < composedText.length()
217 && Character.charCount(composedText.codePointAt(index))==2){
218 index++;
219 chgOffset++;
220 }
221 }
222 // The index keeps value
223 for (int i=0;i < tmpChgLength; i++,index++){
224 if (index < composedText.length()
225 && Character.charCount(composedText.codePointAt(index))==2){
226 index++;
227 chgLength++;
228 }
229 }
230 }
231
232 // Replace control character with a square box
233 if (chgText != null) {
234 StringBuffer newChgText = new StringBuffer();
235 for (int i=0; i < chgText.length(); i++){
236 char c = chgText.charAt(i);
237 if (Character.isISOControl(c)){
238 c = '\u25A1';
239 }
240 newChgText.append(c);
241 }
242 chgText = new String(newChgText);
243 }
244
245 if (composedText == null) {
246 // TODO: avoid reallocation of those buffers
247 composedText = new StringBuffer(INITIAL_SIZE);
248 rawFeedbacks = new IntBuffer(INITIAL_SIZE);
249 }
250 if (chgLength > 0) {
251 if (chgText == null && chgStyles != null) {
252 rawFeedbacks.replace(chgOffset, chgStyles);
253 } else {
254 if (chgLength == composedText.length()) {
255 // optimization for the special case to replace the
256 // entire previous text
257 composedText = new StringBuffer(INITIAL_SIZE);
258 rawFeedbacks = new IntBuffer(INITIAL_SIZE);
259 } else {
260 if (composedText.length() > 0) {
261 if (chgOffset+chgLength < composedText.length()) {
262 String text;
263 text = composedText.toString().substring(chgOffset+chgLength,
264 composedText.length());
265 composedText.setLength(chgOffset);
266 composedText.append(text);
267 } else {
268 // in case to remove substring from chgOffset
269 // to the end
270 composedText.setLength(chgOffset);
271 }
272 rawFeedbacks.remove(chgOffset, chgLength);
273 }
274 }
275 }
276 }
277 if (chgText != null) {
278 composedText.insert(chgOffset, chgText);
279 if (chgStyles != null) {
280 // Recalculate chgStyles for supplementary char
281 if (chgText.length() > chgStyles.length){
282 int index=0;
283 int[] newStyles = new int[chgText.length()];
284 for (int i=0; i < chgStyles.length; i++, index++){
285 newStyles[index]=chgStyles[i];
286 if (index < chgText.length()
287 && Character.charCount(chgText.codePointAt(index))==2){
288 newStyles[++index]=chgStyles[i];
289 }
290 }
291 chgStyles=newStyles;
292 }
293 rawFeedbacks.insert(chgOffset, chgStyles);
294 }
295
296 }
297
298 else if (chgStyles != null) {
299 // Recalculate chgStyles to support supplementary char
300 int count=0;
301 for (int i=0; i < chgStyles.length; i++){
302 if (composedText.length() > chgOffset+i+count
303 && Character.charCount(composedText.codePointAt(chgOffset+i+count))==2){
304 count++;
305 }
306 }
307 if (count>0){
308 int index=0;
309 int[] newStyles = new int[chgStyles.length+count];
310 for (int i=0; i < chgStyles.length; i++, index++){
311 newStyles[index]=chgStyles[i];
312 if (composedText.length() > chgOffset+index
313 && Character.charCount(composedText.codePointAt(chgOffset+index))==2){
314 newStyles[++index]=chgStyles[i];
315 }
316 }
317 chgStyles=newStyles;
318 }
319 rawFeedbacks.replace(chgOffset, chgStyles);
320 }
321
322 if (composedText.length() == 0) {
323 composedText = null;
324 rawFeedbacks = null;
325
326 // if there is any outstanding committed text stored by
327 // dispatchCommittedText(), it has to be sent to the
328 // client component.
329 if (committedText != null) {
330 dispatchCommittedText(committedText, when);
331 committedText = null;
332 return;
333 }
334
335 // otherwise, send null text to delete client's composed
336 // text.
337 postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
338 null,
339 0,
340 null,
341 null,
342 when);
343
344 return;
345 }
346
347 // Adjust caretPosition for supplementary char
348 for (int i=0; i< caretPosition; i++){
349 if (i < composedText.length()
350 && Character.charCount(composedText.codePointAt(i))==2){
351 caretPosition++;
352 i++;
353 }
354 }
355
356 // Now sending the composed text to the client
357 int composedOffset;
358 AttributedString inputText;
359
360 // if there is any partially committed text, concatenate it to
361 // the composed text.
362 if (committedText != null) {
363 composedOffset = committedText.length();
364 inputText = new AttributedString(committedText + composedText);
365 committedText = null;
366 } else {
367 composedOffset = 0;
368 inputText = new AttributedString(composedText.toString());
369 }
370
371 int currentFeedback;
372 int nextFeedback;
373 int startOffset = 0;
374 int currentOffset;
375 int visiblePosition = 0;
376 TextHitInfo visiblePositionInfo = null;
377
378 rawFeedbacks.rewind();
379 currentFeedback = rawFeedbacks.getNext();
380 rawFeedbacks.unget();
381 while ((nextFeedback = rawFeedbacks.getNext()) != -1) {
382 if (visiblePosition == 0) {
383 visiblePosition = nextFeedback & XIMVisibleMask;
384 if (visiblePosition != 0) {
385 int index = rawFeedbacks.getOffset() - 1;
386
387 if (visiblePosition == XIMVisibleToBackward)
388 visiblePositionInfo = TextHitInfo.leading(index);
389 else
390 visiblePositionInfo = TextHitInfo.trailing(index);
391 }
392 }
393 nextFeedback &= ~XIMVisibleMask;
394 if (currentFeedback != nextFeedback) {
395 rawFeedbacks.unget();
396 currentOffset = rawFeedbacks.getOffset();
397 inputText.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
398 convertVisualFeedbackToHighlight(currentFeedback),
399 composedOffset + startOffset,
400 composedOffset + currentOffset);
401 startOffset = currentOffset;
402 currentFeedback = nextFeedback;
403 }
404 }
405 currentOffset = rawFeedbacks.getOffset();
406 if (currentOffset >= 0) {
407 inputText.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
408 convertVisualFeedbackToHighlight(currentFeedback),
409 composedOffset + startOffset,
410 composedOffset + currentOffset);
411 }
412
413 postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
414 inputText.getIterator(),
415 composedOffset,
416 TextHitInfo.leading(caretPosition),
417 visiblePositionInfo,
418 when);
419 }
420
421 /* Some IMs need forced Text clear */
422 void clearComposedText(long when) {
423 composedText = null;
424 postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
425 null, 0, null, null,
426 when);
427 if (committedText != null && committedText.length() > 0) {
428 dispatchCommittedText(committedText, when);
429 }
430 committedText = null;
431 rawFeedbacks = null;
432 }
433
434 void clearComposedText() {
435 if (EventQueue.isDispatchThread()) {
436 clearComposedText(EventQueue.getMostRecentEventTime());
437 }
438 }
439
440 /*
441 * Subclasses should override disposeImpl() instead of dispose(). Client
442 * code should always invoke dispose(), never disposeImpl().
443 */
444 protected synchronized void disposeImpl() {
445 disposeXIC();
446 awtLock();
447 try {
448 clearComposedText();
449 } finally {
450 // Put awtUnlock into finally block in case an exception is thrown in clearComposedText.
451 awtUnlock();
452 }
453 awtFocussedComponent = null;
454 lastXICFocussedComponent = null;
455 needResetXIC = false;
456 savedCompositionState = false;
457 compositionEnableSupported = true;
458 }
459
460 /**
461 * @see java.awt.im.spi.InputMethod#setCompositionEnabled(boolean)
462 */
463 public void setCompositionEnabled(boolean enable) {
464 /* If the composition state is successfully changed, set
465 the savedCompositionState to 'enable'. Otherwise, simply
466 return.
467 setCompositionEnabledNative may throw UnsupportedOperationException.
468 Don't try to catch it since the method may be called by clients.
469 Use package private mthod 'resetCompositionState' if you want the
470 exception to be caught.
471 */
472 boolean pre, post;
473 pre=getCompositionState();
474
475 if (setCompositionEnabledNative(enable)) {
476 savedCompositionState = enable;
477 }
478
479 post=getCompositionState();
480 if (pre != post && post == enable){
481 if (enable == false) flushText();
482 if (awtFocussedComponent != null && isActive){
483 setXICFocus(getPeer(awtFocussedComponent),
484 true, haveActiveClient());
485 }
486 }
487 }
488
489 private native void setStatusAreaVisible(boolean value, long data);
490 }