/src/com/melloware/jintellitype/JIntellitype.java

/**

 * JIntellitype ----------------- Copyright 2005-2008 Emil A. Lefkof III,

 * Melloware Inc. I always give it my best shot to make a program useful and

 * solid, but remeber that there is absolutely no warranty for using this

 * program as stated in the following terms: Licensed under the Apache License,

 * Version 2.0 (the "License"); you may not use this file except in compliance

 * with the License. You may obtain a copy of the License at

 * http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law

 * or agreed to in writing, software distributed under the License is

 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 * KIND, either express or implied. See the License for the specific language

 * governing permissions and limitations under the License.

 */

package com.melloware.jintellitype;



import java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.concurrent.CopyOnWriteArrayList;



import javax.swing.SwingUtilities;



/**

 * JIntellitype A Java Implementation for using the Windows API Intellitype commands and the RegisterHotKey and

 * UnRegisterHotkey API calls for globally responding to key events. Intellitype are commands that are using for Play,

 * Stop, Next on Media keyboards or some laptops that have those special keys.

 * <p>

 * JIntellitype class that is used to call Windows API calls using the JIntellitype.dll.

 * <p>

 * This file comes with native code in JINTELLITYPE.DLL The DLL should go in C:/WINDOWS/SYSTEM or in your current

 * directory

 * <p>

 * <p>

 * Copyright (c) 1999-2008 Melloware, Inc. <http://www.melloware.com>

 * @author Emil A. Lefkof III <info@melloware.com>

 * @version 1.3.1

 */

public final class JIntellitype implements JIntellitypeConstants {



   /**

    * Static variable to hold singleton.

    */

   private static JIntellitype jintellitype = null;



   /**

    * Static variable for double checked thread safety.

    */

   private static boolean isInitialized = false;



   /**

    * Static variable to hold the libary location if set

    */

   private static String libraryLocation = null;



   /**

    * Listeners collection for Hotkey events

    */

   private final List<HotkeyListener> hotkeyListeners = Collections.synchronizedList(new CopyOnWriteArrayList<HotkeyListener>());



   /**

    * Listeners collection for Hotkey events

    */

   private final List<IntellitypeListener> intellitypeListeners = Collections.synchronizedList(new CopyOnWriteArrayList<IntellitypeListener>());



   /**

    * Handler is used by JNI code to keep different JVM instances separate

    */

   private final int handler = 0;



   /**

    * Map containing key->keycode mapping

    * @see #registerHotKey(int, String)

    * @see #getKey2KeycodeMapping()

    */

   private final HashMap<String, Integer> keycodeMap;



   /**

    * Private Constructor to prevent instantiation. Initialize the library for calling.

    */

   private JIntellitype() {

      try {

         // Load JNI library

         System.loadLibrary("JIntellitype");

      } catch (Throwable ex) {

         try {

            if (getLibraryLocation() != null) {

               System.load(getLibraryLocation());

            } else {

               String jarPath = "com/melloware/jintellitype/";

               String tmpDir = System.getProperty("java.io.tmpdir");

               try {

                  String dll = "JIntellitype.dll";

                  fromJarToFs(jarPath + dll, tmpDir + dll);

                  System.load(tmpDir + dll);

               } catch (UnsatisfiedLinkError e) {

                  String dll = "JIntellitype64.dll";

                  fromJarToFs(jarPath + dll, tmpDir + dll);

                  System.load(tmpDir + dll);

               }

            }

         } catch (Throwable ex2) {

            throw new JIntellitypeException("Could not load JIntellitype.dll from local file system or from inside JAR", ex2);

         }

      }



      initializeLibrary();

      this.keycodeMap = getKey2KeycodeMapping();

   }



   /**

    * Pulls a file out of the JAR and puts it on the File Path.

    * <p>

    * @param jarPath the path to the JAR

    * @param filePath the file path to extract to

    * @throws IOException if any IO error occurs

    */

