8201429: Support AIX Input Method Editor (IME) for AWT Input Method Framework (IMF)
Reviewed-by: prr
Contributed-by: takiguc@linux.vnet.ibm.com, christoph.langer@sap.com
--- a/make/lib/Awt2dLibraries.gmk Tue May 29 11:22:21 2018 -0700
+++ b/make/lib/Awt2dLibraries.gmk Wed May 30 08:19:59 2018 +0200
@@ -269,6 +269,7 @@
ifeq ($(ENABLE_HEADLESS_ONLY), false)
LIBAWT_XAWT_DIRS := \
+ $(wildcard $(TOPDIR)/src/java.desktop/$(OPENJDK_TARGET_OS)/native/libawt_xawt) \
$(TOPDIR)/src/java.desktop/$(OPENJDK_TARGET_OS_TYPE)/native/libawt_xawt \
$(TOPDIR)/src/java.desktop/share/native/common/awt/debug \
$(TOPDIR)/src/java.desktop/share/native/common/awt/utility \
@@ -329,7 +330,7 @@
BUILD_LIBAWT_XAWT_awt_Font.c_CFLAGS := -w
# initializing a declared 'extern'
BUILD_LIBAWT_XAWT_debug_mem.c_CFLAGS := -w
- endif
+ endif
$(eval $(call SetupJdkLibrary, BUILD_LIBAWT_XAWT, \
NAME := awt_xawt, \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.desktop/aix/classes/sun/awt/X11InputMethod.java Wed May 30 08:19:59 2018 +0200
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) 1997, 2018, 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;
+
+import java.awt.AWTException;
+import java.awt.EventQueue;
+import java.awt.event.InputMethodEvent;
+import java.awt.font.TextAttribute;
+import java.awt.font.TextHitInfo;
+import java.awt.peer.ComponentPeer;
+import java.text.AttributedString;
+
+import sun.util.logging.PlatformLogger;
+
+/**
+ * Input Method Adapter for XIM for AIX
+ *
+ * @author JavaSoft International
+ */
+public abstract class X11InputMethod extends X11InputMethodBase {
+
+ // to keep the instance of activating if IM resumed
+ static protected X11InputMethod activatedInstance = null;
+
+ /**
+ * Constructs an X11InputMethod instance. It initializes the XIM
+ * environment if it's not done yet.
+ *
+ * @exception AWTException if XOpenIM() failed.
+ */
+ public X11InputMethod() throws AWTException {
+ super();
+ }
+
+ /**
+ * Reset the composition state to the current composition state.
+ */
+ protected void resetCompositionState() {
+ if (compositionEnableSupported && haveActiveClient()) {
+ try {
+ /* Restore the composition mode to the last saved composition
+ mode. */
+ setCompositionEnabled(savedCompositionState);
+ } catch (UnsupportedOperationException e) {
+ compositionEnableSupported = false;
+ }
+ }
+ }
+
+ /**
+ * Activate input method.
+ */
+ public synchronized void activate() {
+ activatedInstance = this;
+ clientComponentWindow = getClientComponentWindow();
+ if (clientComponentWindow == null)
+ return;
+
+ if (lastXICFocussedComponent != null) {
+ if (log.isLoggable(PlatformLogger.Level.FINE)) {
+ log.fine("XICFocused {0}, AWTFocused {1}",
+ lastXICFocussedComponent, awtFocussedComponent);
+ }
+ if (lastXICFocussedComponent != awtFocussedComponent) {
+ ComponentPeer lastXICFocussedComponentPeer = getPeer(lastXICFocussedComponent);
+ if (lastXICFocussedComponentPeer != null) {
+ setXICFocus(lastXICFocussedComponentPeer, false, isLastXICActive);
+ }
+ }
+ lastXICFocussedComponent = null;
+ }
+
+ if (pData == 0) {
+ if (!createXIC()) {
+ return;
+ }
+ disposed = false;
+ }
+
+ /* reset input context if necessary and set the XIC focus
+ */
+ resetXICifneeded();
+ ComponentPeer awtFocussedComponentPeer = getPeer(awtFocussedComponent);
+ setStatusAreaVisible(true, pData);
+
+ if (awtFocussedComponentPeer != null) {
+ setXICFocus(awtFocussedComponentPeer, true, haveActiveClient());
+ }
+ lastXICFocussedComponent = awtFocussedComponent;
+ isLastXICActive = haveActiveClient();
+ isActive = true;
+ if (savedCompositionState) {
+ resetCompositionState();
+ }
+ }
+
+ /**
+ * Deactivate input method.
+ */
+ public synchronized void deactivate(boolean isTemporary) {
+ 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.
+ */
+ activatedInstance = null;
+ savedCompositionState = getCompositionState();
+
+ if (isTemporary) {
+ //turn the status window off...
+ turnoffStatusWindow();
+ /* Delay resetting the XIC focus until activate is called and the newly
+ * Focused component has a different peer as the last focused component.
+ */
+ lastXICFocussedComponent = awtFocussedComponent;
+ } else {
+ if (awtFocussedComponent != null ) {
+ ComponentPeer awtFocussedComponentPeer = getPeer(awtFocussedComponent);
+ if (awtFocussedComponentPeer != null) {
+ setXICFocus(awtFocussedComponentPeer, false, isAc);
+ }
+ }
+ lastXICFocussedComponent = null;
+ }
+
+ isLastXICActive = isAc;
+ isLastTemporary = isTemporary;
+ isActive = false;
+ setStatusAreaVisible(false, pData);
+ }
+
+ // implements java.awt.im.spi.InputMethod.hideWindows
+ public void hideWindows() {
+ if (pData != 0) {
+ setStatusAreaVisible(false, pData);
+ turnoffStatusWindow();
+ }
+ }
+
+ /**
+ * 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!
+ void dispatchComposedText(String chgText,
+ int chgStyles[],
+ int chgOffset,
+ int chgLength,
+ int caretPosition,
+ long when) {
+ if (disposed) {
+ return;
+ }
+
+ // Workaround for deadlock bug on solaris2.6_zh bug#4170760
+ if (chgText == null
+ && chgStyles == null
+ && chgOffset == 0
+ && chgLength == 0
+ && caretPosition == 0
+ && composedText == null
+ && committedText == null)
+ return;
+
+ // Recalculate chgOffset and chgLength for supplementary char
+ if (composedText != null) {
+ int tmpChgOffset=chgOffset;
+ int tmpChgLength=chgLength;
+ int index = 0;
+ for (int i=0;i < tmpChgOffset; i++,index++){
+ if (index < composedText.length()
+ && Character.charCount(composedText.codePointAt(index))==2){
+ index++;
+ chgOffset++;
+ }
+ }
+ // The index keeps value
+ for (int i=0;i < tmpChgLength; i++,index++){
+ if (index < composedText.length()
+ && Character.charCount(composedText.codePointAt(index))==2){
+ index++;
+ chgLength++;
+ }
+ }
+ }
+
+ // Replace control character with a square box
+ if (chgText != null) {
+ StringBuffer newChgText = new StringBuffer();
+ for (int i=0; i < chgText.length(); i++){
+ char c = chgText.charAt(i);
+ if (Character.isISOControl(c)){
+ c = '\u25A1';
+ }
+ newChgText.append(c);
+ }
+ chgText = new String(newChgText);
+ }
+
+ if (composedText == null) {
+ // TODO: avoid reallocation of those buffers
+ composedText = new StringBuffer(INITIAL_SIZE);
+ rawFeedbacks = new IntBuffer(INITIAL_SIZE);
+ }
+ if (chgLength > 0) {
+ if (chgText == null && chgStyles != null) {
+ rawFeedbacks.replace(chgOffset, chgStyles);
+ } else {
+ if (chgLength == composedText.length()) {
+ // optimization for the special case to replace the
+ // entire previous text
+ composedText = new StringBuffer(INITIAL_SIZE);
+ rawFeedbacks = new IntBuffer(INITIAL_SIZE);
+ } else {
+ if (composedText.length() > 0) {
+ if (chgOffset+chgLength < composedText.length()) {
+ String text;
+ text = composedText.toString().substring(chgOffset+chgLength,
+ composedText.length());
+ composedText.setLength(chgOffset);
+ composedText.append(text);
+ } else {
+ // in case to remove substring from chgOffset
+ // to the end
+ composedText.setLength(chgOffset);
+ }
+ rawFeedbacks.remove(chgOffset, chgLength);
+ }
+ }
+ }
+ }
+ if (chgText != null) {
+ composedText.insert(chgOffset, chgText);
+ if (chgStyles != null) {
+ // Recalculate chgStyles for supplementary char
+ if (chgText.length() > chgStyles.length){
+ int index=0;
+ int[] newStyles = new int[chgText.length()];
+ for (int i=0; i < chgStyles.length; i++, index++){
+ newStyles[index]=chgStyles[i];
+ if (index < chgText.length()
+ && Character.charCount(chgText.codePointAt(index))==2){
+ newStyles[++index]=chgStyles[i];
+ }
+ }
+ chgStyles=newStyles;
+ }
+ rawFeedbacks.insert(chgOffset, chgStyles);
+ }
+
+ }
+
+ else if (chgStyles != null) {
+ // Recalculate chgStyles to support supplementary char
+ int count=0;
+ for (int i=0; i < chgStyles.length; i++){
+ if (composedText.length() > chgOffset+i+count
+ && Character.charCount(composedText.codePointAt(chgOffset+i+count))==2){
+ count++;
+ }
+ }
+ if (count>0){
+ int index=0;
+ int[] newStyles = new int[chgStyles.length+count];
+ for (int i=0; i < chgStyles.length; i++, index++){
+ newStyles[index]=chgStyles[i];
+ if (composedText.length() > chgOffset+index
+ && Character.charCount(composedText.codePointAt(chgOffset+index))==2){
+ newStyles[++index]=chgStyles[i];
+ }
+ }
+ chgStyles=newStyles;
+ }
+ rawFeedbacks.replace(chgOffset, chgStyles);
+ }
+
+ if (composedText.length() == 0) {
+ 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) {
+ dispatchCommittedText(committedText, when);
+ committedText = null;
+ return;
+ }
+
+ // otherwise, send null text to delete client's composed
+ // text.
+ postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ null,
+ 0,
+ null,
+ null,
+ when);
+
+ return;
+ }
+
+ // Adjust caretPosition for supplementary char
+ for (int i=0; i< caretPosition; i++){
+ if (i < composedText.length()
+ && Character.charCount(composedText.codePointAt(i))==2){
+ caretPosition++;
+ i++;
+ }
+ }
+
+ // Now sending the composed text to the client
+ int composedOffset;
+ AttributedString inputText;
+
+ // if there is any partially committed text, concatenate it to
+ // the composed text.
+ if (committedText != null) {
+ composedOffset = committedText.length();
+ inputText = new AttributedString(committedText + composedText);
+ committedText = null;
+ } else {
+ composedOffset = 0;
+ inputText = new AttributedString(composedText.toString());
+ }
+
+ int currentFeedback;
+ int nextFeedback;
+ int startOffset = 0;
+ int currentOffset;
+ int visiblePosition = 0;
+ TextHitInfo visiblePositionInfo = null;
+
+ rawFeedbacks.rewind();
+ currentFeedback = rawFeedbacks.getNext();
+ rawFeedbacks.unget();
+ while ((nextFeedback = rawFeedbacks.getNext()) != -1) {
+ if (visiblePosition == 0) {
+ visiblePosition = nextFeedback & XIMVisibleMask;
+ if (visiblePosition != 0) {
+ int index = rawFeedbacks.getOffset() - 1;
+
+ if (visiblePosition == XIMVisibleToBackward)
+ visiblePositionInfo = TextHitInfo.leading(index);
+ else
+ visiblePositionInfo = TextHitInfo.trailing(index);
+ }
+ }
+ nextFeedback &= ~XIMVisibleMask;
+ if (currentFeedback != nextFeedback) {
+ rawFeedbacks.unget();
+ currentOffset = rawFeedbacks.getOffset();
+ inputText.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
+ convertVisualFeedbackToHighlight(currentFeedback),
+ composedOffset + startOffset,
+ composedOffset + currentOffset);
+ startOffset = currentOffset;
+ currentFeedback = nextFeedback;
+ }
+ }
+ currentOffset = rawFeedbacks.getOffset();
+ if (currentOffset >= 0) {
+ inputText.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
+ convertVisualFeedbackToHighlight(currentFeedback),
+ composedOffset + startOffset,
+ composedOffset + currentOffset);
+ }
+
+ postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ inputText.getIterator(),
+ composedOffset,
+ TextHitInfo.leading(caretPosition),
+ visiblePositionInfo,
+ when);
+ }
+
+ /* Some IMs need forced Text clear */
+ void clearComposedText(long when) {
+ composedText = null;
+ postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ null, 0, null, null,
+ when);
+ if (committedText != null && committedText.length() > 0) {
+ dispatchCommittedText(committedText, when);
+ }
+ committedText = null;
+ rawFeedbacks = null;
+ }
+
+ void clearComposedText() {
+ if (EventQueue.isDispatchThread()) {
+ clearComposedText(EventQueue.getMostRecentEventTime());
+ }
+ }
+
+ /*
+ * Subclasses should override disposeImpl() instead of dispose(). Client
+ * code should always invoke dispose(), never disposeImpl().
+ */
+ protected synchronized void disposeImpl() {
+ disposeXIC();
+ awtLock();
+ try {
+ clearComposedText();
+ } finally {
+ // Put awtUnlock into finally block in case an exception is thrown in clearComposedText.
+ awtUnlock();
+ }
+ awtFocussedComponent = null;
+ lastXICFocussedComponent = null;
+ needResetXIC = false;
+ savedCompositionState = false;
+ compositionEnableSupported = true;
+ }
+
+ /**
+ * @see java.awt.im.spi.InputMethod#setCompositionEnabled(boolean)
+ */
+ public void setCompositionEnabled(boolean enable) {
+ /* 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.
+ */
+ boolean pre, post;
+ pre=getCompositionState();
+
+ if (setCompositionEnabledNative(enable)) {
+ savedCompositionState = enable;
+ }
+
+ post=getCompositionState();
+ if (pre != post && post == enable){
+ if (enable == false) flushText();
+ if (awtFocussedComponent != null && isActive){
+ setXICFocus(getPeer(awtFocussedComponent),
+ true, haveActiveClient());
+ }
+ }
+ }
+
+ private native void setStatusAreaVisible(boolean value, long data);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.desktop/aix/native/libawt_xawt/awt/awt_InputMethod.c Wed May 30 08:19:59 2018 +0200
@@ -0,0 +1,2269 @@
+/*
+ * Copyright (c) 1997, 2018, 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.
+ */
+
+#ifdef HEADLESS
+ #error This file should not be included in headless library
+#endif
+
+#include "awt.h"
+#include "awt_p.h"
+
+#include <sun_awt_X11InputMethodBase.h>
+#include <sun_awt_X11InputMethod.h>
+#include <sun_awt_X11_XInputMethod.h>
+
+#include <langinfo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <wchar.h>
+#include <wctype.h>
+#include <X11/Intrinsic.h>
+#include <X11/keysym.h>
+#include <X11/Xlib.h>
+
+#define THROW_OUT_OF_MEMORY_ERROR() \
+ JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), NULL)
+
+struct X11InputMethodIDs {
+ jfieldID pData;
+} x11InputMethodIDs;
+
+static int PreeditStartCallback(XIC, XPointer, XPointer);
+static void PreeditDoneCallback(XIC, XPointer, XPointer);
+static void PreeditDrawCallback(XIC, XPointer,
+ XIMPreeditDrawCallbackStruct *);
+static void PreeditCaretCallback(XIC, XPointer,
+ XIMPreeditCaretCallbackStruct *);
+static void StatusStartCallback(XIC, XPointer, XPointer);
+static void StatusDoneCallback(XIC, XPointer, XPointer);
+static void StatusDrawCallback(XIC, XPointer,
+ XIMStatusDrawCallbackStruct *);
+
+#define ROOT_WINDOW_STYLES (XIMPreeditNothing | XIMStatusNothing)
+#define NO_STYLES (XIMPreeditNone | XIMStatusNone)
+/* added style to allow for in-place composition, such as "dead" keys for accents */
+#define IN_PLACE_STYLES (XIMPreeditNothing | XIMStatusNone)
+
+#define PreeditStartIndex 0
+#define PreeditDoneIndex 1
+#define PreeditDrawIndex 2
+#define PreeditCaretIndex 3
+#define StatusStartIndex 4
+#define StatusDoneIndex 5
+#define StatusDrawIndex 6
+#define NCALLBACKS 7
+
+#define STATUS_BORDER 2 /* Status Border width */
+#define CARET_OFFSET 1 /* Offset of caret position (pixel) */
+#define BORDER_MARGIN 3 /* BORDER MARGIN width */
+#define STATUS_MARGIN 7 /* Margin between the status window and its parent window */
+#define PREEDIT_ATTR_MASK (XIMReverse|XIMUnderline)
+ /* Preedit attribute which host adapter can handle */
+
+/*
+ * Callback function pointers: the order has to match the *Index
+ * values above.
+ */
+static XIMProc callback_funcs[NCALLBACKS] = {
+ (XIMProc)PreeditStartCallback,
+ (XIMProc)PreeditDoneCallback,
+ (XIMProc)PreeditDrawCallback,
+ (XIMProc)PreeditCaretCallback,
+ (XIMProc)StatusStartCallback,
+ (XIMProc)StatusDoneCallback,
+ (XIMProc)StatusDrawCallback,
+};
+
+#define MAX_STATUS_LEN 100
+typedef struct {
+ Window w; /*status window id */
+ Window root; /*the root window id */
+ Window parent; /*parent shell window */
+ Window grandParent; /*window has WM frame */
+ int x, y; /*parent's upperleft position */
+ int width, height; /*parent's width, height */
+ GC lightGC; /*gc for light border */
+ GC dimGC; /*gc for dim border */
+ GC bgGC; /*normal painting */
+ GC fgGC; /*normal painting */
+ int statusW, statusH; /*status window's w, h */
+ int rootW, rootH; /*root window's w, h */
+ int bWidth; /*border width */
+ wchar_t status[MAX_STATUS_LEN + 1]; /*status text */
+ XFontSet fontset; /*fontset for drawing */
+ int off_x, off_y;
+ Bool on; /*if the status window on*/
+ int fOff; /* font base line(in pixel) from top */
+ int fBot; /* font bottom line(in pixel) from top */
+ int peTextW; /* Composition text width in pixel */
+ wchar_t* peText; /* Composed string (wide char.) */
+ XIMFeedback* peAttr; /* Composed text attribute */
+ int peCaret; /* Caret position in number of character */
+ Bool status_ready; /* Not draw Status at XCreateIC */
+} StatusWindow;
+
+/*
+ * X11InputMethodData keeps per X11InputMethod instance information. A pointer
+ * to this data structure is kept in an X11InputMethod object (pData).
+ */
+typedef struct _X11InputMethodData {
+ XIC current_ic; /* current X Input Context */
+ XIC ic_active; /* X Input Context for active clients */
+ XIC ic_passive; /* X Input Context for passive clients */
+ XIMCallback *callbacks; /* callback parameters */
+ jobject x11inputmethod; /* global ref to X11InputMethod instance */
+ /* associated with the XIC */
+ StatusWindow *statusWindow; /* our own status window */
+ Bool passiveStatusWindow;/* Passive Client uses StatusWindow */
+ Bool isActiveClient; /* True:clinet is active */
+ Bool forceReset; /* True: call resetXIC before UnsetICFocus */
+} X11InputMethodData;
+
+/* reference to the current X11InputMethod instance, it is always
+ point to the global reference to the X11InputMethodObject since
+ it could be referenced by different threads. */
+jobject currentX11InputMethodInstance = NULL;
+
+Window currentFocusWindow = 0; /* current window that has focus for input
+ method. (the best place to put this
+ information should be
+ currentX11InputMethodInstance's pData) */
+static XIM X11im = NULL;
+Display * dpy = NULL;
+
+#define GetJNIEnv() (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2)
+
+static X11InputMethodData * getX11InputMethodData(JNIEnv *, jobject);
+static void setX11InputMethodData(JNIEnv *, jobject, X11InputMethodData *);
+static void destroyX11InputMethodData(JNIEnv *, X11InputMethodData *);
+static void freeX11InputMethodData(JNIEnv *, X11InputMethodData *);
+
+/* Prototype for this function is missing in AIX Xlib.h */
+extern char *XSetIMValues(
+#if NeedVarargsPrototypes
+ XIM /* im */, ...
+#endif
+);
+
+static int st_wcslen(wchar_t *string);
+static Bool isPreeditStateActive(XIC ic);
+static void * buf_insert(void * src, void * insert, int size,
+ int src_len, int ins_len, int offset);
+static void * handle_buffer(void * source, void * insert,
+ int size, int src_len, int ins_len,
+ int del_len, int offset);
+static void preedit_draw_passive(X11InputMethodData *pX11IMData,
+ XIMPreeditDrawCallbackStruct *pre_draw);
+static void resetPassivePreeditText(StatusWindow *statusWindow);
+static void draw_caret(StatusWindow *statusWindow, GC gc, int pos);
+static int get_next_attr(int len, unsigned long *attr);
+static void draw_preedit(StatusWindow *statusWindow);
+static void align_status(StatusWindow *statusWindow);
+static void shrink_status(StatusWindow *statusWindow);
+static GC create_gc(Window win, Bool isReverse);
+static XFontSet create_fontset(void);
+static Bool is_text_available(XIMText * text);
+static Bool isNativeIm();
+static Window getGrandParent(Window parent);
+static void moveStatusWindow(StatusWindow *statusWindow);
+static void arrange_window_stack(StatusWindow* statusWindow);
+static Window get_current_focus(XIC ic);
+
+/*
+ * This function is stolen from /src/solaris/hpi/src/system_md.c
+ * It is used in setting the time in Java-level InputEvents
+ */
+jlong
+awt_util_nowMillisUTC()
+{
+ struct timeval t;
+ gettimeofday(&t, NULL);
+ return ((jlong)t.tv_sec) * 1000 + (jlong)(t.tv_usec/1000);
+}
+
+/*
+ * Converts the wchar_t string to a multi-byte string calling wcstombs(). A
+ * buffer is allocated by malloc() to store the multi-byte string. NULL is
+ * returned if the given wchar_t string pointer is NULL or buffer allocation is
+ * failed.
+ */
+static char *
+wcstombsdmp(wchar_t *wcs, int len)
+{
+ size_t n;
+ char *mbs;
+
+ if (wcs == NULL)
+ return NULL;
+
+ n = len*MB_CUR_MAX + 1;
+
+ mbs = (char *) malloc(n * sizeof(char));
+ if (mbs == NULL) {
+ THROW_OUT_OF_MEMORY_ERROR();
+ return NULL;
+ }
+
+ /* TODO: check return values... Handle invalid characters properly... */
+ if (wcstombs(mbs, wcs, n) == (size_t)-1) {
+ free(mbs);
+ return NULL;
+ }
+
+ return mbs;
+}
+
+static X11InputMethodData * getX11InputMethodData(JNIEnv * env, jobject imInstance) {
+ X11InputMethodData *pX11IMData =
+ (X11InputMethodData *)JNU_GetLongFieldAsPtr(env, imInstance, x11InputMethodIDs.pData);
+
+ /*
+ * In case the XIM server was killed somehow, reset X11InputMethodData.
+ */
+ if (X11im == NULL && pX11IMData != NULL) {
+ JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,
+ "flushText",
+ "()V");
+ JNU_CHECK_EXCEPTION_RETURN(env, NULL);
+ /* IMPORTANT:
+ The order of the following calls is critical since "imInstance" may
+ point to the global reference itself, if "freeX11InputMethodData" is called
+ first, the global reference will be destroyed and "setX11InputMethodData"
+ will in fact fail silently. So pX11IMData will not be set to NULL.
+ This could make the original java object refers to a deleted pX11IMData
+ object.
+ */
+ setX11InputMethodData(env, imInstance, NULL);
+ freeX11InputMethodData(env, pX11IMData);
+ pX11IMData = NULL;
+ }
+
+ return pX11IMData;
+}
+
+static void setX11InputMethodData(JNIEnv * env, jobject imInstance, X11InputMethodData *pX11IMData) {
+ JNU_SetLongFieldFromPtr(env, imInstance, x11InputMethodIDs.pData, pX11IMData);
+}
+
+/* this function should be called within AWT_LOCK() */
+static void
+destroyX11InputMethodData(JNIEnv *env, X11InputMethodData *pX11IMData)
+{
+ /*
+ * Destroy XICs
+ */
+ if (pX11IMData == NULL) {
+ return;
+ }
+
+ if (pX11IMData->ic_active != (XIC)0) {
+ XUnsetICFocus(pX11IMData->ic_active);
+ XDestroyIC(pX11IMData->ic_active);
+ if (pX11IMData->ic_active != pX11IMData->ic_passive) {
+ if (pX11IMData->ic_passive != (XIC)0) {
+ XUnsetICFocus(pX11IMData->ic_passive);
+ XDestroyIC(pX11IMData->ic_passive);
+ }
+ pX11IMData->ic_passive = (XIC)0;
+ pX11IMData->current_ic = (XIC)0;
+ }
+ }
+
+ freeX11InputMethodData(env, pX11IMData);
+}
+
+static void
+freeX11InputMethodData(JNIEnv *env, X11InputMethodData *pX11IMData)
+{
+ if (pX11IMData->statusWindow != NULL){
+ StatusWindow *sw = pX11IMData->statusWindow;
+ XFreeGC(awt_display, sw->lightGC);
+ XFreeGC(awt_display, sw->dimGC);
+ XFreeGC(awt_display, sw->bgGC);
+ XFreeGC(awt_display, sw->fgGC);
+ if (sw->fontset != NULL) {
+ XFreeFontSet(awt_display, sw->fontset);
+ }
+ XDestroyWindow(awt_display, sw->w);
+ if (pX11IMData->statusWindow->peText){
+ free((void *)pX11IMData->statusWindow->peText);
+ pX11IMData->statusWindow->peText = NULL;
+ }
+ if (pX11IMData->statusWindow->peAttr){
+ free((void *)pX11IMData->statusWindow->peAttr);
+ pX11IMData->statusWindow->peAttr = NULL;
+ }
+ free((void*)sw);
+ }
+
+ if (pX11IMData->callbacks)
+ free((void *)pX11IMData->callbacks);
+
+ if (env) {
+ (*env)->DeleteGlobalRef(env, pX11IMData->x11inputmethod);
+ }
+
+ free((void *)pX11IMData);
+}
+
+/*
+ * Sets or unsets the focus to the given XIC.
+ */
+static void
+setXICFocus(XIC ic, unsigned short req)
+{
+ if (ic == NULL) {
+ (void)fprintf(stderr, "Couldn't find X Input Context\n");
+ return;
+ }
+ if (req == 1)
+ XSetICFocus(ic);
+ else
+ XUnsetICFocus(ic);
+}
+
+/*
+ * Sets the focus window to the given XIC.
+ */
+static void
+setXICWindowFocus(XIC ic, Window w)
+{
+ if (ic == NULL) {
+ (void)fprintf(stderr, "Couldn't find X Input Context\n");
+ return;
+ }
+ (void) XSetICValues(ic, XNFocusWindow, w, NULL);
+}
+
+/*
+ * Invokes XmbLookupString() to get something from the XIM. It invokes
+ * X11InputMethod.dispatchCommittedText() if XmbLookupString() returns
+ * committed text. This function is called from handleKeyEvent in canvas.c and
+ * it's under the Motif event loop thread context.
+ *
+ * Buffer usage: There is a bug in XFree86-4.3.0 XmbLookupString implementation,
+ * where it never returns XBufferOverflow. We need to allocate the initial lookup buffer
+ * big enough, so that the possibility that user encounters this problem is relatively
+ * small. When this bug gets fixed, we can make the initial buffer size smaller.
+ * Note that XmbLookupString() sometimes produces a non-null-terminated string.
+ *
+ * Returns True when there is a keysym value to be handled.
+ */
+#define INITIAL_LOOKUP_BUF_SIZE 512
+
+Boolean
+awt_x11inputmethod_lookupString(XKeyPressedEvent *event, KeySym *keysymp)
+{
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData = NULL;
+ int buf_len = INITIAL_LOOKUP_BUF_SIZE;
+ char mbbuf[INITIAL_LOOKUP_BUF_SIZE];
+ char *buf;
+ KeySym keysym = NoSymbol;
+ Status status;
+ int mblen;
+ jstring javastr;
+ XIC ic;
+ Boolean result = True;
+ static Boolean composing = False;
+
+ /*
+ printf("lookupString: entering...\n");
+ */
+
+ pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance);
+
+ if (pX11IMData == NULL) {
+ return False;
+ }
+
+ if ((ic = pX11IMData->current_ic) == (XIC)0){
+ return False;
+ }
+
+ buf = mbbuf;
+ mblen = XmbLookupString(ic, event, buf,
+ buf_len - 1, &keysym, &status);
+
+ /*
+ * In case of overflow, a buffer is allocated and it retries
+ * XmbLookupString().
+ */
+ if (status == XBufferOverflow) {
+ buf_len = mblen + 1;
+ buf = (char *)malloc(buf_len);
+ if (buf == NULL) {
+ THROW_OUT_OF_MEMORY_ERROR();
+ return result;
+ }
+ mblen = XmbLookupString(ic, event, buf, buf_len, &keysym, &status);
+ }
+ buf[mblen] = 0;
+
+ /* Get keysym without taking modifiers into account first to map
+ * to AWT keyCode table.
+ */
+ switch (status) {
+ case XLookupBoth:
+ if (!composing) {
+ if (event->keycode != 0) {
+ *keysymp = keysym;
+ result = False;
+ break;
+ }
+ }
+ composing = False;
+ /*FALLTHRU*/
+ case XLookupChars:
+ /*
+ printf("lookupString: status=XLookupChars, type=%d, state=%x, keycode=%x, keysym=%x\n",
+ event->type, event->state, event->keycode, keysym);
+ */
+ javastr = JNU_NewStringPlatform(env, (const char *)buf);
+ if (javastr != NULL) {
+ JNU_CallMethodByName(env, NULL,
+ currentX11InputMethodInstance,
+ "dispatchCommittedText",
+ "(Ljava/lang/String;J)V",
+ javastr,
+ event->time);
+ if ((*env)->ExceptionOccurred(env)) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->ExceptionClear(env);
+ }
+ }
+ break;
+
+ case XLookupKeySym:
+ /*
+ printf("lookupString: status=XLookupKeySym, type=%d, state=%x, keycode=%x, keysym=%x\n",
+ event->type, event->state, event->keycode, keysym);
+ */
+ if (keysym == XK_Multi_key)
+ composing = True;
+ if (! composing) {
+ *keysymp = keysym;
+ result = False;
+ }
+ break;
+
+ case XLookupNone:
+ /*
+ printf("lookupString: status=XLookupNone, type=%d, state=%x, keycode=%x, keysym=%x\n",
+ event->type, event->state, event->keycode, keysym);
+ */
+ break;
+ }
+
+ if (buf != mbbuf) {
+ free(buf);
+ }
+ return result;
+}
+
+static StatusWindow *createStatusWindow(Window parent) {
+ StatusWindow *statusWindow;
+ XSetWindowAttributes attrib;
+ unsigned long attribmask;
+ Window containerWindow;
+ Window status;
+ Window child;
+ XWindowAttributes xwa;
+ XWindowAttributes xxwa;
+ /* Variable for XCreateFontSet()*/
+ char **mclr;
+ int mccr = 0;
+ char *dsr;
+ unsigned long bg, fg, light, dim;
+ int x, y, off_x, off_y, xx, yy;
+ unsigned int w, h, bw, depth;
+ XGCValues values;
+ unsigned long valuemask = 0; /*ignore XGCvalue and use defaults*/
+ int screen = 0;
+ int i;
+ AwtGraphicsConfigDataPtr adata;
+ extern int awt_numScreens;
+ /*hardcode the size right now, should get the size base on font*/
+ int width=80, height=22;
+ Window rootWindow;
+ Window *ignoreWindowPtr;
+ unsigned int ignoreUnit;
+ Window grandParent;
+ Window target;
+ XFontSet fontset;
+
+ fontset = create_fontset();
+ if (NULL == fontset) {
+ return NULL;
+ }
+
+ XGetGeometry(dpy, parent, &rootWindow, &x, &y, &w, &h, &bw, &depth);
+
+ attrib.override_redirect = True;
+ attribmask = CWOverrideRedirect;
+ for (i = 0; i < awt_numScreens; i++) {
+ if (RootWindow(dpy, i) == rootWindow) {
+ screen = i;
+ break;
+ }
+ }
+ adata = getDefaultConfig(screen);
+ bg = adata->AwtColorMatch(255, 255, 255, adata);
+ fg = adata->AwtColorMatch(0, 0, 0, adata);
+ light = adata->AwtColorMatch(195, 195, 195, adata);
+ dim = adata->AwtColorMatch(128, 128, 128, adata);
+
+ grandParent = getGrandParent(parent);
+ target = (grandParent == 0) ? parent : grandParent;
+ XGetWindowAttributes(dpy, target, &xwa);
+ bw = 2; /*xwa.border_width does not have the correct value*/
+
+ /*compare the size difference between parent container
+ and shell widget, the diff should be the border frame
+ and title bar height (?)*/
+
+ XQueryTree( dpy,
+ target,
+ &rootWindow,
+ &containerWindow,
+ &ignoreWindowPtr,
+ &ignoreUnit);
+ XGetWindowAttributes(dpy, containerWindow, &xxwa);
+
+ XTranslateCoordinates(dpy,
+ target, xwa.root,
+ 0, 0,
+ &x, &y, &child);
+
+ if (containerWindow == rootWindow) {
+ off_x = 0; off_y = STATUS_MARGIN;
+ } else {
+ XGetWindowAttributes(dpy, containerWindow, &xxwa);
+ off_x = (xxwa.width - xwa.width) / 2;
+ /* off_y = xxwa.height - xwa.height - off_x;*/ /*it's magic:-) */
+ {
+ int cx, cy;
+ XTranslateCoordinates(dpy,
+ containerWindow, xxwa.root,
+ 0, 0,
+ &cx, &cy,
+ &child);
+ off_y = (xxwa.height + cy) - (xwa.height + y);
+ }
+ }
+
+ /*get the size of root window*/
+ XGetWindowAttributes(dpy, rootWindow, &xxwa);
+
+ XTranslateCoordinates(dpy,
+ target, xwa.root,
+ xwa.x, xwa.y,
+ &x, &y,
+ &child);
+ xx = x - off_x;
+ yy = y + xwa.height - off_y;
+ if (xx < 0 ){
+ xx = 0;
+ }
+ if (xx + width > xxwa.width) {
+ xx = xxwa.width - width;
+ }
+ if (yy + height > xxwa.height) {
+ yy = xxwa.height - height;
+ }
+
+ if ((DefaultVisual(dpy,screen))->class != adata->awt_visInfo.visual->class &&
+ adata->awt_visInfo.visual->class == TrueColor) {
+ attrib.colormap = XCreateColormap(dpy, xwa.root,
+ adata->awt_visInfo.visual, AllocNone );
+ attrib.border_pixel = BlackPixel(dpy, screen) ;
+ attribmask |= CWColormap | CWBorderPixel;
+ }
+
+ status = XCreateWindow(dpy,
+ xwa.root,
+ xx, yy,
+ width, height,
+ 0,
+ xwa.depth,
+ InputOutput,
+ adata->awt_visInfo.visual,
+ attribmask, &attrib);
+ XSelectInput(dpy, status,
+ ExposureMask | StructureNotifyMask | EnterWindowMask |
+ LeaveWindowMask | VisibilityChangeMask);
+ if (grandParent != 0){
+ long mask;
+ XGetWindowAttributes(dpy, grandParent, &xwa);
+ mask = xwa.your_event_mask | StructureNotifyMask |
+ VisibilityChangeMask | PropertyChangeMask;
+ XSelectInput(dpy, grandParent,mask);
+ }
+
+ statusWindow = (StatusWindow*) calloc(1, sizeof(StatusWindow));
+ if (statusWindow == NULL){
+ THROW_OUT_OF_MEMORY_ERROR();
+ return NULL;
+ }
+ statusWindow->w = status;
+ statusWindow->fontset = fontset;
+ statusWindow->parent = parent;
+ statusWindow->grandParent = grandParent;
+ statusWindow->on = False;
+ statusWindow->x = x;
+ statusWindow->y = y;
+ statusWindow->width = xwa.width;
+ statusWindow->height = xwa.height;
+ statusWindow->off_x = off_x;
+ statusWindow->off_y = off_y;
+ statusWindow->bWidth = bw;
+ statusWindow->statusH = height;
+ statusWindow->statusW = width;
+ statusWindow->peTextW = 0;
+ statusWindow->rootH = xxwa.height;
+ statusWindow->rootW = xxwa.width;
+ statusWindow->lightGC = XCreateGC(dpy, status, valuemask, &values);
+ XSetForeground(dpy, statusWindow->lightGC, light);
+ statusWindow->dimGC = XCreateGC(dpy, status, valuemask, &values);
+ XSetForeground(dpy, statusWindow->dimGC, dim);
+ statusWindow->fgGC = create_gc(status, FALSE);
+ XSetForeground(dpy, statusWindow->fgGC, fg);
+ statusWindow->bgGC = create_gc(status, TRUE);
+ XSetForeground(dpy, statusWindow->bgGC, bg);
+ statusWindow->status_ready = False;
+ wcscpy(statusWindow->status, L"");
+ return statusWindow;
+}
+
+/* This method is to turn off or turn on the status window. */
+static void onoffStatusWindow(X11InputMethodData* pX11IMData,
+ Window parent,
+ Bool ON){
+ XWindowAttributes xwa;
+ Window child;
+ int x, y;
+ StatusWindow *statusWindow = NULL;
+
+ if (NULL == pX11IMData ||
+ NULL == (statusWindow = pX11IMData->statusWindow)){
+ return;
+ }
+
+ if (ON == False) {
+ XUnmapWindow(dpy, statusWindow->w);
+ return;
+ }
+ if (NULL == currentX11InputMethodInstance){
+ return;
+ }
+ {
+ JNIEnv *env = GetJNIEnv();
+ parent = JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,
+ "getCurrentParentWindow",
+ "()J").j;
+ if ((*env)->ExceptionOccurred(env)) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->ExceptionClear(env);
+ }
+ }
+ if (statusWindow->parent != parent) {
+ statusWindow->parent = parent;
+ }
+ if (st_wcslen(statusWindow->status) > 0 ||
+ (statusWindow->peText != NULL && st_wcslen(statusWindow->peText) > 0 )) {
+ moveStatusWindow(statusWindow);
+ XMapRaised(dpy, statusWindow->w);
+ }
+}
+
+void paintStatusWindow(StatusWindow *statusWindow){
+ Window win = statusWindow->w;
+ GC lightgc = statusWindow->lightGC;
+ GC dimgc = statusWindow->dimGC;
+ GC bggc = statusWindow->bgGC;
+ GC fggc = statusWindow->fgGC;
+
+ int width = statusWindow->statusW;
+ int height = statusWindow->statusH;
+ int bwidth = statusWindow->bWidth;
+ int len;
+ XRectangle logical, ink;
+
+ if (NULL == statusWindow) return;
+ if ((len = st_wcslen(statusWindow->status)) == 0) {
+ return;
+ }
+ XwcTextExtents(statusWindow->fontset, statusWindow->status,
+ len, &ink, &logical);
+ width = logical.width;
+ height = logical.height;
+
+ XFillRectangle(dpy, win, bggc, 0, 0, width+2, height+2);
+
+ XDrawLine(dpy, win, fggc, 0, 0, width+2, 0);
+ XDrawLine(dpy, win, fggc, 0, height+2, width+2, height+2);
+ XDrawLine(dpy, win, fggc, 0, 0, 0, height+2);
+ XDrawLine(dpy, win, fggc, width+2, 0, width+2, height+2);
+
+ if (statusWindow->fontset) {
+ XwcDrawString(dpy, win, statusWindow->fontset, fggc,
+ -logical.x + 1, -logical.y + 1,
+ statusWindow->status,
+ st_wcslen(statusWindow->status));
+ } else {
+ /*too bad we failed to create a fontset for this locale*/
+ XDrawString(dpy, win, fggc, bwidth + 2, height - bwidth - 4,
+ "[InputMethod ON]", strlen("[InputMethod ON]"));
+ }
+}
+
+Bool statusWindowEventHandler(XEvent event) {
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData = NULL;
+ StatusWindow *statusWindow;
+
+ if (NULL == currentX11InputMethodInstance ||
+ NULL == (pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance)) ||
+ NULL == (statusWindow = pX11IMData->statusWindow))
+ {
+ return False;
+ }
+
+ if (statusWindow->w == event.xany.window) {
+ switch (event.type) {
+ case Expose:
+ paintStatusWindow(statusWindow);
+ if (statusWindow->peText)
+ draw_preedit(statusWindow);
+ arrange_window_stack(statusWindow);
+ break;
+ case ConfigureNotify:
+ case VisibilityNotify:
+ arrange_window_stack(statusWindow);
+ break;
+ /*
+ case UnmapNotify:
+ case VisibilityNotify:
+ break;
+ */
+ default:
+ break;
+ }
+ return True;
+ } else if ((statusWindow->parent == event.xany.window) ||
+ (statusWindow->grandParent && statusWindow->grandParent == event.xany.window)) {
+ switch (event.type) {
+ case MapNotify:
+ if (statusWindow->on) {
+ onoffStatusWindow(pX11IMData, statusWindow->parent, True);
+ }
+ break;
+ case UnmapNotify:
+ onoffStatusWindow(pX11IMData, 0, False);
+ break;
+ case VisibilityNotify:
+ if (statusWindow->on) {
+ arrange_window_stack(statusWindow);
+ }
+ break;
+ case ConfigureNotify:
+ if (statusWindow->grandParent && statusWindow->on) {
+ moveStatusWindow(statusWindow);
+ }
+ case PropertyNotify:
+ if (statusWindow->on) {
+ arrange_window_stack(statusWindow);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return False;
+}
+
+static void adjustStatusWindow(Window shell) {
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData = NULL;
+ StatusWindow *statusWindow;
+
+ if (NULL == currentX11InputMethodInstance
+ || NULL == (pX11IMData = getX11InputMethodData(env,currentX11InputMethodInstance))
+ || NULL == (statusWindow = pX11IMData->statusWindow)
+ || !statusWindow->on)
+ {
+ return;
+ }
+
+ moveStatusWindow(statusWindow);
+}
+
+/*
+ * Creates two XICs, one for active clients and the other for passive
+ * clients. All information on those XICs are stored in the
+ * X11InputMethodData given by the pX11IMData parameter.
+ *
+ * For active clients: Try to use preedit callback to support
+ * on-the-spot. If tc is not null, the XIC to be created will
+ * share the Status Area with Motif widgets (TextComponents). If the
+ * preferable styles can't be used, fallback to root-window styles. If
+ * root-window styles failed, fallback to None styles.
+ *
+ * For passive clients: Try to use root-window styles. If failed,
+ * fallback to None styles.
+ */
+static Bool
+createXIC(JNIEnv * env, X11InputMethodData *pX11IMData, Window w)
+{
+ XVaNestedList preedit = NULL;
+ XVaNestedList status = NULL;
+ XIMStyle on_the_spot_styles = XIMPreeditCallbacks,
+ in_place_styles = 0,
+ active_styles = 0,
+ passive_styles = 0,
+ no_styles = 0;
+ XIMCallback *callbacks;
+ unsigned short i;
+ XIMStyles *im_styles;
+ char *ret = NULL;
+ Bool passiveStatusWindow = False;
+ pX11IMData->statusWindow = NULL;
+
+ if (X11im == NULL) {
+ return False;
+ }
+ if (!w) {
+ return False;
+ }
+
+ if (getenv("IBMJAVA_PASSIVE") == NULL) {
+ passiveStatusWindow = False;
+ } else {
+ passiveStatusWindow = True;
+ }
+
+ if (isNativeIm()) { passiveStatusWindow = True; }
+
+ ret = XGetIMValues(X11im, XNQueryInputStyle, &im_styles, NULL);
+
+ if (ret != NULL) {
+ jio_fprintf(stderr,"XGetIMValues: %s\n",ret);
+ return FALSE ;
+ }
+
+ on_the_spot_styles |= XIMStatusNothing;
+
+ /*kinput does not support XIMPreeditCallbacks and XIMStatusArea
+ at the same time, so use StatusCallback to draw the status
+ ourself
+ */
+ for (i = 0; i < im_styles->count_styles; i++) {
+ if (im_styles->supported_styles[i] == (XIMPreeditCallbacks | XIMStatusCallbacks)) {
+ on_the_spot_styles = (XIMPreeditCallbacks | XIMStatusCallbacks);
+ break;
+ }
+ }
+
+ for (i = 0; i < im_styles->count_styles; i++) {
+ if (im_styles->supported_styles[i] == on_the_spot_styles)
+ active_styles = im_styles->supported_styles[i];
+ if (im_styles->supported_styles[i] == ROOT_WINDOW_STYLES)
+ passive_styles = im_styles->supported_styles[i];
+ if (im_styles->supported_styles[i] == IN_PLACE_STYLES) {
+ in_place_styles = im_styles->supported_styles[i];
+ }
+ if (im_styles->supported_styles[i] == NO_STYLES) {
+ no_styles = im_styles->supported_styles[i];
+ }
+ }
+
+ XFree(im_styles);
+
+ if (active_styles != on_the_spot_styles) {
+ if (passive_styles == ROOT_WINDOW_STYLES)
+ active_styles = passive_styles;
+ else {
+ if (in_place_styles == IN_PLACE_STYLES){
+ active_styles = passive_styles = IN_PLACE_STYLES;
+ } else {
+ if (no_styles == NO_STYLES)
+ active_styles = passive_styles = NO_STYLES;
+ else
+ active_styles = passive_styles = 0;
+ }
+ }
+ } else {
+ if (!passiveStatusWindow) {
+ if (passive_styles != ROOT_WINDOW_STYLES) {
+ if (no_styles == NO_STYLES)
+ active_styles = passive_styles = NO_STYLES;
+ else
+ active_styles = passive_styles = 0;
+ }
+ } else
+ passive_styles = active_styles;
+ }
+
+ if (active_styles == on_the_spot_styles) {
+ callbacks = (XIMCallback *)malloc(sizeof(XIMCallback) * NCALLBACKS);
+ if (callbacks == (XIMCallback *)NULL)
+ return False;
+ pX11IMData->callbacks = callbacks;
+
+ for (i = 0; i < NCALLBACKS; i++, callbacks++) {
+ callbacks->client_data = (XPointer) pX11IMData->x11inputmethod;
+ callbacks->callback = callback_funcs[i];
+ }
+
+ callbacks = pX11IMData->callbacks;
+ preedit = (XVaNestedList)XVaCreateNestedList(0,
+ XNPreeditStartCallback, &callbacks[PreeditStartIndex],
+ XNPreeditDoneCallback, &callbacks[PreeditDoneIndex],
+ XNPreeditDrawCallback, &callbacks[PreeditDrawIndex],
+ XNPreeditCaretCallback, &callbacks[PreeditCaretIndex],
+ NULL);
+ if (preedit == (XVaNestedList)NULL)
+ goto err;
+ /*always try XIMStatusCallbacks for active client...*/
+ {
+ if (on_the_spot_styles & XIMStatusCallbacks) {
+ status = (XVaNestedList)XVaCreateNestedList(0,
+ XNStatusStartCallback, &callbacks[StatusStartIndex],
+ XNStatusDoneCallback, &callbacks[StatusDoneIndex],
+ XNStatusDrawCallback, &callbacks[StatusDrawIndex],
+ NULL);
+
+ if (status == NULL)
+ goto err;
+ }
+ pX11IMData->statusWindow = createStatusWindow(w);
+ pX11IMData->ic_active = XCreateIC(X11im,
+ XNClientWindow, w,
+ XNFocusWindow, w,
+ XNInputStyle, active_styles,
+ XNPreeditAttributes, preedit,
+ XNStatusAttributes, status,
+ NULL);
+ if (NULL != pX11IMData->statusWindow) {
+ pX11IMData->statusWindow->status_ready = True;
+ }
+ XFree((void *)status);
+ XFree((void *)preedit);
+ }
+ if (passiveStatusWindow) {
+ pX11IMData->ic_passive = pX11IMData->ic_active;
+ } else {
+ pX11IMData->ic_passive = XCreateIC(X11im,
+ XNClientWindow, w,
+ XNFocusWindow, w,
+ XNInputStyle, passive_styles,
+ NULL);
+ }
+ } else {
+ pX11IMData->ic_active = XCreateIC(X11im,
+ XNClientWindow, w,
+ XNFocusWindow, w,
+ XNInputStyle, active_styles,
+ NULL);
+ pX11IMData->ic_passive = pX11IMData->ic_active;
+ }
+
+ // The code set the IC mode that the preedit state is not initialied
+ // at XmbResetIC. This attribute can be set at XCreateIC. I separately
+ // set the attribute to avoid the failure of XCreateIC at some platform
+ // which does not support the attribute.
+ if (pX11IMData->ic_active != 0)
+ XSetICValues(pX11IMData->ic_active,
+ XNResetState, XIMPreserveState, NULL);
+ if (pX11IMData->ic_passive != 0 &&
+ pX11IMData->ic_active != pX11IMData->ic_passive)
+ XSetICValues(pX11IMData->ic_passive,
+ XNResetState, XIMInitialState, NULL);
+
+ pX11IMData->passiveStatusWindow = passiveStatusWindow;
+
+ if (pX11IMData->ic_active == (XIC)0
+ || pX11IMData->ic_passive == (XIC)0) {
+ return False;
+ }
+
+ /* Unset focus to avoid unexpected IM on */
+ setXICFocus(pX11IMData->ic_active, False);
+ if (pX11IMData->ic_active != pX11IMData->ic_passive)
+ setXICFocus(pX11IMData->ic_passive, False);
+
+ return True;
+
+ err:
+ if (preedit)
+ XFree((void *)preedit);
+ THROW_OUT_OF_MEMORY_ERROR();
+ return False;
+}
+
+static int
+PreeditStartCallback(XIC ic, XPointer client_data, XPointer call_data)
+{
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData;
+
+ pX11IMData = getX11InputMethodData(env, (jobject)client_data);
+ if (pX11IMData == NULL || pX11IMData->statusWindow == NULL) {
+ return 0;
+ }
+ resetPassivePreeditText(pX11IMData->statusWindow);
+
+ return -1; /* unlimited length for preedit text */
+}
+
+static void
+PreeditDoneCallback(XIC ic, XPointer client_data, XPointer call_data)
+{
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData;
+
+ pX11IMData = getX11InputMethodData(env, (jobject)client_data);
+ if (pX11IMData == NULL) {
+ return;
+ }
+
+ if (!pX11IMData->isActiveClient) {
+ resetPassivePreeditText(pX11IMData->statusWindow);
+ shrink_status(pX11IMData->statusWindow);
+ }
+ else{
+ JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,
+ "clearComposedText",
+ "(J)V",
+ awt_util_nowMillisUTC());
+ if ((*env)->ExceptionOccurred(env)) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->ExceptionClear(env);
+ }
+ }
+}
+
+/*
+ * Translate the preedit draw callback items to Java values and invoke
+ * X11InputMethod.dispatchComposedText().
+ *
+ * client_data: X11InputMethod object
+ */
+static void
+PreeditDrawCallback(XIC ic, XPointer client_data,
+ XIMPreeditDrawCallbackStruct *pre_draw)
+{
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData = NULL;
+ jmethodID x11imMethodID;
+
+ XIMText *text;
+ jstring javastr = NULL;
+ jintArray style = NULL;
+
+ /* printf("Native: PreeditDrawCallback() \n"); */
+ if (pre_draw == NULL) {
+ return;
+ }
+ AWT_LOCK();
+ if ((pX11IMData = getX11InputMethodData(env, (jobject)client_data)) == NULL) {
+ goto finally;
+ }
+
+ if (!pX11IMData->isActiveClient){
+ if (ic == pX11IMData->ic_passive) {
+ preedit_draw_passive(pX11IMData, pre_draw);
+ }
+ goto finally;
+ }
+
+ if ((text = pre_draw->text) != NULL) {
+ if (is_text_available(text)) {
+ if (text->string.multi_byte != NULL) {
+ if (pre_draw->text->encoding_is_wchar == False) {
+ javastr = JNU_NewStringPlatform(env, (const char *)text->string.multi_byte);
+ if (javastr == NULL) {
+ goto finally;
+ }
+ } else {
+ char *mbstr = wcstombsdmp(text->string.wide_char, text->length);
+ if (mbstr == NULL) {
+ goto finally;
+ }
+ javastr = JNU_NewStringPlatform(env, (const char *)mbstr);
+ free(mbstr);
+ if (javastr == NULL) {
+ goto finally;
+ }
+ }
+ }
+ }
+ if (text->feedback != NULL) {
+ int cnt;
+ jint *tmpstyle;
+
+ style = (*env)->NewIntArray(env, text->length);
+ if (JNU_IsNull(env, style)) {
+ (*env)->ExceptionClear(env);
+ THROW_OUT_OF_MEMORY_ERROR();
+ goto finally;
+ }
+
+ if (sizeof(XIMFeedback) == sizeof(jint)) {
+ /*
+ * Optimization to avoid copying the array
+ */
+ (*env)->SetIntArrayRegion(env, style, 0,
+ text->length, (jint *)text->feedback);
+ } else {
+ tmpstyle = (jint *)malloc(sizeof(jint)*(text->length));
+ if (tmpstyle == (jint *) NULL) {
+ THROW_OUT_OF_MEMORY_ERROR();
+ goto finally;
+ }
+ for (cnt = 0; cnt < (int)text->length; cnt++)
+ tmpstyle[cnt] = text->feedback[cnt];
+ (*env)->SetIntArrayRegion(env, style, 0,
+ text->length, (jint *)tmpstyle);
+ }
+ }
+ }
+ JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,
+ "dispatchComposedText",
+ "(Ljava/lang/String;[IIIIJ)V",
+ javastr,
+ style,
+ (jint)pre_draw->chg_first,
+ (jint)pre_draw->chg_length,
+ (jint)pre_draw->caret,
+ awt_util_nowMillisUTC());
+
+ if ((*env)->ExceptionOccurred(env)) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->ExceptionClear(env);
+ }
+
+finally:
+ AWT_UNLOCK();
+ return;
+}
+
+static void
+PreeditCaretCallback(XIC ic, XPointer client_data,
+ XIMPreeditCaretCallbackStruct *pre_caret)
+{
+ XIMPreeditDrawCallbackStruct pre_draw;
+
+ if (pre_caret != NULL && pre_caret->direction == XIMAbsolutePosition) {
+ pre_draw.caret = pre_caret->position;
+ pre_draw.chg_first = 0;
+ pre_draw.chg_length = 0;
+ pre_draw.text = NULL;
+ PreeditDrawCallback(ic, client_data, &pre_draw);
+ }
+}
+
+static void
+StatusStartCallback(XIC ic, XPointer client_data, XPointer call_data)
+{
+ /*ARGSUSED*/
+ /*printf("StatusStartCallback:\n"); */
+}
+
+static void
+StatusDoneCallback(XIC ic, XPointer client_data, XPointer call_data)
+{
+ /*ARGSUSED*/
+ /*printf("StatusDoneCallback:\n"); */
+}
+
+static void StatusDrawCallback
+ (XIC ic, XPointer client_data, XIMStatusDrawCallbackStruct *status_draw)
+{
+ /*ARGSUSED*/
+ /*printf("StatusDrawCallback:\n"); */
+ JNIEnv *env = GetJNIEnv();
+ X11InputMethodData *pX11IMData = NULL;
+ StatusWindow *statusWindow;
+ int value_make = CWX|CWWidth|CWHeight;
+ XRectangle logical, ink;
+ XWindowChanges xwc;
+ int len;
+
+ AWT_LOCK();
+
+ if (NULL == (pX11IMData = getX11InputMethodData(env, (jobject)client_data))
+ || NULL == (statusWindow = pX11IMData->statusWindow)){
+ goto finally;
+ }
+
+ if (status_draw->type == XIMTextType) {
+ XIMText *text = (status_draw->data).text;
+ if (text != NULL) {
+ if (text->string.multi_byte != NULL) {
+ if(!strcmp(text->string.multi_byte," ")){
+ wcscpy(statusWindow->status, L"");
+ onoffStatusWindow(pX11IMData, 0, False);
+ goto finally;
+ }
+ mbstowcs(statusWindow->status,
+ (const char *)text->string.multi_byte,
+ (size_t)MAX_STATUS_LEN);
+ } else {
+ if (0 == st_wcslen(text->string.wide_char)){
+ wcscpy(statusWindow->status, L"");
+ onoffStatusWindow(pX11IMData, 0, False);
+ goto finally;
+ }
+ wcsncpy(statusWindow->status,
+ text->string.wide_char,
+ MAX_STATUS_LEN);
+ }
+ XwcTextExtents(statusWindow->fontset, statusWindow->status,
+ st_wcslen(statusWindow->status), &ink, &logical);
+ statusWindow->statusW = logical.width + BORDER_MARGIN;
+ statusWindow->statusH = logical.height + BORDER_MARGIN;
+ xwc.x = statusWindow->x - statusWindow->off_x;
+ if (xwc.x < 0 ) xwc.x = 0;
+ xwc.width = statusWindow->statusW;
+ xwc.height = statusWindow->statusH;
+ if (xwc.x + xwc.width > statusWindow->rootW){
+ xwc.x = statusWindow->rootW - xwc.width;
+ }
+ XConfigureWindow(dpy, statusWindow->w, value_make, &xwc);
+ if (statusWindow->status_ready && statusWindow->on == True){
+ onoffStatusWindow(pX11IMData, statusWindow->parent, True);
+ }
+ paintStatusWindow(statusWindow);
+ if (statusWindow->peText)
+ draw_preedit(statusWindow);
+ }
+ else {
+ wcscpy(statusWindow->status, L"");
+ /*just turnoff the status window
+ paintStatusWindow(statusWindow);
+ */
+ onoffStatusWindow(pX11IMData, 0, False);
+ }
+ }
+
+ finally:
+ AWT_UNLOCK();
+}
+
+/* return the string length without trailing spaces */
+/* work around code for Japanese AIXIM is implemented. */
+static int st_wcslen(wchar_t *string)
+{
+ int len = (int32_t)wcslen(string);
+ if (len == 0)
+ return 0;
+ for (len--;len >= 0; len--) {
+ if (!iswspace((wint_t) string[len])) break;
+ }
+ return len+1;
+}
+
+/*
+ * Checks whether given XIMText contains a string data.
+ */
+static Bool is_text_available(XIMText * text)
+{
+ if (text == NULL || text->length==0)
+ return False;
+ if (text->encoding_is_wchar) {
+ if(text->string.wide_char[0] == L'\0')
+ return False;
+ } else {
+ if (text->string.multi_byte[0] == '\0')
+ return False;
+ }
+ return True;
+}
+
+/*
+ * check if preedit status is active
+*/
+static Bool isPreeditStateActive(XIC ic)
+{
+ XIMPreeditState state = XIMPreeditUnKnown;
+ XVaNestedList pr_atrb;
+ char* nosupportAttr;
+
+ if (ic == NULL) return False;
+
+ pr_atrb = XVaCreateNestedList(0,XNPreeditState,&state,NULL);
+ nosupportAttr=XGetICValues(ic,XNPreeditAttributes,pr_atrb,NULL);
+ XFree(pr_atrb);
+ if (nosupportAttr==NULL && state & XIMPreeditDisable)
+ return False;
+ else
+ return True;
+}
+
+static void * buf_insert(void * src, void * insert, int size,
+ int src_len, int ins_len, int offset)
+{
+ char *temp;
+
+ temp = realloc(src, size*(src_len+ins_len+1));
+ if (temp == NULL) {
+ THROW_OUT_OF_MEMORY_ERROR();
+ return src;
+ }
+ if (offset != src_len) {
+ memmove(&temp[size*(offset+ins_len)],
+ &((char *)temp)[size*offset],
+ size*(src_len-offset));
+ }
+ memcpy(&temp[size*offset], insert, size*ins_len);
+
+ return (void *)temp;
+}
+
+static void * handle_buffer(void * source, void * insert,
+ int size,int src_len, int ins_len,
+ int del_len, int offset)
+{
+ void * temp = source;
+
+ if (del_len > 0) {
+ if (del_len == ins_len) {
+ memcpy(&((char *)source)[size*offset], insert, size*ins_len);
+ return source;
+ }
+ else if (src_len > offset+del_len) {
+ memmove(&((char *)source)[size*offset],
+ &((char *)source)[size*(offset+del_len)],
+ size*(src_len-offset-del_len));
+ }
+ }
+ if (ins_len > 0) {
+ temp = buf_insert(source, insert, size, src_len,
+ ins_len, offset);
+ }
+ return temp;
+}
+/*
+ * Display the given preedit text to the root window which is ownd by
+ * myself. All of the character is converted to wide char.
+ * this function is used for the passive client.
+ */
+static void preedit_draw_passive(X11InputMethodData *pX11IMData,
+ XIMPreeditDrawCallbackStruct *pre_draw)
+{
+ XIMText *text;
+ wchar_t *tempbuf = NULL;
+ StatusWindow *statusWindow;
+ wchar_t *cur_text;
+ unsigned long *cur_attr;
+ int cur_len = 0;
+ int chg_len = pre_draw->chg_length;
+ int chg_1st = pre_draw->chg_first;
+
+ if (NULL == (statusWindow = pX11IMData->statusWindow))
+ return;
+ cur_text = statusWindow->peText;
+ cur_attr = statusWindow->peAttr;
+ if (cur_text == NULL && pre_draw->text == NULL)
+ return;
+
+ if (cur_text != NULL)
+ cur_len = (int32_t)wcslen(cur_text);
+ text = pre_draw->text;
+ if (text == NULL) {
+ /* delete only */
+ if (cur_len > chg_1st+chg_len) {
+ memmove(&cur_text[chg_1st],
+ &cur_text[chg_1st+chg_len],
+ sizeof(wchar_t)*(cur_len-chg_1st-chg_len));
+ memmove(&cur_attr[chg_1st],
+ &cur_attr[chg_1st+chg_len],
+ sizeof(long)*(cur_len-chg_1st-chg_len));
+ }
+ if ((pre_draw->chg_length <= cur_len ) && (pre_draw->chg_length >0))
+ cur_text[cur_len-pre_draw->chg_length] =L'\0';
+ } else {
+ /* insert or replace */
+ int ins_len = 0;
+ void * ins_text = NULL;
+
+ /* if invalid offset is specified, do nothing. */
+ /* this fix is for aixim for eucTW */
+ if (cur_len < chg_1st)
+ return;
+ if(is_text_available(text)) {
+ /* insert or replace the text */
+ if (text->encoding_is_wchar == False) {
+ /* convert the text to wide chars.
+ allocate enough size buffer
+ */
+ tempbuf = (wchar_t *)malloc(sizeof(wchar_t)*(text->length+1));
+ if (tempbuf == NULL) {
+ THROW_OUT_OF_MEMORY_ERROR();
+ return;
+ }
+ ins_len = (int32_t)mbstowcs(tempbuf, text->string.multi_byte,
+ text->length);
+ if (ins_len == -1) {
+ free(tempbuf);
+ return;
+ }
+ ins_text = (void *)tempbuf;
+ }
+ else {
+ ins_len = text->length;
+ ins_text = text->string.wide_char;
+ }
+ /* finish prepare the data to be inserted */
+
+ statusWindow->peText =
+ handle_buffer(cur_text, ins_text, sizeof(wchar_t),
+ cur_len, ins_len, chg_len, chg_1st);
+ statusWindow->peAttr =
+ handle_buffer(cur_attr, text->feedback, sizeof(long),
+ cur_len, ins_len, chg_len, chg_1st);
+ statusWindow->peText[cur_len-chg_len+ins_len] =L'\0';
+
+ if (tempbuf != NULL)
+ free(tempbuf);
+ } /* endof insert or replace text */
+ else {
+ /* change attribute only */
+ memcpy(&cur_attr[chg_1st], text->feedback,
+ sizeof(long)*text->length);
+ }
+ }
+ statusWindow->peCaret= pre_draw->caret;
+ draw_preedit(statusWindow);
+ if (statusWindow->on && wcslen(statusWindow->peText) > 0)
+ onoffStatusWindow(pX11IMData, statusWindow->parent, True);
+ else if (wcslen(statusWindow->status) == 0)
+ onoffStatusWindow(pX11IMData, 0, False);
+}
+
+/*
+ * reset predit test of passive mode
+ */
+static void
+resetPassivePreeditText(StatusWindow *statusWindow)
+{
+ if (NULL == statusWindow) return;
+ if(statusWindow->peText != NULL) {
+ free(statusWindow->peText);
+ statusWindow->peText = NULL;
+ }
+ if(statusWindow->peAttr != NULL) {
+ free(statusWindow->peAttr);
+ statusWindow->peAttr = NULL;
+ }
+ statusWindow->peCaret= 0;
+}
+
+static void draw_caret(StatusWindow *statusWindow, GC gc, int pos)
+{
+ if (NULL == statusWindow) return;
+ XSetFunction(dpy, gc, GXinvert);
+ XDrawLine(dpy, statusWindow->w,
+ gc, pos, STATUS_BORDER/2,
+ pos, STATUS_BORDER/2+statusWindow->fOff);
+ XSetFunction(dpy, gc, GXcopy);
+}
+
+static int get_next_attr(int len, unsigned long *attr)
+{
+ int count;
+
+ for (count = 1; count < len; count++) {
+ if ((attr[count-1] & PREEDIT_ATTR_MASK)
+ != (attr[count] & PREEDIT_ATTR_MASK))
+ break;
+ }
+ return count;
+}
+
+static void draw_preedit(StatusWindow *statusWindow)
+{
+ unsigned long *attr;
+ int x_pos,x_caret;
+ unsigned int len;
+ int len_disp, pos;
+ wchar_t *str;
+ GC gc;
+ XRectangle ink, rect, rect_c;
+ Bool caret_done = False;
+
+ if (NULL == statusWindow) return;
+ align_status(statusWindow);
+ XFillRectangle(dpy, statusWindow->w,
+ statusWindow->bgGC,
+ statusWindow->statusW,0,
+ statusWindow->statusW + statusWindow->peTextW + BORDER_MARGIN,
+ statusWindow->fBot+2);
+
+
+ XDrawLine(dpy, statusWindow->w, statusWindow->fgGC,
+ statusWindow->statusW, 0,
+ statusWindow->statusW + statusWindow->peTextW + BORDER_MARGIN, 0);
+ XDrawLine(dpy, statusWindow->w, statusWindow->fgGC,
+ statusWindow->statusW, statusWindow->fBot+2,
+ statusWindow->statusW + statusWindow->peTextW + BORDER_MARGIN,
+ statusWindow->fBot+2);
+ XDrawLine(dpy, statusWindow->w, statusWindow->fgGC,
+ statusWindow->statusW + statusWindow->peTextW + BORDER_MARGIN, 0,
+ statusWindow->statusW + statusWindow->peTextW + BORDER_MARGIN,
+ statusWindow->fBot+2);
+ if (0 == statusWindow->statusW)
+ XDrawLine(dpy, statusWindow->w, statusWindow->fgGC,
+ 0, 0, 0, statusWindow->fBot+2);
+
+ str = statusWindow->peText;
+
+ if (str != NULL && (len = (int32_t)wcslen(str)) != 0) {
+ pos = 0;
+ attr = statusWindow->peAttr;
+ x_pos = x_caret = statusWindow->statusW + STATUS_BORDER;
+ while((int)len-1 >= pos) {
+ len_disp = get_next_attr(len - pos, &attr[pos]);
+ if (attr[pos] & XIMReverse) {
+ gc = statusWindow->bgGC;
+ }
+ else {
+ gc = statusWindow->fgGC;
+ }
+ XwcTextExtents(statusWindow->fontset,
+ &str[pos],
+ len_disp, &ink, &rect);
+ XwcDrawImageString(dpy, statusWindow->w,
+ statusWindow->fontset, gc,
+ x_pos, statusWindow->fOff+1, &str[pos], len_disp);
+ if (attr[pos] & XIMUnderline) {
+ XDrawLine(dpy, statusWindow->w,
+ gc, x_pos, statusWindow->fBot,
+ x_pos+rect.width, statusWindow->fBot);
+ }
+ if (!caret_done) {
+ if( statusWindow->peCaret >= pos &&
+ statusWindow->peCaret <= pos+len_disp) {
+ if (statusWindow->peCaret == 0)
+ x_caret = x_pos;
+ else if (statusWindow->peCaret == pos+len_disp)
+ x_caret = x_pos+rect.width;
+ else {
+ XwcTextExtents(statusWindow->fontset,
+ &str[pos],
+ statusWindow->peCaret-pos,
+ &ink, &rect_c);
+ x_caret = x_pos+ rect_c.width;
+ }
+ x_caret-=CARET_OFFSET;
+ caret_done = True;
+ }
+ }
+ pos += len_disp;
+ x_pos += rect.width;
+ }
+ if (caret_done)
+ draw_caret(statusWindow, statusWindow->fgGC, x_caret);
+ }
+}
+
+/* calc required status window size and resize the window */
+static void align_status(StatusWindow *statusWindow)
+{
+ int len_st, len_pe = 0;
+ XRectangle rect_st, rect_pe, ink;
+ Dimension cur_w;
+ int value_make = CWX|CWWidth|CWHeight;
+ XWindowChanges xwc;
+
+ if (NULL == statusWindow) return;
+ if ((len_st = st_wcslen(statusWindow->status)) == 0
+ && (statusWindow->peText == NULL || st_wcslen(statusWindow->peText) == 0 ))
+ return;
+
+ rect_pe.x = rect_pe.y = rect_pe.width = rect_pe.height = 0;
+
+ XwcTextExtents(statusWindow->fontset,
+ statusWindow->status,
+ len_st, &ink, &rect_st);
+ if (statusWindow->peText != NULL
+ && (len_pe = (int32_t)wcslen(statusWindow->peText)) > 0) {
+ XwcTextExtents(statusWindow->fontset,
+ statusWindow->peText,
+ len_pe, &ink, &rect_pe);
+ }
+ statusWindow->fOff = max(-rect_st.y, -rect_pe.y);
+ statusWindow->fBot = max(rect_st.height, rect_pe.height);
+ statusWindow->statusW =rect_st.width;
+ if (rect_st.width > 0) statusWindow->statusW += BORDER_MARGIN;
+ statusWindow->peTextW = rect_pe.width;
+
+ xwc.x = statusWindow->x - statusWindow->off_x;
+ if (xwc.x < 0 ) xwc.x = 0;
+
+ if (len_pe > 0) {
+ xwc.width = statusWindow->statusW
+ + statusWindow->peTextW + BORDER_MARGIN + 1;
+ xwc.height = statusWindow->fBot + BORDER_MARGIN;
+ } else {
+ xwc.width = statusWindow->statusW;
+ xwc.height = statusWindow->fBot + BORDER_MARGIN;
+ }
+ if (xwc.x + xwc.width > statusWindow->rootW){
+ xwc.x = statusWindow->rootW - xwc.width;
+ }
+ XConfigureWindow(dpy, statusWindow->w, value_make, &xwc);
+}
+
+static void shrink_status(StatusWindow *statusWindow)
+{
+ int value_make = CWX|CWWidth|CWHeight;
+ XWindowChanges xwc;
+
+ if (NULL == statusWindow) return;
+ xwc.width = statusWindow->statusW;
+ xwc.height = statusWindow->statusH;
+ statusWindow->peTextW = 0;
+ xwc.x = statusWindow->x - statusWindow->off_x;
+ if (xwc.x < 0 ) xwc.x = 0;
+ if (xwc.x + xwc.width > statusWindow->rootW){
+ xwc.x = statusWindow->rootW - xwc.width;
+ }
+ XConfigureWindow(dpy, statusWindow->w, value_make, &xwc);
+}
+
+static GC create_gc(Window win, Bool isReverse)
+{
+ XGCValues xgcv;
+ unsigned long mask;
+ AwtScreenDataPtr defaultScreen;
+
+ defaultScreen = getScreenData(DefaultScreen(dpy));
+
+ mask = (GCForeground | GCBackground );
+ if (isReverse) {
+ xgcv.foreground = defaultScreen->whitepixel;
+ xgcv.background = defaultScreen->blackpixel;
+ } else {
+ xgcv.foreground = defaultScreen->blackpixel;
+ xgcv.background = defaultScreen->whitepixel;
+ }
+ return XCreateGC(dpy, win, mask, &xgcv);
+}
+
+static Bool isNativeIm()
+{
+#define XIMMODIFIER "@im="
+#define XIM_SERVER_CATEGORY "@server="
+ char *immodifiers;
+ char *imserver, *imserverPtr;
+ Atom imserverAtom;
+
+ if (!(immodifiers = getenv("XMODIFIERS"))) return True;
+ if (!(imserver = calloc(1,strlen(immodifiers)+strlen(XIM_SERVER_CATEGORY)+1))) return True;
+ if (!(immodifiers = strstr(immodifiers,XIMMODIFIER))) return True;
+ immodifiers += strlen(XIMMODIFIER);
+ strcpy(imserver,XIM_SERVER_CATEGORY);
+ imserverPtr = imserver + strlen(imserver);
+ while(*immodifiers != '@' && *immodifiers != '\0') {
+ *imserverPtr = *immodifiers;
+ imserverPtr++;
+ immodifiers++;
+ }
+ imserverAtom = XInternAtom(awt_display, imserver, True);
+ free(imserver);
+ if (imserverAtom > 0)
+ return False;
+ else
+ return True;
+}
+
+static Window getGrandParent(Window parent)
+{
+ Window containerWindow,rootWindow,tmp;
+ Window *ignoreWindowPtr;
+ unsigned int ignoreUnit;
+ Window grandParent=0;
+ XWindowAttributes xwa;
+ Atom WM_STATE;
+ Atom type = None;
+ int32_t format;
+ unsigned long nitems, after;
+ unsigned char * data;
+
+ if (parent == 0) return grandParent;
+ WM_STATE = XInternAtom(dpy, "WM_STATE", True);
+ if (WM_STATE == None) return grandParent;
+
+ tmp=parent;
+ while(XQueryTree(dpy, tmp,
+ &rootWindow, &containerWindow,
+ &ignoreWindowPtr, &ignoreUnit)){
+ XFree(ignoreWindowPtr);
+ if (containerWindow == rootWindow) break;
+ if (XGetWindowProperty(dpy, containerWindow, WM_STATE,
+ 0, 0, False, AnyPropertyType,
+ &type, &format, &nitems, &after, &data) == Success) {
+ XFree(data);
+ if (type) {
+ XGetWindowAttributes(dpy, containerWindow, &xwa);
+ if (FALSE == xwa.override_redirect){
+ grandParent=containerWindow;
+ }
+ }
+ }
+ tmp=containerWindow;
+ }
+ return grandParent;
+}
+
+static void moveStatusWindow(StatusWindow *statusWindow)
+{
+ XWindowAttributes xwa;
+ Window child;
+ int x, y, width;
+ Window target;
+
+ if (NULL == statusWindow) return;
+ if (statusWindow->grandParent) {
+ target = statusWindow->grandParent;
+ } else {
+ target = statusWindow->parent;
+ }
+ XGetWindowAttributes(dpy, target, &xwa);
+ XTranslateCoordinates(dpy,
+ target, xwa.root,
+ 0, 0,
+ &x, &y,
+ &child);
+ if (statusWindow->x != x
+ || statusWindow->y != y
+ || statusWindow->width != xwa.width
+ || statusWindow->height != xwa.height){
+ statusWindow->x = x;
+ statusWindow->y = y;
+ statusWindow->height = xwa.height;
+ statusWindow->width = xwa.width;
+ x = statusWindow->x - statusWindow->off_x;
+ y = statusWindow->y + statusWindow->height + statusWindow->off_y;
+ if (x < 0 ){
+ x = 0;
+ }
+ if (statusWindow->peTextW > 0) {
+ width = statusWindow->statusW + statusWindow->peTextW + BORDER_MARGIN + 1;
+ if (x + width > statusWindow->rootW){
+ x = statusWindow->rootW - width;
+ }
+ } else {
+ if (x + statusWindow->statusW > statusWindow->rootW){
+ x = statusWindow->rootW - statusWindow->statusW;
+ }
+ }
+ if (y + statusWindow->statusH > statusWindow->rootH){
+ y = statusWindow->rootH - statusWindow->statusH;
+ }
+ XMoveWindow(dpy, statusWindow->w, x, y);
+ }
+}
+
+static void arrange_window_stack(StatusWindow* statusWindow)
+{
+ XWindowChanges xwc;
+ int value_make = CWSibling|CWStackMode;
+ Window root, parent, *children;
+ unsigned int nchildren;
+
+ if (NULL == statusWindow) return;
+ if (XQueryTree(dpy, statusWindow->parent,
+ &root, &parent, &children, &nchildren)){
+ XFree(children);
+ xwc.sibling = parent;
+ while(XQueryTree(dpy, xwc.sibling, &root, &parent, &children, &nchildren)) {
+ XFree(children);
+ if (root != parent) {
+ xwc.sibling = parent;
+ } else {
+ break;
+ }
+ }
+ xwc.stack_mode = Above;
+ XConfigureWindow(dpy, statusWindow->w, value_make, &xwc);
+ }
+}
+
+static int count_missing_fonts(char **charset_list, int charset_count)
+{
+ int i,j;
+ if (charset_count > 0) {
+ j=charset_count;
+ for(i=0; i < charset_count; i++) {
+ if ((strstr(charset_list[i], "IBM-udc")) ||
+ (strstr(charset_list[i], "IBM-sbd")) ||
+ (strstr(charset_list[i], "IBM-ucdTW")))
+ j--;
+ }
+ return j;
+ }
+ else
+ return 0;
+}
+
+static XFontSet create_fontset_name(char * font_name, Bool force)
+{
+ XFontSet fontset = NULL;
+ char **charset_list;
+ int charset_count;
+ char *def_string;
+ int missing_fonts;
+
+ fontset = XCreateFontSet(dpy, font_name,
+ &charset_list, &charset_count, &def_string);
+ if (charset_count > 0) {
+ missing_fonts = count_missing_fonts(charset_list,
+ charset_count);
+ XFreeStringList(charset_list);
+ if (fontset && (missing_fonts > 0)) {
+ if (!force) {
+ XFreeFontSet(dpy, fontset);
+ fontset = NULL;
+ }
+ }
+ }
+ return fontset;
+}
+
+static XFontSet create_fontset()
+{
+ XFontSet fontset = NULL;
+ int i;
+ static char * fontlist[] = {
+ "-dt-interface user-medium-r-normal-S*-*-*-*-*-*-*-*-*",
+ "-*-*-medium-r-normal-*-14-*-*-*-c-*-*-*",
+ "-*-*-medium-r-normal-*-14-*-*-*-m-*-*-*",
+ "-*-*-medium-r-normal--14-0-0-0-m-*-*-*",
+ "-monotype-sansmonowt-medium-r-normal--14-*-*-*-m-*-*-*",
+ "-*--14-*",
+ "-dt-interface user-medium-r-normal-s*-*-*-*-*-*-*-*-*",
+ "-*--16-*",
+ "-*--17-*",
+ "-*--18-*",
+ "-*--19-*",
+ "-*--20-*",
+ "-*--24-*",
+ NULL};
+
+ for (i=0; fontlist[i] != NULL && fontset==NULL; i++)
+ fontset = create_fontset_name(fontlist[i], False);
+
+ if (!fontset)
+ fprintf(stdout, "Cannot load fonts for IMF.\n");
+ return fontset;
+}
+
+static Window get_current_focus(XIC ic) {
+ Window w = 0;
+ if (ic != NULL)
+ XGetICValues(ic, XNFocusWindow, &w, NULL);
+ return w;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_awt_X11_XInputMethod_openXIMNative(JNIEnv *env,
+ jobject this,
+ jlong display)
+{
+ Bool registered;
+
+ AWT_LOCK();
+
+ dpy = (Display *)jlong_to_ptr(display);
+
+ if (X11im == NULL) {
+ X11im = XOpenIM(dpy, NULL, NULL, NULL);
+ }
+
+ AWT_UNLOCK();
+
+ return JNI_TRUE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_awt_X11_XInputMethod_createXICNative(JNIEnv *env,
+ jobject this,
+ jlong window)
+{
+ X11InputMethodData *pX11IMData;
+ jobject globalRef;
+ XIC ic;
+
+ AWT_LOCK();
+
+ if (!window) {
+ JNU_ThrowNullPointerException(env, "NullPointerException");
+ AWT_UNLOCK();
+ return JNI_FALSE;
+ }
+
+ pX11IMData = (X11InputMethodData *) calloc(1, sizeof(X11InputMethodData));
+ if (pX11IMData == NULL) {
+ THROW_OUT_OF_MEMORY_ERROR();
+ AWT_UNLOCK();
+ return JNI_FALSE;
+ }
+
+ globalRef = (*env)->NewGlobalRef(env, this);
+ pX11IMData->x11inputmethod = globalRef;
+ pX11IMData->statusWindow = NULL;
+
+ setX11InputMethodData(env, this, pX11IMData);
+
+ if (createXIC(env, pX11IMData, (Window)window) == False) {
+ destroyX11InputMethodData((JNIEnv *) NULL, pX11IMData);
+ pX11IMData = (X11InputMethodData *) NULL;
+ setX11InputMethodData(env, this, pX11IMData);
+ if ((*env)->ExceptionCheck(env)) {
+ goto finally;
+ }
+ }
+
+finally:
+ AWT_UNLOCK();
+ return (pX11IMData != NULL);
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_X11_XInputMethod_setXICFocusNative(JNIEnv *env,
+ jobject this,
+ jlong w,
+ jboolean req,
+ jboolean active)
+{
+ X11InputMethodData *pX11IMData;
+ AWT_LOCK();
+ pX11IMData = getX11InputMethodData(env, this);
+ if (pX11IMData == NULL) {
+ AWT_UNLOCK();
+ return;
+ }
+
+ if (req) {
+ if (!w) {
+ AWT_UNLOCK();
+ return;
+ }
+ pX11IMData->isActiveClient = active;
+ pX11IMData->current_ic = active ?
+ pX11IMData->ic_active : pX11IMData->ic_passive;
+ /*
+ * On Solaris2.6, setXICWindowFocus() has to be invoked
+ * before setting focus.
+ */
+ get_current_focus(pX11IMData->current_ic); /* workaround for kinput2 and SCIM */
+ if (currentFocusWindow != w) {
+ setXICWindowFocus(pX11IMData->current_ic, w);
+ setXICFocus(pX11IMData->current_ic, req);
+ currentX11InputMethodInstance = pX11IMData->x11inputmethod;
+ currentFocusWindow = w;
+ } else {
+ setXICFocus(pX11IMData->current_ic, req);
+ }
+ if ((active || pX11IMData->passiveStatusWindow)
+ && (pX11IMData->statusWindow && pX11IMData->statusWindow->on))
+ onoffStatusWindow(pX11IMData, w, True);
+ } else {
+ currentX11InputMethodInstance = NULL;
+ currentFocusWindow = 0;
+ onoffStatusWindow(pX11IMData, 0, False);
+ if (pX11IMData->current_ic != NULL)
+ setXICFocus(pX11IMData->current_ic, req);
+
+ pX11IMData->current_ic = (XIC)0;
+ }
+
+ XFlush(dpy);
+ AWT_UNLOCK();
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: initIDs
+ * Signature: ()V
+ * This function gets called from the static initializer for
+ * X11InputMethod.java to initialize the fieldIDs for fields
+ * that may be accessed from C
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethodBase_initIDs
+ (JNIEnv *env, jclass cls)
+{
+ x11InputMethodIDs.pData = (*env)->GetFieldID(env, cls, "pData", "J");
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: turnoffStatusWindow
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethodBase_turnoffStatusWindow
+ (JNIEnv *env, jobject this)
+{
+ X11InputMethodData *pX11IMData;
+ StatusWindow *statusWindow;
+
+ AWT_LOCK();
+
+ if (NULL == currentX11InputMethodInstance
+ || NULL == (pX11IMData = getX11InputMethodData(env,currentX11InputMethodInstance))
+ || NULL == (statusWindow = pX11IMData->statusWindow)
+ || !statusWindow->on ){
+ AWT_UNLOCK();
+ return;
+ }
+ onoffStatusWindow(pX11IMData, 0, False);
+ statusWindow->on = False;
+
+ AWT_UNLOCK();
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: disposeXIC
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethodBase_disposeXIC
+ (JNIEnv *env, jobject this)
+{
+ X11InputMethodData *pX11IMData = NULL;
+
+ AWT_LOCK();
+ pX11IMData = getX11InputMethodData(env, this);
+ if (pX11IMData == NULL) {
+ AWT_UNLOCK();
+ return;
+ }
+
+ setX11InputMethodData(env, this, NULL);
+
+ if (pX11IMData->x11inputmethod == currentX11InputMethodInstance) {
+ currentX11InputMethodInstance = NULL;
+ currentFocusWindow = 0;
+ }
+ destroyX11InputMethodData(env, pX11IMData);
+ AWT_UNLOCK();
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: resetXIC
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_sun_awt_X11InputMethodBase_resetXIC
+ (JNIEnv *env, jobject this)
+{
+ X11InputMethodData *pX11IMData;
+ char *xText = NULL;
+ jstring jText = (jstring)0;
+
+ AWT_LOCK();
+ pX11IMData = getX11InputMethodData(env, this);
+ if (pX11IMData == NULL) {
+ AWT_UNLOCK();
+ return jText;
+ }
+
+ if (pX11IMData->current_ic) {
+ if (!isPreeditStateActive(pX11IMData->current_ic)) {
+ xText = NULL;
+ } else {
+ if (!(pX11IMData->forceReset))
+ setXICFocus(pX11IMData->current_ic, FALSE);
+ xText = XmbResetIC(pX11IMData->current_ic);
+ if (!(pX11IMData->forceReset))
+ setXICFocus(pX11IMData->current_ic, TRUE);
+ }
+ } else {
+ /*
+ * If there is no reference to the current XIC, try to reset both XICs.
+ */
+ if (!isPreeditStateActive(pX11IMData->ic_active))
+ xText = NULL;
+ else
+ xText = XmbResetIC(pX11IMData->ic_active);
+ /*it may also means that the real client component does
+ not have focus -- has been deactivated... its xic should
+ not have the focus, bug#4284651 showes reset XIC for htt
+ may bring the focus back, so de-focus it again.
+ */
+ setXICFocus(pX11IMData->ic_active, FALSE);
+ if (pX11IMData->ic_active != pX11IMData->ic_passive) {
+ char *tmpText;
+ if (!isPreeditStateActive(pX11IMData->ic_passive))
+ tmpText = NULL;
+ else
+ tmpText = XmbResetIC(pX11IMData->ic_passive);
+ setXICFocus(pX11IMData->ic_passive, FALSE);
+ if (xText == (char *)NULL && tmpText)
+ xText = tmpText;
+ }
+ }
+ if (xText != NULL) {
+ jText = JNU_NewStringPlatform(env, (const char *)xText);
+ XFree((void *)xText);
+ }
+
+ /* workaround
+ * Some IME do not call PreeditDoneCallback routine even
+ * when XmbResetIC is called. I force to reset the preedit string.
+ */
+ if (!pX11IMData->isActiveClient) {
+ resetPassivePreeditText(pX11IMData->statusWindow);
+ shrink_status(pX11IMData->statusWindow);
+ } else {
+ JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,
+ "clearComposedText",
+ "()V");
+ if ((*env)->ExceptionOccurred(env)) {
+ (*env)->ExceptionDescribe(env);
+ (*env)->ExceptionClear(env);
+ }
+ }
+
+ AWT_UNLOCK();
+ return jText;
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: setCompositionEnabledNative
+ * Signature: (Z)Z
+ *
+ * This method tries to set the XNPreeditState attribute associated with the current
+ * XIC to the passed in 'enable' state.
+ *
+ * Return JNI_TRUE if XNPreeditState attribute is successfully changed to the
+ * 'enable' state; Otherwise, if XSetICValues fails to set this attribute,
+ * java.lang.UnsupportedOperationException will be thrown. JNI_FALSE is returned if this
+ * method fails due to other reasons.
+ */
+JNIEXPORT jboolean JNICALL Java_sun_awt_X11InputMethodBase_setCompositionEnabledNative
+ (JNIEnv *env, jobject this, jboolean enable)
+{
+ X11InputMethodData *pX11IMData;
+ char * ret = NULL;
+ XVaNestedList pr_atrb;
+
+ AWT_LOCK();
+ pX11IMData = getX11InputMethodData(env, this);
+
+ if ((pX11IMData == NULL) || (pX11IMData->current_ic == NULL)) {
+ AWT_UNLOCK();
+ return JNI_FALSE;
+ }
+
+ pr_atrb = XVaCreateNestedList(0, XNPreeditState,
+ (enable ? XIMPreeditEnable : XIMPreeditDisable), NULL);
+ ret = XSetICValues(pX11IMData->current_ic, XNPreeditAttributes, pr_atrb, NULL);
+ XFree((void *)pr_atrb);
+ AWT_UNLOCK();
+
+ if ((ret != 0) &&
+ ((strcmp(ret, XNPreeditAttributes) == 0)
+ || (strcmp(ret, XNPreeditState) == 0))) {
+ JNU_ThrowByName(env, "java/lang/UnsupportedOperationException", "");
+ }
+
+ return (jboolean)(ret == 0);
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: isCompositionEnabledNative
+ * Signature: ()Z
+ *
+ * This method tries to get the XNPreeditState attribute associated with the current XIC.
+ *
+ * Return JNI_TRUE if the XNPreeditState is successfully retrieved. Otherwise, if
+ * XGetICValues fails to get this attribute, java.lang.UnsupportedOperationException
+ * will be thrown. JNI_FALSE is returned if this method fails due to other reasons.
+ */
+JNIEXPORT jboolean JNICALL Java_sun_awt_X11InputMethodBase_isCompositionEnabledNative
+ (JNIEnv *env, jobject this)
+{
+ X11InputMethodData *pX11IMData = NULL;
+ char * ret = NULL;
+ XIMPreeditState state = XIMPreeditUnKnown;
+ XVaNestedList pr_atrb;
+
+ AWT_LOCK();
+ pX11IMData = getX11InputMethodData(env, this);
+
+ if ((pX11IMData == NULL) || (pX11IMData->current_ic == NULL)) {
+ AWT_UNLOCK();
+ return JNI_FALSE;
+ }
+
+ pr_atrb = XVaCreateNestedList(0, XNPreeditState, &state, NULL);
+ ret = XGetICValues(pX11IMData->current_ic, XNPreeditAttributes, pr_atrb, NULL);
+ XFree((void *)pr_atrb);
+ AWT_UNLOCK();
+
+ if ((ret != 0) &&
+ ((strcmp(ret, XNPreeditAttributes) == 0)
+ || (strcmp(ret, XNPreeditState) == 0))) {
+ JNU_ThrowByName(env, "java/lang/UnsupportedOperationException", "");
+ return JNI_FALSE;
+ }
+
+ return (jboolean)(state == XIMPreeditEnable);
+}
+
+JNIEXPORT void JNICALL Java_sun_awt_X11_XInputMethod_adjustStatusWindow
+ (JNIEnv *env, jobject this, jlong window)
+{
+
+}
+
+/*
+ * Class: sun_awt_X11InputMethod
+ * Method: setStatusAreaVisible
+ * Signature: (ZJ)V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethod_setStatusAreaVisible
+ (JNIEnv *env, jobject this, jboolean value, jlong data)
+{
+ X11InputMethodData *pX11IMData;
+
+ pX11IMData = getX11InputMethodData(env, this);
+ if (NULL == pX11IMData) return;
+ if (NULL == pX11IMData->statusWindow) return;
+
+ if ((int)value){
+ pX11IMData->statusWindow->on = True;
+ }else{
+ pX11IMData->statusWindow->on = False;
+ }
+ return;
+}
--- a/src/java.desktop/unix/classes/sun/awt/X11InputMethod.java Tue May 29 11:22:21 2018 -0700
+++ b/src/java.desktop/unix/classes/sun/awt/X11InputMethod.java Wed May 30 08:19:59 2018 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, 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
@@ -25,147 +25,21 @@
package sun.awt;
-import java.util.Collections;
-import java.util.Locale;
-import java.util.Map;
-import java.util.HashMap;
-import java.awt.AWTEvent;
import java.awt.AWTException;
-import java.awt.Component;
-import java.awt.Container;
-import java.awt.EventQueue;
-import java.awt.Window;
-import java.awt.im.InputMethodHighlight;
-import java.awt.im.spi.InputMethodContext;
-import sun.awt.im.InputMethodAdapter;
import java.awt.event.InputMethodEvent;
import java.awt.font.TextAttribute;
import java.awt.font.TextHitInfo;
import java.awt.peer.ComponentPeer;
-import java.lang.Character.Subset;
import java.text.AttributedString;
-import java.text.AttributedCharacterIterator;
-import java.io.File;
-import java.io.FileReader;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.lang.ref.WeakReference;
import sun.util.logging.PlatformLogger;
-import java.util.StringTokenizer;
-import java.util.regex.Pattern;
-
/**
* Input Method Adapter for XIM
*
* @author JavaSoft International
*/
-public abstract class X11InputMethod extends InputMethodAdapter {
- private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11InputMethod");
- /*
- * The following XIM* values must be the same as those defined in
- * Xlib.h
- */
- private static final int XIMReverse = (1<<0);
- private static final int XIMUnderline = (1<<1);
- private static final int XIMHighlight = (1<<2);
- private static final int XIMPrimary = (1<<5);
- private static final int XIMSecondary = (1<<6);
- private static final int XIMTertiary = (1<<7);
-
- /*
- * visible position values
- */
- private static final int XIMVisibleToForward = (1<<8);
- private static final int XIMVisibleToBackward = (1<<9);
- private static final int XIMVisibleCenter = (1<<10);
- private static final int XIMVisibleMask = (XIMVisibleToForward|
- XIMVisibleToBackward|
- XIMVisibleCenter);
-
- private Locale locale;
- private static boolean isXIMOpened = false;
- protected Container clientComponentWindow = null;
- private Component awtFocussedComponent = null;
- private Component lastXICFocussedComponent = null;
- private boolean isLastXICActive = false;
- private boolean isLastTemporary = false;
- private boolean isActive = false;
- private boolean isActiveClient = false;
- private static Map<TextAttribute, ?>[] highlightStyles;
- private boolean disposed = false;
-
- //reset the XIC if necessary
- private boolean needResetXIC = false;
- private WeakReference<Component> needResetXICClient = new WeakReference<>(null);
-
- // 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.
- // these variables need to be accessed within AWT_LOCK/UNLOCK
- private String committedText = null;
- private StringBuffer composedText = null;
- private IntBuffer rawFeedbacks;
-
- // private data (X11InputMethodData structure defined in
- // awt_InputMethod.c) for native methods
- // this structure needs to be accessed within AWT_LOCK/UNLOCK
- private transient long pData = 0; // accessed by native
-
- // Initialize highlight mapping table
- static {
- @SuppressWarnings({"unchecked", "rawtypes"})
- Map<TextAttribute, ?> styles[] = new Map[4];
- HashMap<TextAttribute, Object> map;
-
- // UNSELECTED_RAW_TEXT_HIGHLIGHT
- map = new HashMap<>(1);
- map.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
- styles[0] = Collections.unmodifiableMap(map);
-
- // SELECTED_RAW_TEXT_HIGHLIGHT
- map = new HashMap<>(1);
- map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);
- styles[1] = Collections.unmodifiableMap(map);
-
- // UNSELECTED_CONVERTED_TEXT_HIGHLIGHT
- map = new HashMap<>(1);
- map.put(TextAttribute.INPUT_METHOD_UNDERLINE,
- TextAttribute.UNDERLINE_LOW_ONE_PIXEL);
- styles[2] = Collections.unmodifiableMap(map);
-
- // SELECTED_CONVERTED_TEXT_HIGHLIGHT
- map = new HashMap<>(1);
- map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);
- styles[3] = Collections.unmodifiableMap(map);
-
- highlightStyles = styles;
- }
-
- static {
- initIDs();
- }
-
- /**
- * Initialize JNI field and method IDs for fields that may be
- accessed from C.
- */
- private static native void initIDs();
+public abstract class X11InputMethod extends X11InputMethodBase {
/**
* Constructs an X11InputMethod instance. It initializes the XIM
@@ -174,113 +48,13 @@
* @exception AWTException if XOpenIM() failed.
*/
public X11InputMethod() throws AWTException {
- // supports only the locale in which the VM is started
- locale = X11InputMethodDescriptor.getSupportedLocale();
- if (initXIM() == false) {
- throw new AWTException("Cannot open X Input Method");
- }
- }
-
- @SuppressWarnings("deprecation")
- protected void finalize() throws Throwable {
- 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;
- }
-
- protected abstract void setXICFocus(ComponentPeer peer,
- boolean value, boolean active);
-
- /**
- * Does nothing - this adapter doesn't use the input method context.
- *
- * @see java.awt.im.spi.InputMethod#setInputMethodContext
- */
- public void setInputMethodContext(InputMethodContext context) {
- }
-
- /**
- * 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.
- */
- public boolean setLocale(Locale lang) {
- if (lang.equals(locale)) {
- return true;
- }
- // special compatibility rule for Japanese and Korean
- if (locale.equals(Locale.JAPAN) && lang.equals(Locale.JAPANESE) ||
- locale.equals(Locale.KOREA) && lang.equals(Locale.KOREAN)) {
- return true;
- }
- return false;
- }
-
- /**
- * Returns current input locale.
- */
- public Locale getLocale() {
- return locale;
- }
-
- /**
- * Does nothing - XIM doesn't let you specify which characters you expect.
- *
- * @see java.awt.im.spi.InputMethod#setCharacterSubsets
- */
- public void setCharacterSubsets(Subset[] subsets) {
- }
-
- /**
- * 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
- */
- public void dispatchEvent(AWTEvent e) {
- }
-
-
- 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() &&
- getClientComponent() != needResetXICClient.get()){
- resetXIC();
-
- // needs to reset the last xic focussed component.
- lastXICFocussedComponent = null;
- isLastXICActive = false;
-
- needResetXICClient.clear();
- needResetXIC = false;
- }
+ super();
}
/**
* Reset the composition state to the current composition state.
*/
- private void resetCompositionState() {
+ protected void resetCompositionState() {
if (compositionEnableSupported) {
try {
/* Restore the composition mode to the last saved composition
@@ -293,23 +67,6 @@
}
/**
- * Query and then return the current composition state.
- * @return the composition state if isCompositionEnabled call
- * is successful. Otherwise, it returns false.
- */
- private boolean getCompositionState() {
- boolean compositionState = false;
- if (compositionEnableSupported) {
- try {
- compositionState = isCompositionEnabled();
- } catch (UnsupportedOperationException e) {
- compositionEnableSupported = false;
- }
- }
- return compositionState;
- }
-
- /**
* Activate input method.
*/
public synchronized void activate() {
@@ -317,7 +74,7 @@
if (clientComponentWindow == null)
return;
- if (lastXICFocussedComponent != null){
+ if (lastXICFocussedComponent != null) {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine("XICFocused {0}, AWTFocused {1}",
lastXICFocussedComponent, awtFocussedComponent);
@@ -360,8 +117,6 @@
isActive = true;
}
- protected abstract boolean createXIC();
-
/**
* Deactivate input method.
*/
@@ -387,198 +142,26 @@
*/
savedCompositionState = getCompositionState();
- if (isTemporary){
+ if (isTemporary) {
//turn the status window off...
turnoffStatusWindow();
}
/* Delay resetting the XIC focus until activate is called and the newly
- focussed component has a different peer as the last focussed component.
- */
+ * Focused component has a different peer as the last focused component.
+ */
lastXICFocussedComponent = awtFocussedComponent;
isLastXICActive = isAc;
isLastTemporary = isTemporary;
isActive = false;
}
- /**
- * Explicitly disable the native IME. Native IME is not disabled when
- * deactivate is called.
- */
- public void disableInputMethod() {
- if (lastXICFocussedComponent != null) {
- setXICFocus(getPeer(lastXICFocussedComponent), false, isLastXICActive);
- lastXICFocussedComponent = null;
- isLastXICActive = false;
-
- resetXIC();
- needResetXICClient.clear();
- needResetXIC = false;
- }
- }
-
// implements java.awt.im.spi.InputMethod.hideWindows
public void hideWindows() {
// ??? need real implementation
}
/**
- * @see java.awt.Toolkit#mapInputMethodHighlight
- */
- public static Map<TextAttribute, ?> mapInputMethodHighlight(InputMethodHighlight highlight) {
- int index;
- int state = highlight.getState();
- if (state == InputMethodHighlight.RAW_TEXT) {
- index = 0;
- } else if (state == InputMethodHighlight.CONVERTED_TEXT) {
- index = 2;
- } else {
- return null;
- }
- if (highlight.isSelected()) {
- index += 1;
- }
- return highlightStyles[index];
- }
-
- /**
- * @see sun.awt.im.InputMethodAdapter#setAWTFocussedComponent
- */
- protected void setAWTFocussedComponent(Component component) {
- if (component == null) {
- 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();
- setXICFocus(getPeer(awtFocussedComponent), false, ac);
- setXICFocus(getPeer(component), true, ac);
- }
- awtFocussedComponent = component;
- }
-
- /**
- * @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.
- endComposition();
- // disable the native input method so that the other input
- // method could get the input focus.
- disableInputMethod();
- if (needResetXIC) {
- resetXIC();
- needResetXICClient.clear();
- 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!
- private Window getClientComponentWindow() {
- Component client = getClientComponent();
- Container container;
-
- if (client instanceof Container) {
- container = (Container) client;
- } else {
- container = getParent(client);
- }
-
- while (container != null && !(container instanceof java.awt.Window)) {
- container = getParent(container);
- }
- return (Window) container;
- }
-
- protected abstract Container getParent(Component client);
-
- /**
- * 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.
- */
- protected abstract ComponentPeer getPeer(Component client);
-
- /**
- * 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
- */
- private void postInputMethodEvent(int id,
- AttributedCharacterIterator text,
- int committedCharacterCount,
- TextHitInfo caret,
- TextHitInfo visiblePosition,
- long when) {
- Component source = getClientComponent();
- if (source != null) {
- InputMethodEvent event = new InputMethodEvent(source,
- id, when, text, committedCharacterCount, caret, visiblePosition);
- SunToolkit.postEvent(SunToolkit.targetToAppContext(source), (AWTEvent)event);
- }
- }
-
- private void postInputMethodEvent(int id,
- AttributedCharacterIterator text,
- int committedCharacterCount,
- TextHitInfo caret,
- TextHitInfo visiblePosition) {
- postInputMethodEvent(id, text, committedCharacterCount,
- caret, visiblePosition, EventQueue.getMostRecentEventTime());
- }
-
- /**
- * 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 when 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!
- void dispatchCommittedText(String str, long when) {
- if (str == null)
- return;
-
- if (composedText == null) {
- AttributedString attrstr = new AttributedString(str);
- postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
- attrstr.getIterator(),
- str.length(),
- null,
- null,
- when);
- } else {
- // if there is composed text, wait until the preedit
- // callback is invoked.
- committedText = str;
- }
- }
-
- private void dispatchCommittedText(String str) {
- dispatchCommittedText(str, EventQueue.getMostRecentEventTime());
- }
-
- /**
* 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
@@ -601,7 +184,7 @@
return;
}
- //Workaround for deadlock bug on solaris2.6_zh bug#4170760
+ // Workaround for deadlock bug on solaris2.6_zh bug#4170760
if (chgText == null
&& chgStyles == null
&& chgOffset == 0
@@ -739,34 +322,6 @@
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() {
- String flush = (committedText != null ? committedText : "");
- if (composedText != null) {
- flush += composedText.toString();
- }
-
- if (!flush.equals("")) {
- AttributedString attrstr = new AttributedString(flush);
- postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
- attrstr.getIterator(),
- flush.length(),
- null,
- null,
- EventQueue.getMostRecentEventTime());
- composedText = null;
- committedText = null;
- }
- }
-
/*
* Subclasses should override disposeImpl() instead of dispose(). Client
* code should always invoke dispose(), never disposeImpl().
@@ -783,43 +338,6 @@
}
/**
- * 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
- */
- public Object getControlObject() {
- return null;
- }
-
- /**
- * @see java.awt.im.spi.InputMethod#removeNotify
- */
- public synchronized void removeNotify() {
- dispose();
- }
-
- /**
* @see java.awt.im.spi.InputMethod#setCompositionEnabled(boolean)
*/
public void setCompositionEnabled(boolean enable) {
@@ -835,263 +353,4 @@
savedCompositionState = 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. */
- savedCompositionState = getCompositionState();
- boolean active = haveActiveClient();
- if (active && composedText == null && committedText == null){
- needResetXIC = true;
- needResetXICClient = new WeakReference<>(getClientComponent());
- return;
- }
-
- String text = resetXIC();
- /* 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;
- postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
- null,
- 0,
- null,
- null);
-
- if (text != null && text.length() > 0) {
- dispatchCommittedText(text);
- }
- awtUnlock();
-
- // Restore the preedit state if it was enabled
- if (savedCompositionState) {
- resetCompositionState();
- }
- }
-
- /**
- * 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.
- *
- */
- public String getNativeInputMethodInfo() {
- String xmodifiers = System.getenv("XMODIFIERS");
- String imInfo = null;
-
- // If XMODIFIERS is set, return the value
- if (xmodifiers != null) {
- int imIndex = xmodifiers.indexOf("@im=");
- if (imIndex != -1) {
- imInfo = xmodifiers.substring(imIndex + 4);
- }
- } else if (System.getProperty("os.name").startsWith("SunOS")) {
- File dtprofile = new File(System.getProperty("user.home") +
- "/.dtprofile");
- String languageEngineInfo = null;
- try {
- BufferedReader br = new BufferedReader(new FileReader(dtprofile));
- String line = null;
-
- while ( languageEngineInfo == null && (line = br.readLine()) != null) {
- if (line.contains("atok") || line.contains("wnn")) {
- StringTokenizer tokens = new StringTokenizer(line);
- while (tokens.hasMoreTokens()) {
- String token = tokens.nextToken();
- if (Pattern.matches("atok.*setup", token) ||
- Pattern.matches("wnn.*setup", token)){
- languageEngineInfo = token.substring(0, token.indexOf("setup"));
- break;
- }
- }
- }
- }
-
- br.close();
- } catch(IOException ioex) {
- // Since this method is provided for internal testing only,
- // we dump the stack trace for the ease of debugging.
- ioex.printStackTrace();
- }
-
- imInfo = "htt " + languageEngineInfo;
- }
-
- return imInfo;
- }
-
-
- /**
- * Performs mapping from an XIM visible feedback value to Java IM highlight.
- * @return Java input method highlight
- */
- private InputMethodHighlight convertVisualFeedbackToHighlight(int feedback) {
- InputMethodHighlight highlight;
-
- switch (feedback) {
- case XIMUnderline:
- highlight = InputMethodHighlight.UNSELECTED_CONVERTED_TEXT_HIGHLIGHT;
- break;
- case XIMReverse:
- highlight = InputMethodHighlight.SELECTED_CONVERTED_TEXT_HIGHLIGHT;
- break;
- case XIMHighlight:
- highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
- break;
- case XIMPrimary:
- highlight = InputMethodHighlight.UNSELECTED_CONVERTED_TEXT_HIGHLIGHT;
- break;
- case XIMSecondary:
- highlight = InputMethodHighlight.SELECTED_CONVERTED_TEXT_HIGHLIGHT;
- break;
- case XIMTertiary:
- highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
- break;
- default:
- highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
- break;
- }
- return highlight;
- }
-
- // initial capacity size for string buffer, etc.
- private static final int INITIAL_SIZE = 64;
-
- /**
- * 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;
-
- IntBuffer(int initialCapacity) {
- intArray = new int[initialCapacity];
- size = 0;
- index = 0;
- }
-
- void insert(int offset, int[] values) {
- int newSize = size + values.length;
- if (intArray.length < newSize) {
- int[] newIntArray = new int[newSize * 2];
- System.arraycopy(intArray, 0, newIntArray, 0, size);
- intArray = newIntArray;
- }
- System.arraycopy(intArray, offset, intArray, offset+values.length,
- size - offset);
- System.arraycopy(values, 0, intArray, offset, values.length);
- size += values.length;
- if (index > offset)
- index = offset;
- }
-
- void remove(int offset, int length) {
- if (offset + length != size)
- System.arraycopy(intArray, offset+length, intArray, offset,
- size - offset - length);
- size -= length;
- if (index > offset)
- index = offset;
- }
-
- void replace(int offset, int[] values) {
- System.arraycopy(values, 0, intArray, offset, values.length);
- }
-
- void removeAll() {
- size = 0;
- index = 0;
- }
-
- void rewind() {
- index = 0;
- }
-
- int getNext() {
- if (index == size)
- return -1;
- return intArray[index++];
- }
-
- void unget() {
- if (index != 0)
- index--;
- }
-
- int getOffset() {
- return index;
- }
-
- public String toString() {
- StringBuffer s = new StringBuffer();
- for (int i = 0; i < size;) {
- s.append(intArray[i++]);
- if (i < size)
- s.append(",");
- }
- return s.toString();
- }
- }
-
- /*
- * Native methods
- */
- private native String resetXIC();
- private native void disposeXIC();
- private native boolean setCompositionEnabledNative(boolean enable);
- private native boolean isCompositionEnabledNative();
- private native void turnoffStatusWindow();
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.desktop/unix/classes/sun/awt/X11InputMethodBase.java Wed May 30 08:19:59 2018 +0200
@@ -0,0 +1,849 @@
+/*
+ * Copyright (c) 1997, 2018, 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;
+
+import java.awt.AWTEvent;
+import java.awt.AWTException;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.EventQueue;
+import java.awt.Window;
+import java.awt.event.InputMethodEvent;
+import java.awt.font.TextAttribute;
+import java.awt.font.TextHitInfo;
+import java.awt.im.InputMethodHighlight;
+import java.awt.im.spi.InputMethodContext;
+import java.awt.peer.ComponentPeer;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.Character.Subset;
+import java.lang.ref.WeakReference;
+import java.text.AttributedCharacterIterator;
+import java.text.AttributedString;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.regex.Pattern;
+
+import sun.awt.im.InputMethodAdapter;
+import sun.util.logging.PlatformLogger;
+
+/**
+ * Input Method Adapter for XIM
+ *
+ * @author JavaSoft International
+ */
+public abstract class X11InputMethodBase extends InputMethodAdapter {
+ protected static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11InputMethod");
+ /*
+ * The following XIM* values must be the same as those defined in
+ * Xlib.h
+ */
+ private static final int XIMReverse = (1<<0);
+ private static final int XIMUnderline = (1<<1);
+ private static final int XIMHighlight = (1<<2);
+ private static final int XIMPrimary = (1<<5);
+ private static final int XIMSecondary = (1<<6);
+ private static final int XIMTertiary = (1<<7);
+
+ /*
+ * visible position values
+ */
+ protected static final int XIMVisibleToForward = (1<<8);
+ protected static final int XIMVisibleToBackward = (1<<9);
+ protected static final int XIMVisibleCenter = (1<<10);
+ protected static final int XIMVisibleMask =
+ (XIMVisibleToForward | XIMVisibleToBackward | XIMVisibleCenter);
+
+ private Locale locale;
+ private static boolean isXIMOpened = false;
+ protected Container clientComponentWindow = null;
+ protected Component awtFocussedComponent = null;
+ protected Component lastXICFocussedComponent = null;
+ protected boolean isLastXICActive = false;
+ protected boolean isLastTemporary = false;
+ protected boolean isActive = false;
+ private static Map<TextAttribute, ?>[] highlightStyles;
+ protected boolean disposed = false;
+
+ //reset the XIC if necessary
+ protected boolean needResetXIC = false;
+ private WeakReference<Component> needResetXICClient = new WeakReference<>(null);
+
+ // 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.
+ protected 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.
+ protected boolean savedCompositionState = false;
+
+ // variables to keep track of preedit context.
+ // these variables need to be accessed within AWT_LOCK/UNLOCK
+ protected String committedText = null;
+ protected StringBuffer composedText = null;
+ protected IntBuffer rawFeedbacks;
+
+ // private data (X11InputMethodData structure defined in
+ // awt_InputMethod.c) for native methods
+ // this structure needs to be accessed within AWT_LOCK/UNLOCK
+ protected transient long pData = 0; // accessed by native
+
+ // Initialize highlight mapping table
+ static {
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ Map<TextAttribute, ?> styles[] = new Map[4];
+ HashMap<TextAttribute, Object> map;
+
+ // UNSELECTED_RAW_TEXT_HIGHLIGHT
+ map = new HashMap<>(1);
+ map.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
+ styles[0] = Collections.unmodifiableMap(map);
+
+ // SELECTED_RAW_TEXT_HIGHLIGHT
+ map = new HashMap<>(1);
+ map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);
+ styles[1] = Collections.unmodifiableMap(map);
+
+ // UNSELECTED_CONVERTED_TEXT_HIGHLIGHT
+ map = new HashMap<>(1);
+ map.put(TextAttribute.INPUT_METHOD_UNDERLINE,
+ TextAttribute.UNDERLINE_LOW_ONE_PIXEL);
+ styles[2] = Collections.unmodifiableMap(map);
+
+ // SELECTED_CONVERTED_TEXT_HIGHLIGHT
+ map = new HashMap<>(1);
+ map.put(TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON);
+ styles[3] = Collections.unmodifiableMap(map);
+
+ highlightStyles = styles;
+ }
+
+ static {
+ initIDs();
+ }
+
+ /**
+ * Constructs an X11InputMethod instance. It initializes the XIM
+ * environment if it's not done yet.
+ *
+ * @exception AWTException if XOpenIM() failed.
+ */
+ public X11InputMethodBase() throws AWTException {
+ // supports only the locale in which the VM is started
+ locale = X11InputMethodDescriptor.getSupportedLocale();
+ if (initXIM() == false) {
+ throw new AWTException("Cannot open X Input Method");
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ protected void finalize() throws Throwable {
+ 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;
+ }
+
+ protected abstract void setXICFocus(ComponentPeer peer,
+ boolean value, boolean active);
+
+ /**
+ * Does nothing - this adapter doesn't use the input method context.
+ *
+ * @see java.awt.im.spi.InputMethod#setInputMethodContext
+ */
+ public void setInputMethodContext(InputMethodContext context) {
+ }
+
+ /**
+ * 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.
+ */
+ public boolean setLocale(Locale lang) {
+ if (lang.equals(locale)) {
+ return true;
+ }
+ // special compatibility rule for Japanese and Korean
+ if (locale.equals(Locale.JAPAN) && lang.equals(Locale.JAPANESE) ||
+ locale.equals(Locale.KOREA) && lang.equals(Locale.KOREAN)) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Returns current input locale.
+ */
+ public Locale getLocale() {
+ return locale;
+ }
+
+ /**
+ * Does nothing - XIM doesn't let you specify which characters you expect.
+ *
+ * @see java.awt.im.spi.InputMethod#setCharacterSubsets
+ */
+ public void setCharacterSubsets(Subset[] subsets) {
+ }
+
+ /**
+ * 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
+ */
+ public void dispatchEvent(AWTEvent e) {
+ }
+
+ 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() &&
+ getClientComponent() != needResetXICClient.get()){
+ resetXIC();
+
+ // needs to reset the last xic focussed component.
+ lastXICFocussedComponent = null;
+ isLastXICActive = false;
+
+ needResetXICClient.clear();
+ needResetXIC = false;
+ }
+ }
+
+ /**
+ * Reset the composition state to the current composition state.
+ */
+ protected abstract void resetCompositionState();
+
+ /**
+ * Query and then return the current composition state.
+ * @return the composition state if isCompositionEnabled call
+ * is successful. Otherwise, it returns false.
+ */
+ protected boolean getCompositionState() {
+ boolean compositionState = false;
+ if (compositionEnableSupported) {
+ try {
+ compositionState = isCompositionEnabled();
+ } catch (UnsupportedOperationException e) {
+ compositionEnableSupported = false;
+ }
+ }
+ return compositionState;
+ }
+
+ /**
+ * Activate input method.
+ */
+ public abstract void activate();
+
+ protected abstract boolean createXIC();
+
+ /**
+ * Deactivate input method.
+ */
+ public abstract void deactivate(boolean isTemporary);
+
+ /**
+ * Explicitly disable the native IME. Native IME is not disabled when
+ * deactivate is called.
+ */
+ public void disableInputMethod() {
+ if (lastXICFocussedComponent != null) {
+ setXICFocus(getPeer(lastXICFocussedComponent), false, isLastXICActive);
+ lastXICFocussedComponent = null;
+ isLastXICActive = false;
+
+ resetXIC();
+ needResetXICClient.clear();
+ needResetXIC = false;
+ }
+ }
+
+ // implements java.awt.im.spi.InputMethod.hideWindows
+ public abstract void hideWindows();
+
+ /**
+ * @see java.awt.Toolkit#mapInputMethodHighlight
+ */
+ public static Map<TextAttribute, ?> mapInputMethodHighlight(InputMethodHighlight highlight) {
+ int index;
+ int state = highlight.getState();
+ if (state == InputMethodHighlight.RAW_TEXT) {
+ index = 0;
+ } else if (state == InputMethodHighlight.CONVERTED_TEXT) {
+ index = 2;
+ } else {
+ return null;
+ }
+ if (highlight.isSelected()) {
+ index += 1;
+ }
+ return highlightStyles[index];
+ }
+
+ /**
+ * @see sun.awt.im.InputMethodAdapter#setAWTFocussedComponent
+ */
+ protected void setAWTFocussedComponent(Component component) {
+ if (component == null) {
+ 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();
+ setXICFocus(getPeer(awtFocussedComponent), false, ac);
+ setXICFocus(getPeer(component), true, ac);
+ }
+ awtFocussedComponent = component;
+ }
+
+ /**
+ * @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.
+ endComposition();
+ // disable the native input method so that the other input
+ // method could get the input focus.
+ disableInputMethod();
+ if (needResetXIC) {
+ resetXIC();
+ needResetXICClient.clear();
+ 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!
+ protected Window getClientComponentWindow() {
+ Component client = getClientComponent();
+ Container container;
+
+ if (client instanceof Container) {
+ container = (Container) client;
+ } else {
+ container = getParent(client);
+ }
+
+ while (container != null && !(container instanceof java.awt.Window)) {
+ container = getParent(container);
+ }
+ return (Window) container;
+ }
+
+ protected abstract Container getParent(Component client);
+
+ /**
+ * 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.
+ */
+ protected abstract ComponentPeer getPeer(Component client);
+
+ /**
+ * 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
+ */
+ protected void postInputMethodEvent(int id,
+ AttributedCharacterIterator text,
+ int committedCharacterCount,
+ TextHitInfo caret,
+ TextHitInfo visiblePosition,
+ long when) {
+ Component source = getClientComponent();
+ if (source != null) {
+ InputMethodEvent event = new InputMethodEvent(source,
+ id, when, text, committedCharacterCount, caret, visiblePosition);
+ SunToolkit.postEvent(SunToolkit.targetToAppContext(source), (AWTEvent)event);
+ }
+ }
+
+ private void postInputMethodEvent(int id,
+ AttributedCharacterIterator text,
+ int committedCharacterCount,
+ TextHitInfo caret,
+ TextHitInfo visiblePosition) {
+ postInputMethodEvent(id, text, committedCharacterCount,
+ caret, visiblePosition, EventQueue.getMostRecentEventTime());
+ }
+
+ /**
+ * 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 when 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!
+ void dispatchCommittedText(String str, long when) {
+ if (str == null)
+ return;
+
+ if (composedText == null) {
+ AttributedString attrstr = new AttributedString(str);
+ postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ attrstr.getIterator(),
+ str.length(),
+ null,
+ null,
+ when);
+ } else {
+ // if there is composed text, wait until the preedit
+ // callback is invoked.
+ committedText = str;
+ }
+ }
+
+ private void dispatchCommittedText(String str) {
+ dispatchCommittedText(str, EventQueue.getMostRecentEventTime());
+ }
+
+ /**
+ * 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!
+ abstract void dispatchComposedText(String chgText,
+ int chgStyles[],
+ int chgOffset,
+ int chgLength,
+ int caretPosition,
+ long 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() {
+ String flush = (committedText != null ? committedText : "");
+ if (composedText != null) {
+ flush += composedText.toString();
+ }
+
+ if (!flush.equals("")) {
+ AttributedString attrstr = new AttributedString(flush);
+ postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ attrstr.getIterator(),
+ flush.length(),
+ null,
+ null,
+ EventQueue.getMostRecentEventTime());
+ composedText = null;
+ committedText = null;
+ }
+ }
+
+ /*
+ * Subclasses should override disposeImpl() instead of dispose(). Client
+ * code should always invoke dispose(), never disposeImpl().
+ */
+ protected abstract void disposeImpl();
+
+ /**
+ * 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
+ */
+ public Object getControlObject() {
+ return null;
+ }
+
+ /**
+ * @see java.awt.im.spi.InputMethod#removeNotify
+ */
+ public synchronized void removeNotify() {
+ dispose();
+ }
+
+ /**
+ * @see java.awt.im.spi.InputMethod#setCompositionEnabled(boolean)
+ */
+ public abstract void setCompositionEnabled(boolean 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. */
+ savedCompositionState = getCompositionState();
+ boolean active = haveActiveClient();
+ if (active && composedText == null && committedText == null){
+ needResetXIC = true;
+ needResetXICClient = new WeakReference<>(getClientComponent());
+ return;
+ }
+
+ String text = resetXIC();
+ /* 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();
+ try {
+ composedText = null;
+ postInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
+ null,
+ 0,
+ null,
+ null);
+
+ if (text != null && text.length() > 0) {
+ dispatchCommittedText(text);
+ }
+ } finally {
+ // Put awtUnlock into finally block in case an exception is thrown.
+ awtUnlock();
+ }
+
+ // Restore the preedit state if it was enabled
+ if (savedCompositionState) {
+ resetCompositionState();
+ }
+ }
+
+ /**
+ * 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.
+ *
+ */
+ public String getNativeInputMethodInfo() {
+ String xmodifiers = System.getenv("XMODIFIERS");
+ String imInfo = null;
+
+ // If XMODIFIERS is set, return the value
+ if (xmodifiers != null) {
+ int imIndex = xmodifiers.indexOf("@im=");
+ if (imIndex != -1) {
+ imInfo = xmodifiers.substring(imIndex + 4);
+ }
+ } else if (System.getProperty("os.name").startsWith("SunOS")) {
+ File dtprofile = new File(System.getProperty("user.home") +
+ "/.dtprofile");
+ String languageEngineInfo = null;
+ try {
+ BufferedReader br = new BufferedReader(new FileReader(dtprofile));
+ String line = null;
+
+ while ( languageEngineInfo == null && (line = br.readLine()) != null) {
+ if (line.contains("atok") || line.contains("wnn")) {
+ StringTokenizer tokens = new StringTokenizer(line);
+ while (tokens.hasMoreTokens()) {
+ String token = tokens.nextToken();
+ if (Pattern.matches("atok.*setup", token) ||
+ Pattern.matches("wnn.*setup", token)){
+ languageEngineInfo = token.substring(0, token.indexOf("setup"));
+ break;
+ }
+ }
+ }
+ }
+
+ br.close();
+ } catch(IOException ioex) {
+ // Since this method is provided for internal testing only,
+ // we dump the stack trace for the ease of debugging.
+ ioex.printStackTrace();
+ }
+
+ imInfo = "htt " + languageEngineInfo;
+ }
+
+ return imInfo;
+ }
+
+
+ /**
+ * Performs mapping from an XIM visible feedback value to Java IM highlight.
+ * @return Java input method highlight
+ */
+ protected InputMethodHighlight convertVisualFeedbackToHighlight(int feedback) {
+ InputMethodHighlight highlight;
+
+ switch (feedback) {
+ case XIMUnderline:
+ highlight = InputMethodHighlight.UNSELECTED_CONVERTED_TEXT_HIGHLIGHT;
+ break;
+ case XIMReverse:
+ highlight = InputMethodHighlight.SELECTED_CONVERTED_TEXT_HIGHLIGHT;
+ break;
+ case XIMHighlight:
+ highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
+ break;
+ case 0: //None of the values are set by Wnn
+ case XIMPrimary:
+ highlight = InputMethodHighlight.UNSELECTED_CONVERTED_TEXT_HIGHLIGHT;
+ break;
+ case XIMSecondary:
+ highlight = InputMethodHighlight.SELECTED_CONVERTED_TEXT_HIGHLIGHT;
+ break;
+ case XIMTertiary:
+ highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
+ break;
+ default:
+ highlight = InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT;
+ break;
+ }
+ return highlight;
+ }
+
+ // initial capacity size for string buffer, etc.
+ protected static final int INITIAL_SIZE = 64;
+
+ /**
+ * 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.)
+ */
+ protected final class IntBuffer {
+ private int[] intArray;
+ private int size;
+ private int index;
+
+ IntBuffer(int initialCapacity) {
+ intArray = new int[initialCapacity];
+ size = 0;
+ index = 0;
+ }
+
+ void insert(int offset, int[] values) {
+ int newSize = size + values.length;
+ if (intArray.length < newSize) {
+ int[] newIntArray = new int[newSize * 2];
+ System.arraycopy(intArray, 0, newIntArray, 0, size);
+ intArray = newIntArray;
+ }
+ System.arraycopy(intArray, offset, intArray, offset+values.length,
+ size - offset);
+ System.arraycopy(values, 0, intArray, offset, values.length);
+ size += values.length;
+ if (index > offset)
+ index = offset;
+ }
+
+ void remove(int offset, int length) {
+ if (offset + length != size)
+ System.arraycopy(intArray, offset+length, intArray, offset,
+ size - offset - length);
+ size -= length;
+ if (index > offset)
+ index = offset;
+ }
+
+ void replace(int offset, int[] values) {
+ System.arraycopy(values, 0, intArray, offset, values.length);
+ }
+
+ void removeAll() {
+ size = 0;
+ index = 0;
+ }
+
+ void rewind() {
+ index = 0;
+ }
+
+ int getNext() {
+ if (index == size)
+ return -1;
+ return intArray[index++];
+ }
+
+ void unget() {
+ if (index != 0)
+ index--;
+ }
+
+ int getOffset() {
+ return index;
+ }
+
+ public String toString() {
+ StringBuffer s = new StringBuffer();
+ for (int i = 0; i < size;) {
+ s.append(intArray[i++]);
+ if (i < size)
+ s.append(",");
+ }
+ return s.toString();
+ }
+ }
+
+ /*
+ * Native methods
+ */
+
+ /**
+ * Initialize JNI field and method IDs for fields that may be
+ * accessed from C.
+ */
+ private static native void initIDs();
+
+ protected native void turnoffStatusWindow();
+
+ protected native void disposeXIC();
+
+ private native String resetXIC();
+
+ protected native boolean setCompositionEnabledNative(boolean enable);
+
+ private native boolean isCompositionEnabledNative();
+}
--- a/src/java.desktop/unix/native/libawt_xawt/awt/awt_InputMethod.c Tue May 29 11:22:21 2018 -0700
+++ b/src/java.desktop/unix/native/libawt_xawt/awt/awt_InputMethod.c Wed May 30 08:19:59 2018 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, 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
@@ -27,18 +27,18 @@
#error This file should not be included in headless library
#endif
-#include <stdio.h>
-#include <stdlib.h>
-#include <X11/Xlib.h>
-#include <X11/keysym.h>
-#include <sys/time.h>
-
#include "awt.h"
#include "awt_p.h"
-#include <sun_awt_X11InputMethod.h>
+#include <sun_awt_X11InputMethodBase.h>
#include <sun_awt_X11_XInputMethod.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <X11/keysym.h>
+#include <X11/Xlib.h>
+
#define THROW_OUT_OF_MEMORY_ERROR() \
JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), NULL)
@@ -536,10 +536,10 @@
composing = False;
/*FALLTHRU*/
case XLookupChars:
- /*
- printf("lookupString: status=XLookupChars, type=%d, state=%x, keycode=%x, keysym=%x\n",
- event->type, event->state, event->keycode, keysym);
- */
+ /*
+ printf("lookupString: status=XLookupChars, type=%d, state=%x, keycode=%x, keysym=%x\n",
+ event->type, event->state, event->keycode, keysym);
+ */
javastr = JNU_NewStringPlatform(env, (const char *)pX11IMData->lookup_buf);
if (javastr != NULL) {
JNU_CallMethodByName(env, NULL,
@@ -552,10 +552,10 @@
break;
case XLookupKeySym:
- /*
- printf("lookupString: status=XLookupKeySym, type=%d, state=%x, keycode=%x, keysym=%x\n",
- event->type, event->state, event->keycode, keysym);
- */
+ /*
+ printf("lookupString: status=XLookupKeySym, type=%d, state=%x, keycode=%x, keysym=%x\n",
+ event->type, event->state, event->keycode, keysym);
+ */
if (keysym == XK_Multi_key)
composing = True;
if (! composing) {
@@ -565,10 +565,10 @@
break;
case XLookupNone:
- /*
- printf("lookupString: status=XLookupNone, type=%d, state=%x, keycode=%x, keysym=%x\n",
- event->type, event->state, event->keycode, keysym);
- */
+ /*
+ printf("lookupString: status=XLookupNone, type=%d, state=%x, keycode=%x, keysym=%x\n",
+ event->type, event->state, event->keycode, keysym);
+ */
break;
}
@@ -576,8 +576,7 @@
}
#if defined(__linux__) || defined(MACOSX)
-static StatusWindow *createStatusWindow(
- Window parent) {
+static StatusWindow *createStatusWindow(Window parent) {
StatusWindow *statusWindow;
XSetWindowAttributes attrib;
unsigned long attribmask;
@@ -600,7 +599,7 @@
AwtGraphicsConfigDataPtr adata;
extern int awt_numScreens;
/*hardcode the size right now, should get the size base on font*/
- int width=80, height=22;
+ int width=80, height=22;
Window rootWindow;
Window *ignoreWindowPtr;
unsigned int ignoreUnit;
@@ -652,10 +651,10 @@
if (xx < 0 ){
xx = 0;
}
- if (xx + width > xxwa.width){
+ if (xx + width > xxwa.width) {
xx = xxwa.width - width;
}
- if (yy + height > xxwa.height){
+ if (yy + height > xxwa.height) {
yy = xxwa.height - height;
}
@@ -724,7 +723,7 @@
return;
}
- if (ON == False){
+ if (ON == False) {
XUnmapWindow(dpy, statusWindow->w);
statusWindow->on = False;
return;
@@ -732,7 +731,7 @@
parent = JNU_CallMethodByName(GetJNIEnv(), NULL, pX11IMData->x11inputmethod,
"getCurrentParentWindow",
"()J").j;
- if (statusWindow->parent != parent){
+ if (statusWindow->parent != parent) {
statusWindow->parent = parent;
}
XGetWindowAttributes(dpy, parent, &xwa);
@@ -741,21 +740,22 @@
xwa.x, xwa.y,
&x, &y,
&child);
- if (statusWindow->x != x
- || statusWindow->y != y
- || statusWindow->height != xwa.height){
+ if (statusWindow->x != x ||
+ statusWindow->y != y ||
+ statusWindow->height != xwa.height)
+ {
statusWindow->x = x;
statusWindow->y = y;
statusWindow->height = xwa.height;
x = statusWindow->x - statusWindow->off_x;
y = statusWindow->y + statusWindow->height - statusWindow->off_y;
- if (x < 0 ){
+ if (x < 0 ) {
x = 0;
}
- if (x + statusWindow->statusW > statusWindow->rootW){
+ if (x + statusWindow->statusW > statusWindow->rootW) {
x = statusWindow->rootW - statusWindow->statusW;
}
- if (y + statusWindow->statusH > statusWindow->rootH){
+ if (y + statusWindow->statusH > statusWindow->rootH) {
y = statusWindow->rootH - statusWindow->statusH;
}
XMoveWindow(dpy, statusWindow->w, x, y);
@@ -790,61 +790,19 @@
XDrawLine(dpy, win, dimgc, 2, height-3, width-bwidth-1, height-3);
XDrawLine(dpy, win, dimgc, 2, 2, width-bwidth-2, 2);
XDrawLine(dpy, win, dimgc, width-bwidth, 2, width-bwidth, height-3);
- if (statusWindow->fontset){
+ if (statusWindow->fontset) {
XmbDrawString(dpy, win, statusWindow->fontset, fggc,
bwidth + 2, height - bwidth - 4,
statusWindow->status,
strlen(statusWindow->status));
- }
- else{
+ } else {
/*too bad we failed to create a fontset for this locale*/
XDrawString(dpy, win, fggc, bwidth + 2, height - bwidth - 4,
"[InputMethod ON]", strlen("[InputMethod ON]"));
}
}
-void statusWindowEventHandler(XEvent event){
- JNIEnv *env = GetJNIEnv();
- X11InputMethodData *pX11IMData = NULL;
- StatusWindow *statusWindow;
-
- if (!isX11InputMethodGRefInList(currentX11InputMethodInstance)) {
- currentX11InputMethodInstance = NULL;
- return;
- }
-
- if (NULL == currentX11InputMethodInstance
- || NULL == (pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance))
- || NULL == (statusWindow = pX11IMData->statusWindow)
- || statusWindow->w != event.xany.window){
- return;
- }
-
- switch (event.type){
- case Expose:
- paintStatusWindow(statusWindow);
- break;
- case MapNotify:
- case ConfigureNotify:
- {
- /*need to reset the stackMode...*/
- XWindowChanges xwc;
- int value_make = CWStackMode;
- xwc.stack_mode = TopIf;
- XConfigureWindow(dpy, statusWindow->w, value_make, &xwc);
- }
- break;
- /*
- case UnmapNotify:
- case VisibilityNotify:
- break;
- */
- default:
- break;
- }
-}
-
-static void adjustStatusWindow(Window shell){
+static void adjustStatusWindow(Window shell) {
JNIEnv *env = GetJNIEnv();
X11InputMethodData *pX11IMData = NULL;
StatusWindow *statusWindow;
@@ -853,9 +811,11 @@
|| !isX11InputMethodGRefInList(currentX11InputMethodInstance)
|| NULL == (pX11IMData = getX11InputMethodData(env,currentX11InputMethodInstance))
|| NULL == (statusWindow = pX11IMData->statusWindow)
- || !statusWindow->on) {
+ || !statusWindow->on)
+ {
return;
}
+
{
XWindowAttributes xwa;
int x, y;
@@ -875,7 +835,7 @@
x = statusWindow->x - statusWindow->off_x;
y = statusWindow->y + statusWindow->height - statusWindow->off_y;
- if (x < 0 ){
+ if (x < 0 ) {
x = 0;
}
if (x + statusWindow->statusW > statusWindow->rootW){
@@ -889,6 +849,7 @@
}
}
#endif /* __linux__ || MACOSX */
+
/*
* Creates two XICs, one for active clients and the other for passive
* clients. All information on those XICs are stored in the
@@ -931,9 +892,9 @@
return FALSE ;
}
-#if defined(__linux__) || defined(MACOSX)
on_the_spot_styles |= XIMStatusNothing;
+#if defined(__linux__) || defined(MACOSX)
/*kinput does not support XIMPreeditCallbacks and XIMStatusArea
at the same time, so use StatusCallback to draw the status
ourself
@@ -944,8 +905,6 @@
break;
}
}
-#else /*! __linux__ && !MACOSX */
- on_the_spot_styles |= XIMStatusNothing;
#endif /* __linux__ || MACOSX */
for (i = 0; i < im_styles->count_styles; i++) {
@@ -1023,12 +982,12 @@
XFree((void *)preedit);
}
#else /* !__linux__ && !MACOSX */
- pX11IMData->ic_active = XCreateIC(X11im,
- XNClientWindow, w,
- XNFocusWindow, w,
- XNInputStyle, active_styles,
- XNPreeditAttributes, preedit,
- NULL);
+ pX11IMData->ic_active = XCreateIC(X11im,
+ XNClientWindow, w,
+ XNFocusWindow, w,
+ XNInputStyle, active_styles,
+ XNPreeditAttributes, preedit,
+ NULL);
XFree((void *)preedit);
#endif /* __linux__ || MACOSX */
} else {
@@ -1075,14 +1034,14 @@
PreeditStartCallback(XIC ic, XPointer client_data, XPointer call_data)
{
/*ARGSUSED*/
- /* printf("Native: PreeditCaretCallback\n"); */
+ /* printf("Native: PreeditStartCallback\n"); */
}
static void
PreeditDoneCallback(XIC ic, XPointer client_data, XPointer call_data)
{
/*ARGSUSED*/
- /* printf("Native: StatusStartCallback\n"); */
+ /* printf("Native: PreeditDoneCallback\n"); */
}
/*
@@ -1187,7 +1146,6 @@
{
/*ARGSUSED*/
/* printf("Native: PreeditCaretCallback\n"); */
-
}
#if defined(__linux__) || defined(MACOSX)
@@ -1196,7 +1154,6 @@
{
/*ARGSUSED*/
/*printf("StatusStartCallback:\n"); */
-
}
static void
@@ -1204,7 +1161,6 @@
{
/*ARGSUSED*/
/*printf("StatusDoneCallback:\n"); */
-
}
static void
@@ -1230,25 +1186,23 @@
|| NULL == (statusWindow = pX11IMData->statusWindow)){
goto finally;
}
- currentX11InputMethodInstance = (jobject)client_data;
+ currentX11InputMethodInstance = (jobject)client_data;
- if (status_draw->type == XIMTextType){
+ if (status_draw->type == XIMTextType) {
XIMText *text = (status_draw->data).text;
- if (text != NULL){
- if (text->string.multi_byte != NULL) {
- strncpy(statusWindow->status, text->string.multi_byte, MAX_STATUS_LEN);
- statusWindow->status[MAX_STATUS_LEN - 1] = '\0';
- }
- else {
- char *mbstr = wcstombsdmp(text->string.wide_char, text->length);
- strncpy(statusWindow->status, mbstr, MAX_STATUS_LEN);
- statusWindow->status[MAX_STATUS_LEN - 1] = '\0';
- }
- statusWindow->on = True;
- onoffStatusWindow(pX11IMData, statusWindow->parent, True);
- paintStatusWindow(statusWindow);
- }
- else {
+ if (text != NULL) {
+ if (text->string.multi_byte != NULL) {
+ strncpy(statusWindow->status, text->string.multi_byte, MAX_STATUS_LEN);
+ statusWindow->status[MAX_STATUS_LEN - 1] = '\0';
+ } else {
+ char *mbstr = wcstombsdmp(text->string.wide_char, text->length);
+ strncpy(statusWindow->status, mbstr, MAX_STATUS_LEN);
+ statusWindow->status[MAX_STATUS_LEN - 1] = '\0';
+ }
+ statusWindow->on = True;
+ onoffStatusWindow(pX11IMData, statusWindow->parent, True);
+ paintStatusWindow(statusWindow);
+ } else {
statusWindow->on = False;
/*just turnoff the status window
paintStatusWindow(statusWindow);
@@ -1327,26 +1281,10 @@
X11InputMethodData *pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance);
}
-/*
- * Class: sun_awt_X11InputMethod
- * Method: initIDs
- * Signature: ()V
- */
-
-/* This function gets called from the static initializer for
- X11InputMethod.java
- to initialize the fieldIDs for fields that may be accessed from C */
-JNIEXPORT void JNICALL
-Java_sun_awt_X11InputMethod_initIDs(JNIEnv *env, jclass cls)
-{
- x11InputMethodIDs.pData = (*env)->GetFieldID(env, cls, "pData", "J");
-}
-
-
JNIEXPORT jboolean JNICALL
Java_sun_awt_X11_XInputMethod_openXIMNative(JNIEnv *env,
- jobject this,
- jlong display)
+ jobject this,
+ jlong display)
{
Bool registered;
@@ -1375,8 +1313,8 @@
JNIEXPORT jboolean JNICALL
Java_sun_awt_X11_XInputMethod_createXICNative(JNIEnv *env,
- jobject this,
- jlong window)
+ jobject this,
+ jlong window)
{
X11InputMethodData *pX11IMData;
jobject globalRef;
@@ -1423,10 +1361,10 @@
JNIEXPORT void JNICALL
Java_sun_awt_X11_XInputMethod_setXICFocusNative(JNIEnv *env,
- jobject this,
- jlong w,
- jboolean req,
- jboolean active)
+ jobject this,
+ jlong w,
+ jboolean req,
+ jboolean active)
{
X11InputMethodData *pX11IMData;
AWT_LOCK();
@@ -1471,9 +1409,27 @@
AWT_UNLOCK();
}
-JNIEXPORT void JNICALL
-Java_sun_awt_X11InputMethod_turnoffStatusWindow(JNIEnv *env,
- jobject this)
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: initIDs
+ * Signature: ()V
+ * This function gets called from the static initializer for
+ * X11InputMethod.java to initialize the fieldIDs for fields
+ * that may be accessed from C
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethodBase_initIDs
+ (JNIEnv *env, jclass cls)
+{
+ x11InputMethodIDs.pData = (*env)->GetFieldID(env, cls, "pData", "J");
+}
+
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: turnoffStatusWindow
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethodBase_turnoffStatusWindow
+ (JNIEnv *env, jobject this)
{
#if defined(__linux__) || defined(MACOSX)
X11InputMethodData *pX11IMData;
@@ -1495,9 +1451,13 @@
#endif
}
-JNIEXPORT void JNICALL
-Java_sun_awt_X11InputMethod_disposeXIC(JNIEnv *env,
- jobject this)
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: disposeXIC
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_X11InputMethodBase_disposeXIC
+ (JNIEnv *env, jobject this)
{
X11InputMethodData *pX11IMData = NULL;
@@ -1518,9 +1478,13 @@
AWT_UNLOCK();
}
-JNIEXPORT jstring JNICALL
-Java_sun_awt_X11InputMethod_resetXIC(JNIEnv *env,
- jobject this)
+/*
+ * Class: sun_awt_X11InputMethodBase
+ * Method: resetXIC
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_sun_awt_X11InputMethodBase_resetXIC
+ (JNIEnv *env, jobject this)
{
X11InputMethodData *pX11IMData;
char *xText = NULL;
@@ -1564,9 +1528,9 @@
}
/*
- * Class: sun_awt_X11InputMethod
+ * Class: sun_awt_X11InputMethodBase
* Method: setCompositionEnabledNative
- * Signature: (ZJ)V
+ * Signature: (Z)Z
*
* This method tries to set the XNPreeditState attribute associated with the current
* XIC to the passed in 'enable' state.
@@ -1575,9 +1539,8 @@
* 'enable' state; Otherwise, if XSetICValues fails to set this attribute,
* java.lang.UnsupportedOperationException will be thrown. JNI_FALSE is returned if this
* method fails due to other reasons.
- *
*/
-JNIEXPORT jboolean JNICALL Java_sun_awt_X11InputMethod_setCompositionEnabledNative
+JNIEXPORT jboolean JNICALL Java_sun_awt_X11InputMethodBase_setCompositionEnabledNative
(JNIEnv *env, jobject this, jboolean enable)
{
X11InputMethodData *pX11IMData;
@@ -1603,18 +1566,17 @@
}
/*
- * Class: sun_awt_X11InputMethod
+ * Class: sun_awt_X11InputMethodBase
* Method: isCompositionEnabledNative
- * Signature: (J)Z
+ * Signature: ()Z
*
* This method tries to get the XNPreeditState attribute associated with the current XIC.
*
* Return JNI_TRUE if the XNPreeditState is successfully retrieved. Otherwise, if
* XGetICValues fails to get this attribute, java.lang.UnsupportedOperationException
* will be thrown. JNI_FALSE is returned if this method fails due to other reasons.
- *
*/
-JNIEXPORT jboolean JNICALL Java_sun_awt_X11InputMethod_isCompositionEnabledNative
+JNIEXPORT jboolean JNICALL Java_sun_awt_X11InputMethodBase_isCompositionEnabledNative
(JNIEnv *env, jobject this)
{
X11InputMethodData *pX11IMData = NULL;
--- a/src/java.desktop/unix/native/libawt_xawt/xawt/XlibWrapper.c Tue May 29 11:22:21 2018 -0700
+++ b/src/java.desktop/unix/native/libawt_xawt/xawt/XlibWrapper.c Wed May 30 08:19:59 2018 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2018, 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
@@ -23,31 +23,32 @@
* questions.
*/
+#include "awt.h"
+#include "awt_util.h"
+#include "jni.h"
+#include "jlong.h"
+#include "Region.h"
+#include "sizecalc.h"
+#include "utility/rect.h"
+
#include "sun_awt_X11_XlibWrapper.h"
-#include <X11/Xlib.h>
-#include <X11/keysym.h>
-#include <X11/Xutil.h>
-#include <X11/Xos.h>
-#include <X11/Xatom.h>
+
+#include <stdlib.h>
+#include <string.h>
#include <X11/extensions/Xdbe.h>
#include <X11/extensions/shape.h>
-#include <string.h>
-#include <stdlib.h>
+#include <X11/keysym.h>
#include <X11/Sunkeysym.h>
-
-#include <jni.h>
-#include <jni_util.h>
-#include <jlong.h>
-#include <sizecalc.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/XKBlib.h>
+#include <X11/Xos.h>
+#include <X11/Xutil.h>
-#include <awt.h>
-#include <awt_util.h>
-#include <jvm.h>
-
-#include <Region.h>
-#include "utility/rect.h"
-
-#include <X11/XKBlib.h>
+#if defined(AIX)
+#undef X_HAVE_UTF8_STRING
+extern Bool statusWindowEventHandler(XEvent event);
+#endif
// From XWindow.c
extern KeySym keycodeToKeysym(Display *display, KeyCode keycode, int index);
@@ -288,7 +289,6 @@
return ScreenCount((Display *) jlong_to_ptr(display));
}
-
/*
* Class: XlibWrapper
* Method: XCreateWindow
@@ -303,7 +303,6 @@
return XCreateWindow((Display *) jlong_to_ptr(display),(Window) window, x, y, w, h,
border_width, depth, wclass, (Visual *) jlong_to_ptr(visual),
valuemask, (XSetWindowAttributes *) jlong_to_ptr(attributes));
-
}
/*
@@ -320,7 +319,6 @@
(jlong_to_ptr(keysym_uppercase)));
}
-
/*
* Class: XlibWrapper
* Method: XMapWindow
@@ -331,7 +329,6 @@
{
AWT_CHECK_HAVE_LOCK();
XMapWindow( (Display *)jlong_to_ptr(display),(Window) window);
-
}
/*
@@ -344,7 +341,6 @@
{
AWT_CHECK_HAVE_LOCK();
XMapRaised( (Display *)jlong_to_ptr(display),(Window) window);
-
}
/*
@@ -355,10 +351,8 @@
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRaiseWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
-
AWT_CHECK_HAVE_LOCK();
XRaiseWindow( (Display *)jlong_to_ptr(display),(Window) window);
-
}
/*
@@ -369,10 +363,8 @@
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XLowerWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
-
AWT_CHECK_HAVE_LOCK();
XLowerWindow( (Display *)jlong_to_ptr(display),(Window) window);
-
}
/*
@@ -383,10 +375,8 @@
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRestackWindows
(JNIEnv *env, jclass clazz, jlong display, jlong windows, jint length)
{
-
AWT_CHECK_HAVE_LOCK();
XRestackWindows( (Display *) jlong_to_ptr(display), (Window *) jlong_to_ptr(windows), length);
-
}
/*
@@ -411,11 +401,10 @@
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
-
AWT_CHECK_HAVE_LOCK();
XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, CurrentTime);
+}
-}
/*
* Class: XlibWrapper
* Method: XSetInputFocus2
@@ -424,10 +413,8 @@
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus2
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong time)
{
-
AWT_CHECK_HAVE_LOCK();
XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, time);
-
}
/*
@@ -438,7 +425,6 @@
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetInputFocus
(JNIEnv *env, jclass clazz, jlong display)
{
-
Window focusOwner;
int revert_to;
AWT_CHECK_HAVE_LOCK_RETURN(0);
@@ -446,7 +432,6 @@
return focusOwner;
}
-
/*
* Class: XlibWrapper
* Method: XDestroyWindow
@@ -525,8 +510,6 @@
}
-
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSelectInput
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong mask)
{
@@ -543,6 +526,7 @@
(unsigned long)bits_to_change,
(unsigned long)values_for_bits);
}
+
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEventDetails
(JNIEnv *env, jclass clazz, jlong display, jlong device, jlong event_type,
jlong bits_to_change, jlong values_for_bits)
@@ -553,6 +537,7 @@
(unsigned long)bits_to_change,
(unsigned long)values_for_bits);
}
+
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbQueryExtension
(JNIEnv *env, jclass clazz, jlong display, jlong opcode_rtrn, jlong event_rtrn,
jlong error_rtrn, jlong major_in_out, jlong minor_in_out)
@@ -567,6 +552,7 @@
(int *) jlong_to_ptr(minor_in_out));
return status ? JNI_TRUE : JNI_FALSE;
}
+
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbLibraryVersion
(JNIEnv *env, jclass clazz, jlong lib_major_in_out, jlong lib_minor_in_out)
{
@@ -587,6 +573,7 @@
(unsigned int) which,
(unsigned int) device_spec);
}
+
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetUpdatedMap
(JNIEnv *env, jclass clazz, jlong display, jlong which, jlong xkb)
{
@@ -626,8 +613,6 @@
* Method: XNextEvent
* Signature: (JJ)V
*/
-
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XNextEvent
(JNIEnv *env, jclass clazz, jlong display, jlong ptr)
{
@@ -640,7 +625,6 @@
* Method: XMaskEvent
* Signature: (JJJ)V
*/
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMaskEvent
(JNIEnv *env, jclass clazz, jlong display, jlong event_mask, jlong event_return)
{
@@ -653,7 +637,6 @@
* Method: XWindowEvent
* Signature: (JJJJ)V
*/
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XWindowEvent
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong event_mask, jlong event_return)
{
@@ -670,6 +653,11 @@
(JNIEnv *env, jclass clazz, jlong ptr, jlong window)
{
AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
+#if defined(AIX)
+ if (True == statusWindowEventHandler(*((XEvent *)(uintptr_t)ptr))) {
+ return (jboolean)True;
+ }
+#endif
return (jboolean) XFilterEvent((XEvent *) jlong_to_ptr(ptr), (Window) window);
}
@@ -727,19 +715,15 @@
XPeekEvent((Display *) jlong_to_ptr(display),jlong_to_ptr(ptr));
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XMoveResizeWindow
* Signature: (JJIIII)V
*/
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMoveResizeWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint x , jint y , jint width, jint height) {
-
AWT_CHECK_HAVE_LOCK();
XMoveResizeWindow( (Display *) jlong_to_ptr(display), (Window) window, x, y, width, height);
-
}
/*
@@ -747,10 +731,8 @@
* Method: XResizeWindow
* Signature: (JJII)V
*/
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XResizeWindow
-(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height)
-{
+(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height) {
AWT_CHECK_HAVE_LOCK();
XResizeWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height);
}
@@ -760,10 +742,8 @@
* Method: XMoveWindow
* Signature: (JJII)V
*/
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMoveWindow
-(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height)
-{
+(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height) {
AWT_CHECK_HAVE_LOCK();
XMoveWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height);
}
@@ -774,13 +754,10 @@
* Method: XSetWindowBackground
* Signature: (JJJ)V
*/
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWindowBackground
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong background_pixel) {
-
AWT_CHECK_HAVE_LOCK();
XSetWindowBackground((Display *) jlong_to_ptr(display),window,background_pixel);
-
}
@@ -803,10 +780,8 @@
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSync
(JNIEnv *env, jclass clazz, jlong display, jint discard) {
-
AWT_CHECK_HAVE_LOCK();
XSync((Display *) jlong_to_ptr(display), discard);
-
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XTranslateCoordinates
@@ -855,7 +830,6 @@
cname = "";
}
-
AWT_CHECK_HAVE_LOCK();
#ifdef X_HAVE_UTF8_STRING
@@ -866,7 +840,6 @@
XStdICCTextStyle, &tp);
#endif
-
if (status == Success || status > 0) {
XChangeProperty((Display *)jlong_to_ptr(display), window, atom, tp.encoding, tp.format, PropModeReplace, tp.value, tp.nitems);
if (tp.value != NULL) {
@@ -1005,7 +978,6 @@
return XCreateFontCursor((Display *) jlong_to_ptr(display), (int) shape);
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XCreatePixmapCursor
@@ -1019,7 +991,6 @@
(XColor *) jlong_to_ptr(fore), (XColor *) jlong_to_ptr(back), x, y);
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XQueryBestCursor
@@ -1038,7 +1009,6 @@
else return JNI_TRUE;
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFreeCursor
@@ -1084,7 +1054,6 @@
(XSetWindowAttributes *) jlong_to_ptr(attributes));
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetTransientFor
@@ -1181,7 +1150,6 @@
}
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: getScreenOfWindow
@@ -1253,7 +1221,6 @@
return res;
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: ServerVendor
@@ -1265,6 +1232,7 @@
AWT_CHECK_HAVE_LOCK_RETURN(NULL);
return JNU_NewStringPlatform(env, ServerVendor((Display*)jlong_to_ptr(display)));
}
+
/*
* Class: sun_awt_X11_XlibWrapper
* Method: VendorRelease
@@ -1276,6 +1244,7 @@
AWT_CHECK_HAVE_LOCK_RETURN(0);
return VendorRelease((Display*)jlong_to_ptr(display));
}
+
/*
* Class: sun_awt_X11_XlibWrapper
* Method: IsXsunKPBehavior
@@ -1309,7 +1278,6 @@
}
}
-
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsSunKeyboard
(JNIEnv *env, jclass clazz, jlong display)
{
@@ -1407,7 +1375,6 @@
return (*(XErrorHandler)jlong_to_ptr(handler))((Display*) jlong_to_ptr(display), (XErrorEvent*) jlong_to_ptr(event_ptr));
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: PrintXErrorEvent
@@ -1431,7 +1398,6 @@
}
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XInternAtoms
@@ -1451,8 +1417,6 @@
return status;
}
-
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetWindowAttributes
@@ -1468,7 +1432,6 @@
return status;
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetGeometry
@@ -1490,7 +1453,6 @@
return status;
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetWMNormalHints
@@ -1546,7 +1508,6 @@
(XEvent*) jlong_to_ptr(event));
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XQueryTree
@@ -1564,7 +1525,6 @@
(unsigned int*) jlong_to_ptr(nchildren_return));
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: memcpy
@@ -1576,7 +1536,6 @@
memcpy(jlong_to_ptr(dest_ptr), jlong_to_ptr(src_ptr), length);
}
-
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetMinMaxHints
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint x, jint y, jint width, jint height, jlong flags) {
XSizeHints * hints;
@@ -1595,7 +1554,6 @@
XFree(hints);
}
-
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetVisualInfo
(JNIEnv *env, jclass clazz, jlong display, jlong vinfo_mask, jlong vinfo_template,
jlong nitems_return)
@@ -1626,7 +1584,6 @@
XBell((Display*)jlong_to_ptr(display), percent);
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XAllocColor
@@ -1643,7 +1600,6 @@
else return JNI_TRUE;
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XCreateBitmapFromData
@@ -1657,7 +1613,6 @@
(char *) jlong_to_ptr(data), width, height);
}
-
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFreePixmap
@@ -1772,6 +1727,7 @@
AWT_CHECK_HAVE_LOCK_RETURN(0);
return XCreatePixmap((Display*)jlong_to_ptr(display), (Drawable)drawable, width, height, depth);
}
+
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XCreateImage
(JNIEnv *env, jclass clazz, jlong display, jlong visual_ptr,
@@ -1783,6 +1739,7 @@
depth, format, offset, (char*) jlong_to_ptr(data),
width, height, bitmap_pad, bytes_per_line));
}
+
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XCreateGC
(JNIEnv *env, jclass clazz, jlong display, jlong drawable,
@@ -1806,6 +1763,7 @@
img->data = NULL;
XDestroyImage(img);
}
+
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XPutImage(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong gc, jlong image, jint src_x, jint src_y, jint dest_x, jint dest_y, jint width, jint height)
{
@@ -1813,18 +1771,21 @@
XPutImage((Display*)jlong_to_ptr(display), (Drawable)drawable, (GC) jlong_to_ptr(gc), (XImage*) jlong_to_ptr(image), src_x, src_y,
dest_x, dest_y, width, height);
}
+
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XFreeGC(JNIEnv *env, jclass clazz, jlong display, jlong gc)
{
AWT_CHECK_HAVE_LOCK();
XFreeGC((Display*) jlong_to_ptr(display), (GC) jlong_to_ptr(gc));
}
+
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XSetWindowBackgroundPixmap(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong pixmap)
{
AWT_CHECK_HAVE_LOCK();
XSetWindowBackgroundPixmap((Display*) jlong_to_ptr(display), (Window)window, (Pixmap)pixmap);
}
+
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XClearWindow(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
@@ -1922,7 +1883,6 @@
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XQueryKeymap
(JNIEnv *env, jclass clazz, jlong display, jlong vector)
{
-
AWT_CHECK_HAVE_LOCK();
XQueryKeymap( (Display *) jlong_to_ptr(display), (char *) jlong_to_ptr(vector));
}
@@ -1961,6 +1921,7 @@
// printf("-------------------------------------^^^^\n");
return (jint)(sr.group);
}
+
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XkbKeycodeToKeysym(JNIEnv *env, jclass clazz,
jlong display, jint keycode,
@@ -1989,6 +1950,7 @@
AWT_CHECK_HAVE_LOCK();
XFreeModifiermap((XModifierKeymap*) jlong_to_ptr(keymap));
}
+
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XRefreshKeyboardMapping
@@ -2034,7 +1996,6 @@
) ? True : False;
}
-
JNIEXPORT jboolean JNICALL
Java_sun_awt_X11_XlibWrapper_XNextSecondaryLoopEvent(JNIEnv *env, jclass clazz,
jlong display, jlong ptr) {
@@ -2062,7 +2023,6 @@
exitSecondaryLoop = True;
AWT_NOTIFY_ALL();
}
-/*******************************************************************************/
JNIEXPORT jobjectArray JNICALL
Java_sun_awt_X11_XlibWrapper_XTextPropertyToStringList(JNIEnv *env,
@@ -2181,7 +2141,6 @@
return ret;
}
-
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XPutBackEvent(JNIEnv *env,
jclass clazz,