| /* | |
| * Copyright (c) 1999, 2013, 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. | |
| */ | |
| package sun.awt.im; | |
| import java.awt.Component; | |
| import java.awt.Container; | |
| import java.awt.Rectangle; | |
| import java.awt.event.InputMethodEvent; | |
| import java.awt.event.InputMethodListener; | |
| import java.awt.font.TextAttribute; | |
| import java.awt.font.TextHitInfo; | |
| import java.awt.im.InputMethodRequests; | |
| import java.lang.ref.WeakReference; | |
| import java.text.AttributedCharacterIterator; | |
| import java.text.AttributedCharacterIterator.Attribute; | |
| import java.text.AttributedString; | |
| /** | |
| * A composition area handler handles events and input method requests for | |
| * the composition area. Typically each input method context has its own | |
| * composition area handler if it supports passive clients or below-the-spot | |
| * input, but all handlers share a single composition area. | |
| * | |
| * @author JavaSoft International | |
| */ | |
| class CompositionAreaHandler implements InputMethodListener, | |
| InputMethodRequests { | |
| private static CompositionArea compositionArea; | |
| private static Object compositionAreaLock = new Object(); | |
| private static CompositionAreaHandler compositionAreaOwner; // synchronized through compositionArea | |
| private AttributedCharacterIterator composedText; | |
| private TextHitInfo caret = null; | |
| private WeakReference<Component> clientComponent = new WeakReference<>(null); | |
| private InputMethodContext inputMethodContext; | |
| /** | |
| * Constructs the composition area handler. | |
| */ | |
| CompositionAreaHandler(InputMethodContext context) { | |
| inputMethodContext = context; | |
| } | |
| /** | |
| * Creates the composition area. | |
| */ | |
| private void createCompositionArea() { | |
| synchronized(compositionAreaLock) { | |
| compositionArea = new CompositionArea(); | |
| if (compositionAreaOwner != null) { | |
| compositionArea.setHandlerInfo(compositionAreaOwner, inputMethodContext); | |
| } | |
| // If the client component is an active client using below-the-spot style, then | |
| // make the composition window undecorated without a title bar. | |
| Component client = clientComponent.get(); | |
| if(client != null){ | |
| InputMethodRequests req = client.getInputMethodRequests(); | |
| if (req != null && inputMethodContext.useBelowTheSpotInput()) { | |
| setCompositionAreaUndecorated(true); | |
| } | |
| } | |
| } | |
| } | |
| void setClientComponent(Component clientComponent) { | |
| this.clientComponent = new WeakReference<>(clientComponent); | |
| } | |
| /** | |
| * Grabs the composition area, makes this handler its owner, and installs | |
| * the handler and its input context into the composition area for event | |
| * and input method request handling. | |
| * If doUpdate is true, updates the composition area with previously sent | |
| * composed text. | |
| */ | |
| void grabCompositionArea(boolean doUpdate) { | |
| synchronized (compositionAreaLock) { | |
| if (compositionAreaOwner != this) { | |
| compositionAreaOwner = this; | |
| if (compositionArea != null) { | |
| compositionArea.setHandlerInfo(this, inputMethodContext); | |
| } | |
| if (doUpdate) { | |
| // Create the composition area if necessary | |
| if ((composedText != null) && (compositionArea == null)) { | |
| createCompositionArea(); | |
| } | |
| if (compositionArea != null) { | |
| compositionArea.setText(composedText, caret); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Releases and closes the composition area if it is currently owned by | |
| * this composition area handler. | |
| */ | |
| void releaseCompositionArea() { | |
| synchronized (compositionAreaLock) { | |
| if (compositionAreaOwner == this) { | |
| compositionAreaOwner = null; | |
| if (compositionArea != null) { | |
| compositionArea.setHandlerInfo(null, null); | |
| compositionArea.setText(null, null); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Releases and closes the composition area if it has been created, | |
| * independent of the current owner. | |
| */ | |
| static void closeCompositionArea() { | |
| if (compositionArea != null) { | |
| synchronized (compositionAreaLock) { | |
| compositionAreaOwner = null; | |
| compositionArea.setHandlerInfo(null, null); | |
| compositionArea.setText(null, null); | |
| } | |
| } | |
| } | |
| /** | |
| * Returns whether the composition area is currently visible | |
| */ | |
| boolean isCompositionAreaVisible() { | |
| if (compositionArea != null) { | |
| return compositionArea.isCompositionAreaVisible(); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Shows or hides the composition Area | |
| */ | |
| void setCompositionAreaVisible(boolean visible) { | |
| if (compositionArea != null) { | |
| compositionArea.setCompositionAreaVisible(visible); | |
| } | |
| } | |
| void processInputMethodEvent(InputMethodEvent event) { | |
| if (event.getID() == InputMethodEvent.INPUT_METHOD_TEXT_CHANGED) { | |
| inputMethodTextChanged(event); | |
| } else { | |
| caretPositionChanged(event); | |
| } | |
| } | |
| /** | |
| * set the compositionArea frame decoration | |
| */ | |
| void setCompositionAreaUndecorated(boolean undecorated) { | |
| if (compositionArea != null) { | |
| compositionArea.setCompositionAreaUndecorated(undecorated); | |
| } | |
| } | |
| // | |
| // InputMethodListener methods | |
| // | |
| private static final Attribute[] IM_ATTRIBUTES = | |
| { TextAttribute.INPUT_METHOD_HIGHLIGHT }; | |
| public void inputMethodTextChanged(InputMethodEvent event) { | |
| AttributedCharacterIterator text = event.getText(); | |
| int committedCharacterCount = event.getCommittedCharacterCount(); | |
| // extract composed text and prepare it for display | |
| composedText = null; | |
| caret = null; | |
| if (text != null | |
| && committedCharacterCount < text.getEndIndex() - text.getBeginIndex()) { | |
| // Create the composition area if necessary | |
| if (compositionArea == null) { | |
| createCompositionArea(); | |
| } | |
| // copy the composed text | |
| AttributedString composedTextString; | |
| composedTextString = new AttributedString(text, | |
| text.getBeginIndex() + committedCharacterCount, // skip over committed text | |
| text.getEndIndex(), IM_ATTRIBUTES); | |
| composedTextString.addAttribute(TextAttribute.FONT, compositionArea.getFont()); | |
| composedText = composedTextString.getIterator(); | |
| caret = event.getCaret(); | |
| } | |
| if (compositionArea != null) { | |
| compositionArea.setText(composedText, caret); | |
| } | |
| // send any committed text to the text component | |
| if (committedCharacterCount > 0) { | |
| inputMethodContext.dispatchCommittedText(((Component) event.getSource()), | |
| text, committedCharacterCount); | |
| // this may have changed the text location, so reposition the window | |
| if (isCompositionAreaVisible()) { | |
| compositionArea.updateWindowLocation(); | |
| } | |
| } | |
| // event has been handled, so consume it | |
| event.consume(); | |
| } | |
| public void caretPositionChanged(InputMethodEvent event) { | |
| if (compositionArea != null) { | |
| compositionArea.setCaret(event.getCaret()); | |
| } | |
| // event has been handled, so consume it | |
| event.consume(); | |
| } | |
| // | |
| // InputMethodRequests methods | |
| // | |
| /** | |
| * Returns the input method request handler of the client component. | |
| * When using the composition window for an active client (below-the-spot | |
| * input), input method requests that do not relate to the display of | |
| * the composed text are forwarded to the client component. | |
| */ | |
| InputMethodRequests getClientInputMethodRequests() { | |
| Component client = clientComponent.get(); | |
| if (client != null) { | |
| return client.getInputMethodRequests(); | |
| } | |
| return null; | |
| } | |
| public Rectangle getTextLocation(TextHitInfo offset) { | |
| synchronized (compositionAreaLock) { | |
| if (compositionAreaOwner == this && isCompositionAreaVisible()) { | |
| return compositionArea.getTextLocation(offset); | |
| } else if (composedText != null) { | |
| // there's composed text, but it's not displayed, so fake a rectangle | |
| return new Rectangle(0, 0, 0, 10); | |
| } else { | |
| InputMethodRequests requests = getClientInputMethodRequests(); | |
| if (requests != null) { | |
| return requests.getTextLocation(offset); | |
| } else { | |
| // passive client, no composed text, so fake a rectangle | |
| return new Rectangle(0, 0, 0, 10); | |
| } | |
| } | |
| } | |
| } | |
| public TextHitInfo getLocationOffset(int x, int y) { | |
| synchronized (compositionAreaLock) { | |
| if (compositionAreaOwner == this && isCompositionAreaVisible()) { | |
| return compositionArea.getLocationOffset(x, y); | |
| } else { | |
| return null; | |
| } | |
| } | |
| } | |
| public int getInsertPositionOffset() { | |
| InputMethodRequests req = getClientInputMethodRequests(); | |
| if (req != null) { | |
| return req.getInsertPositionOffset(); | |
| } | |
| // we don't have access to the client component's text. | |
| return 0; | |
| } | |
| private static final AttributedCharacterIterator EMPTY_TEXT = | |
| (new AttributedString("")).getIterator(); | |
| public AttributedCharacterIterator getCommittedText(int beginIndex, | |
| int endIndex, | |
| Attribute[] attributes) { | |
| InputMethodRequests req = getClientInputMethodRequests(); | |
| if(req != null) { | |
| return req.getCommittedText(beginIndex, endIndex, attributes); | |
| } | |
| // we don't have access to the client component's text. | |
| return EMPTY_TEXT; | |
| } | |
| public int getCommittedTextLength() { | |
| InputMethodRequests req = getClientInputMethodRequests(); | |
| if(req != null) { | |
| return req.getCommittedTextLength(); | |
| } | |
| // we don't have access to the client component's text. | |
| return 0; | |
| } | |
| public AttributedCharacterIterator cancelLatestCommittedText(Attribute[] attributes) { | |
| InputMethodRequests req = getClientInputMethodRequests(); | |
| if(req != null) { | |
| return req.cancelLatestCommittedText(attributes); | |
| } | |
| // we don't have access to the client component's text. | |
| return null; | |
| } | |
| public AttributedCharacterIterator getSelectedText(Attribute[] attributes) { | |
| InputMethodRequests req = getClientInputMethodRequests(); | |
| if(req != null) { | |
| return req.getSelectedText(attributes); | |
| } | |
| // we don't have access to the client component's text. | |
| return EMPTY_TEXT; | |
| } | |
| } |