   private void fromJarToFs(String jarPath, String filePath) throws IOException {

      File file = new File(filePath);

      if (file.exists()) {

         boolean success = file.delete();

         if (!success) {

            throw new IOException("couldn't delete " + filePath);

         }

      }

      InputStream is = null;

      OutputStream os = null;

      try {

         is = ClassLoader.getSystemClassLoader().getResourceAsStream(jarPath);

         os = new FileOutputStream(filePath);

         byte[] buffer = new byte[8192];

         int bytesRead;

         while ((bytesRead = is.read(buffer)) != -1) {

            os.write(buffer, 0, bytesRead);

         }

      } finally {

         if (is != null) {

            is.close();

         }

         if (os != null) {

            os.close();

         }

      }

   }



   /**

    * Gets the singleton instance of the JIntellitype object.

    * <p>

    * But the possibility of creation of more instance is only before the instance is created. Since all code defined

    * inside getInstance method is in the synchronized block, even the subsequent requests will also come and wait in

    * the synchronized block. This is a performance issue. The same can be solved using double-checked lock. Following

    * is the implementation of Singleton with lazy initialization and double-checked lock.

    * <p>

    * @return an instance of JIntellitype class

    */

   public static JIntellitype getInstance() {

      if (!isInitialized) {

         synchronized (JIntellitype.class) {

            if (!isInitialized) {

               jintellitype = new JIntellitype();

               isInitialized = true;

            }

         }

      }

      return jintellitype;

   }



   /**

    * Adds a listener for hotkeys.

    * <p>

    * @param listener the HotKeyListener to be added

    */

   public void addHotKeyListener(HotkeyListener listener) {

      hotkeyListeners.add(listener);

   }



   /**

    * Adds a listener for intellitype commands.

    * <p>

    * @param listener the IntellitypeListener to be added

    */

   public void addIntellitypeListener(IntellitypeListener listener) {

      intellitypeListeners.add(listener);

   }



   /**

    * Cleans up all resources used by JIntellitype.

    */

   public void cleanUp() {

      try {

         terminate();

      } catch (UnsatisfiedLinkError ex) {

         throw new JIntellitypeException(ERROR_MESSAGE, ex);

      } catch (RuntimeException ex) {

         throw new JIntellitypeException(ex);

      }

   }



   /**

    * Registers a Hotkey with windows. This combination will be responded to by all registered HotKeyListeners. Uses the

    * JIntellitypeConstants for MOD, ALT, CTRL, and WINDOWS keys.

    * <p>

    * @param identifier a unique identifier for this key combination

    * @param modifier MOD_SHIFT, MOD_ALT, MOD_CONTROL, MOD_WIN from JIntellitypeConstants, or 0 if no modifier needed

    * @param keycode the key to respond to in Ascii integer, 65 for A

    */

   public void registerHotKey(int identifier, int modifier, int keycode) {

      try {

         int modifiers = swingToIntelliType(modifier);

         if (modifiers == 0) {

            modifiers = modifier;

         }

         regHotKey(identifier, modifier, keycode);

      } catch (UnsatisfiedLinkError ex) {

         throw new JIntellitypeException(ERROR_MESSAGE, ex);

      } catch (RuntimeException ex) {

         throw new JIntellitypeException(ex);

      }

   }



   /**

    * Registers a Hotkey with windows. This combination will be responded to by all registered HotKeyListeners. Use the

    * Swing InputEvent constants from java.awt.InputEvent.

    * <p>

    * @param identifier a unique identifier for this key combination

    * @param modifier InputEvent.SHIFT_MASK, InputEvent.ALT_MASK, InputEvent.CTRL_MASK, or 0 if no modifier needed

    * @param keycode the key to respond to in Ascii integer, 65 for A

    */

   public void registerSwingHotKey(int identifier, int modifier, int keycode) {

      try {

         regHotKey(identifier, swingToIntelliType(modifier), keycode);

      } catch (UnsatisfiedLinkError ex) {

         throw new JIntellitypeException(ERROR_MESSAGE, ex);

      } catch (RuntimeException ex) {

         throw new JIntellitypeException(ex);

      }

   }



   /**

    * Registers a Hotkey with windows. This combination will be responded to by all registered HotKeyListeners. Use the

    * identifiers CTRL, SHIFT, ALT and/or WIN.

    * <p>

    * @param identifier a unique identifier for this key combination

    * @param modifierAndKeyCode String with modifiers separated by + and keycode (e.g. CTRL+SHIFT+A)

    * @see #registerHotKey(int, int, int)

    * @see #registerSwingHotKey(int, int, int)

    */

   public void registerHotKey(int identifier, String modifierAndKeyCode) {

      String[] split = modifierAndKeyCode.split("\\+");

      int mask = 0;

      int keycode = 0;



      for (int i = 0; i < split.length; i++) {

         if ("ALT".equalsIgnoreCase(split[i])) {

            mask += JIntellitype.MOD_ALT;

         } else if ("CTRL".equalsIgnoreCase(split[i]) || "CONTROL".equalsIgnoreCase(split[i])) {

            mask += JIntellitype.MOD_CONTROL;

         } else if ("SHIFT".equalsIgnoreCase(split[i])) {

            mask += JIntellitype.MOD_SHIFT;

         } else if ("WIN".equalsIgnoreCase(split[i])) {

            mask += JIntellitype.MOD_WIN;

         } else if (keycodeMap.containsKey(split[i].toLowerCase())) {

            keycode = keycodeMap.get(split[i].toLowerCase());

         }

      }

      registerHotKey(identifier, mask, keycode);

   }



   /**

    * Removes a listener for hotkeys.

    */

   public void removeHotKeyListener(HotkeyListener listener) {

      hotkeyListeners.remove(listener);

   }



   /**

    * Removes a listener for intellitype commands.

    */

   public void removeIntellitypeListener(IntellitypeListener listener) {

      intellitypeListeners.remove(listener);

   }



   /**

    * Unregisters a previously registered Hotkey identified by its unique identifier.

    * <p>

    * @param identifier the unique identifer of this Hotkey

    */

   public void unregisterHotKey(int identifier) {

      try {

         unregHotKey(identifier);

      } catch (UnsatisfiedLinkError ex) {

         throw new JIntellitypeException(ERROR_MESSAGE, ex);

      } catch (RuntimeException ex) {

         throw new JIntellitypeException(ex);

      }

   }



   /**

    * Checks to see if this application is already running.

    * <p>

    * @param appTitle the name of the application to check for

    * @return true if running, false if not running

    */

   public static boolean checkInstanceAlreadyRunning(String appTitle) {

      return getInstance().isRunning(appTitle);

   }



   /**

    * Checks to make sure the OS is a Windows flavor and that the JIntellitype DLL is found in the path and the JDK is

    * 32 bit not 64 bit. The DLL currently only supports 32 bit JDK.

    * <p>

    * @return true if Jintellitype may be used, false if not

    */

   public static boolean isJIntellitypeSupported() {

      boolean result = false;

      String os = "none";



      try {

         os = System.getProperty("os.name").toLowerCase();

      } catch (SecurityException ex) {

         // we are not allowed to look at this property

         System.err.println("Caught a SecurityException reading the system property " + "'os.name'; the SystemUtils property value will default to null.");

      }



      // only works on Windows OS currently

      if (os.startsWith("windows")) {

         // try an get the instance and if it succeeds then return true

         try {

            getInstance();

            result = true;

         } catch (Exception e) {

            result = false;

         }

      }



      return result;

   }



   /**

    * Gets the libraryLocation.

    * <p>

    * @return Returns the libraryLocation.

    */

   public static String getLibraryLocation() {

      return libraryLocation;

   }



   /**

    * Sets the libraryLocation.

    * <p>

    * @param libraryLocation The libraryLocation to set.

    */

   public static void setLibraryLocation(String libraryLocation) {

      final File dll = new File(libraryLocation);

      if (!dll.isAbsolute()) {

         JIntellitype.libraryLocation = dll.getAbsolutePath();

      } else {

         // absolute path, no further calculation needed

         JIntellitype.libraryLocation = libraryLocation;

      }

   }



   /**

    * Notifies all listeners that Hotkey was pressed.

    * <p>

    * @param identifier the unique identifier received

    */

   protected void onHotKey(final int identifier) {

      for (final HotkeyListener hotkeyListener : hotkeyListeners) {

         SwingUtilities.invokeLater(new Runnable() {

            public void run() {

               hotkeyListener.onHotKey(identifier);

            }

         });

      }

   }



   /**

    * Notifies all listeners that Intellitype command was received.

    * <p>

    * @param command the unique WM_APPCOMMAND received

    */

   protected void onIntellitype(final int command) {

      for (final IntellitypeListener intellitypeListener : intellitypeListeners) {

         SwingUtilities.invokeLater(new Runnable() {

            public void run() {

               intellitypeListener.onIntellitype(command);

            }

         });

      }

   }



   /**

    * Swing modifier value to Jintellipad conversion. If no conversion needed just return the original value. This lets

    * users pass either the original JIntellitype constants or Swing InputEvent constants.

    * <p>

    * @param swingKeystrokeModifier the Swing KeystrokeModifier to check

    * @return Jintellitype the JIntellitype modifier value

    */

   protected static int swingToIntelliType(int swingKeystrokeModifier) {

      int mask = 0;

      if ((swingKeystrokeModifier & InputEvent.SHIFT_MASK) == InputEvent.SHIFT_MASK) {

         mask &= JIntellitype.MOD_SHIFT;

      }

      if ((swingKeystrokeModifier & InputEvent.ALT_MASK) == InputEvent.ALT_MASK) {

         mask &= JIntellitype.MOD_ALT;

      }

      if ((swingKeystrokeModifier & InputEvent.CTRL_MASK) == InputEvent.CTRL_MASK) {

         mask &= JIntellitype.MOD_CONTROL;

      }

      if ((swingKeystrokeModifier & InputEvent.SHIFT_DOWN_MASK) == InputEvent.SHIFT_DOWN_MASK) {

         mask &= JIntellitype.MOD_SHIFT;

      }

      if ((swingKeystrokeModifier & InputEvent.ALT_DOWN_MASK) == InputEvent.ALT_DOWN_MASK) {

         mask &= JIntellitype.MOD_ALT;

      }

      if ((swingKeystrokeModifier & InputEvent.CTRL_DOWN_MASK) == InputEvent.CTRL_DOWN_MASK) {

         mask &= JIntellitype.MOD_CONTROL;

      }

      return mask;

   }



   /**

    * Puts all constants from {@link java.awt.event.KeyEvent} in a keycodeMap. The key is the lower case form of it.

    * @return Map containing key->keycode mapping DOCU Now enables the user to use all keys specified here instead of

    *         just [A-Z],[0-9] as before

    */

   private HashMap<String, Integer> getKey2KeycodeMapping() {

      HashMap<String, Integer> map = new HashMap<String, Integer>();



      map.put("first", KeyEvent.KEY_FIRST);

      map.put("last", KeyEvent.KEY_LAST);

      map.put("typed", KeyEvent.KEY_TYPED);

      map.put("pressed", KeyEvent.KEY_PRESSED);

      map.put("released", KeyEvent.KEY_RELEASED);

      map.put("enter", 13);

      map.put("back_space", KeyEvent.VK_BACK_SPACE);

      map.put("tab", KeyEvent.VK_TAB);

      map.put("cancel", KeyEvent.VK_CANCEL);

      map.put("clear", KeyEvent.VK_CLEAR);

      map.put("pause", KeyEvent.VK_PAUSE);

      map.put("caps_lock", KeyEvent.VK_CAPS_LOCK);

      map.put("escape", KeyEvent.VK_ESCAPE);

      map.put("space", KeyEvent.VK_SPACE);

      map.put("page_up", KeyEvent.VK_PAGE_UP);

      map.put("page_down", KeyEvent.VK_PAGE_DOWN);

      map.put("end", KeyEvent.VK_END);

      map.put("home", KeyEvent.VK_HOME);

      map.put("left", KeyEvent.VK_LEFT);

      map.put("up", KeyEvent.VK_UP);

      map.put("right", KeyEvent.VK_RIGHT);

      map.put("down", KeyEvent.VK_DOWN);

      map.put("comma", 188);

      map.put("minus", 109);

      map.put("period", 110);

      map.put("slash", 191);

      map.put("accent `", 192);

      map.put("0", KeyEvent.VK_0);

      map.put("1", KeyEvent.VK_1);

      map.put("2", KeyEvent.VK_2);

      map.put("3", KeyEvent.VK_3);

      map.put("4", KeyEvent.VK_4);

      map.put("5", KeyEvent.VK_5);

      map.put("6", KeyEvent.VK_6);

      map.put("7", KeyEvent.VK_7);

      map.put("8", KeyEvent.VK_8);

      map.put("9", KeyEvent.VK_9);

      map.put("semicolon", 186);

      map.put("equals", 187);

      map.put("a", KeyEvent.VK_A);

      map.put("b", KeyEvent.VK_B);

      map.put("c", KeyEvent.VK_C);

      map.put("d", KeyEvent.VK_D);

      map.put("e", KeyEvent.VK_E);

      map.put("f", KeyEvent.VK_F);

      map.put("g", KeyEvent.VK_G);

      map.put("h", KeyEvent.VK_H);

      map.put("i", KeyEvent.VK_I);

      map.put("j", KeyEvent.VK_J);

      map.put("k", KeyEvent.VK_K);

      map.put("l", KeyEvent.VK_L);

      map.put("m", KeyEvent.VK_M);

      map.put("n", KeyEvent.VK_N);

      map.put("o", KeyEvent.VK_O);

      map.put("p", KeyEvent.VK_P);

      map.put("q", KeyEvent.VK_Q);

      map.put("r", KeyEvent.VK_R);

      map.put("s", KeyEvent.VK_S);

      map.put("t", KeyEvent.VK_T);

      map.put("u", KeyEvent.VK_U);

      map.put("v", KeyEvent.VK_V);

      map.put("w", KeyEvent.VK_W);

      map.put("x", KeyEvent.VK_X);

      map.put("y", KeyEvent.VK_Y);

      map.put("z", KeyEvent.VK_Z);

      map.put("open_bracket", 219);

      map.put("back_slash", 220);

      map.put("close_bracket", 221);

      map.put("numpad0", KeyEvent.VK_NUMPAD0);

      map.put("numpad1", KeyEvent.VK_NUMPAD1);

      map.put("numpad2", KeyEvent.VK_NUMPAD2);

      map.put("numpad3", KeyEvent.VK_NUMPAD3);

      map.put("numpad4", KeyEvent.VK_NUMPAD4);

      map.put("numpad5", KeyEvent.VK_NUMPAD5);

      map.put("numpad6", KeyEvent.VK_NUMPAD6);

      map.put("numpad7", KeyEvent.VK_NUMPAD7);

      map.put("numpad8", KeyEvent.VK_NUMPAD8);

      map.put("numpad9", KeyEvent.VK_NUMPAD9);

      map.put("multiply", KeyEvent.VK_MULTIPLY);

      map.put("add", KeyEvent.VK_ADD);

      map.put("separator", KeyEvent.VK_SEPARATOR);

      map.put("subtract", KeyEvent.VK_SUBTRACT);

      map.put("decimal", KeyEvent.VK_DECIMAL);

      map.put("divide", KeyEvent.VK_DIVIDE);

      map.put("delete", 46);

      map.put("num_lock", KeyEvent.VK_NUM_LOCK);

      map.put("scroll_lock", KeyEvent.VK_SCROLL_LOCK);

      map.put("f1", KeyEvent.VK_F1);

      map.put("f2", KeyEvent.VK_F2);

      map.put("f3", KeyEvent.VK_F3);

      map.put("f4", KeyEvent.VK_F4);

      map.put("f5", KeyEvent.VK_F5);

      map.put("f6", KeyEvent.VK_F6);

      map.put("f7", KeyEvent.VK_F7);

      map.put("f8", KeyEvent.VK_F8);

      map.put("f9", KeyEvent.VK_F9);

      map.put("f10", KeyEvent.VK_F10);

      map.put("f11", KeyEvent.VK_F11);

      map.put("f12", KeyEvent.VK_F12);

      map.put("f13", KeyEvent.VK_F13);

      map.put("f14", KeyEvent.VK_F14);

      map.put("f15", KeyEvent.VK_F15);

      map.put("f16", KeyEvent.VK_F16);

      map.put("f17", KeyEvent.VK_F17);

      map.put("f18", KeyEvent.VK_F18);

      map.put("f19", KeyEvent.VK_F19);

      map.put("f20", KeyEvent.VK_F20);

      map.put("f21", KeyEvent.VK_F21);

      map.put("f22", KeyEvent.VK_F22);

      map.put("f23", KeyEvent.VK_F23);

      map.put("f24", KeyEvent.VK_F24);

      map.put("printscreen", 44);

      map.put("insert", 45);

      map.put("help", 47);

      map.put("meta", KeyEvent.VK_META);

      map.put("back_quote", KeyEvent.VK_BACK_QUOTE);

      map.put("quote", KeyEvent.VK_QUOTE);

      map.put("kp_up", KeyEvent.VK_KP_UP);

      map.put("kp_down", KeyEvent.VK_KP_DOWN);

      map.put("kp_left", KeyEvent.VK_KP_LEFT);

      map.put("kp_right", KeyEvent.VK_KP_RIGHT);

      map.put("dead_grave", KeyEvent.VK_DEAD_GRAVE);

      map.put("dead_acute", KeyEvent.VK_DEAD_ACUTE);

      map.put("dead_circumflex", KeyEvent.VK_DEAD_CIRCUMFLEX);

      map.put("dead_tilde", KeyEvent.VK_DEAD_TILDE);

      map.put("dead_macron", KeyEvent.VK_DEAD_MACRON);

      map.put("dead_breve", KeyEvent.VK_DEAD_BREVE);

      map.put("dead_abovedot", KeyEvent.VK_DEAD_ABOVEDOT);

      map.put("dead_diaeresis", KeyEvent.VK_DEAD_DIAERESIS);

      map.put("dead_abovering", KeyEvent.VK_DEAD_ABOVERING);

      map.put("dead_doubleacute", KeyEvent.VK_DEAD_DOUBLEACUTE);

      map.put("dead_caron", KeyEvent.VK_DEAD_CARON);

      map.put("dead_cedilla", KeyEvent.VK_DEAD_CEDILLA);

      map.put("dead_ogonek", KeyEvent.VK_DEAD_OGONEK);

      map.put("dead_iota", KeyEvent.VK_DEAD_IOTA);

      map.put("dead_voiced_sound", KeyEvent.VK_DEAD_VOICED_SOUND);

      map.put("dead_semivoiced_sound", KeyEvent.VK_DEAD_SEMIVOICED_SOUND);

      map.put("ampersand", KeyEvent.VK_AMPERSAND);

      map.put("asterisk", KeyEvent.VK_ASTERISK);

      map.put("quotedbl", KeyEvent.VK_QUOTEDBL);

      map.put("less", KeyEvent.VK_LESS);

      map.put("greater", KeyEvent.VK_GREATER);

      map.put("braceleft", KeyEvent.VK_BRACELEFT);

      map.put("braceright", KeyEvent.VK_BRACERIGHT);

      map.put("at", KeyEvent.VK_AT);

      map.put("colon", KeyEvent.VK_COLON);

      map.put("circumflex", KeyEvent.VK_CIRCUMFLEX);

      map.put("dollar", KeyEvent.VK_DOLLAR);

      map.put("euro_sign", KeyEvent.VK_EURO_SIGN);

      map.put("exclamation_mark", KeyEvent.VK_EXCLAMATION_MARK);

      map.put("inverted_exclamation_mark", KeyEvent.VK_INVERTED_EXCLAMATION_MARK);

      map.put("left_parenthesis", KeyEvent.VK_LEFT_PARENTHESIS);

      map.put("number_sign", KeyEvent.VK_NUMBER_SIGN);

      map.put("plus", KeyEvent.VK_PLUS);

      map.put("right_parenthesis", KeyEvent.VK_RIGHT_PARENTHESIS);

      map.put("underscore", KeyEvent.VK_UNDERSCORE);

      map.put("context_menu", KeyEvent.VK_CONTEXT_MENU);

      map.put("final", KeyEvent.VK_FINAL);

      map.put("convert", KeyEvent.VK_CONVERT);

      map.put("nonconvert", KeyEvent.VK_NONCONVERT);

      map.put("accept", KeyEvent.VK_ACCEPT);

      map.put("modechange", KeyEvent.VK_MODECHANGE);

      map.put("kana", KeyEvent.VK_KANA);

      map.put("kanji", KeyEvent.VK_KANJI);

      map.put("alphanumeric", KeyEvent.VK_ALPHANUMERIC);

      map.put("katakana", KeyEvent.VK_KATAKANA);

      map.put("hiragana", KeyEvent.VK_HIRAGANA);

      map.put("full_width", KeyEvent.VK_FULL_WIDTH);

      map.put("half_width", KeyEvent.VK_HALF_WIDTH);

      map.put("roman_characters", KeyEvent.VK_ROMAN_CHARACTERS);

      map.put("all_candidates", KeyEvent.VK_ALL_CANDIDATES);

      map.put("previous_candidate", KeyEvent.VK_PREVIOUS_CANDIDATE);

      map.put("code_input", KeyEvent.VK_CODE_INPUT);

      map.put("japanese_katakana", KeyEvent.VK_JAPANESE_KATAKANA);

      map.put("japanese_hiragana", KeyEvent.VK_JAPANESE_HIRAGANA);

      map.put("japanese_roman", KeyEvent.VK_JAPANESE_ROMAN);

      map.put("kana_lock", KeyEvent.VK_KANA_LOCK);

      map.put("input_method_on_off", KeyEvent.VK_INPUT_METHOD_ON_OFF);

      map.put("cut", KeyEvent.VK_CUT);

      map.put("copy", KeyEvent.VK_COPY);

      map.put("paste", KeyEvent.VK_PASTE);

      map.put("undo", KeyEvent.VK_UNDO);

      map.put("again", KeyEvent.VK_AGAIN);

      map.put("find", KeyEvent.VK_FIND);

      map.put("props", KeyEvent.VK_PROPS);

      map.put("stop", KeyEvent.VK_STOP);

      map.put("compose", KeyEvent.VK_COMPOSE);

      map.put("alt_graph", KeyEvent.VK_ALT_GRAPH);

      map.put("begin", KeyEvent.VK_BEGIN);



      return map;

   }



   private synchronized native void initializeLibrary() throws UnsatisfiedLinkError;



   private synchronized native void regHotKey(int identifier, int modifier, int keycode) throws UnsatisfiedLinkError;



   private synchronized native void terminate() throws UnsatisfiedLinkError;



   private synchronized native void unregHotKey(int identifier) throws UnsatisfiedLinkError;



   /**

    * Checks if there's an instance with hidden window title = appName running Can be used to detect that another

    * instance of your app is already running (so exit..)

    * <p>

    * @param appName = the title of the hidden window to search for

    */

   private synchronized native boolean isRunning(String appName);

}