Test JNativeHook (global key & mouse listeners) [WORKS, tested on Linux & Windows] [1010546]

!7

lib 1010545 // JNativeHook

/* JNativeHook: Global keyboard and mouse hooking for Java.
 * Copyright (C) 2006-2016 Alexander Barker.  All Rights Received.
 * https://github.com/kwhat/jnativehook/
 *
 * JNativeHook is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * JNativeHook 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 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

// Imports.
import org.jnativehook.GlobalScreen;
import org.jnativehook.NativeHookException;
import org.jnativehook.NativeInputEvent;
import org.jnativehook.dispatcher.SwingDispatchService;
import org.jnativehook.keyboard.NativeKeyEvent;
import org.jnativehook.keyboard.NativeKeyListener;
import org.jnativehook.mouse.NativeMouseEvent;
import org.jnativehook.mouse.NativeMouseInputListener;
import org.jnativehook.mouse.NativeMouseWheelEvent;
import org.jnativehook.mouse.NativeMouseWheelListener;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
import javax.swing.text.BadLocationException;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.ItemSelectable;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyEvent;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Date;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

p { NativeHookDemo.main(args); }

/**
 * A demonstration of how to use the JNativeHook library.
 *
 * @author	Alexander Barker (<a href="mailto:alex@1stleg.com">alex@1stleg.com</a>)
 * @version	2.0
 * @since	1.0
 *
 * @see GlobalScreen
 * @see NativeKeyListener
 */
public sclass NativeHookDemo extends JFrame implements ActionListener, ItemListener, NativeKeyListener, NativeMouseInputListener, NativeMouseWheelListener, WindowListener {
	/** The Constant serialVersionUID. */
	private static final long serialVersionUID = 1541183202160543102L;

	/** Menu Items */
	private JMenu menuSubListeners;
	private JMenuItem menuItemQuit, menuItemClear;
	private JCheckBoxMenuItem menuItemEnable, menuItemKeyboardEvents, menuItemButtonEvents, menuItemMotionEvents, menuItemWheelEvents;

	/** The text area to display event info. */
	private JTextArea txtEventInfo;

	/** Logging */
	private static final Logger logger = Logger.getLogger(GlobalScreen.class.getPackage().getName());

	/**
	 * Instantiates a new native hook demo.
	 */
	public NativeHookDemo() {
		// Setup the main window.
		setTitle("JNativeHook Demo");
		setLayout(new BorderLayout());
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		setSize(600, 300);
		addWindowListener(this);

		JMenuBar menuBar = new JMenuBar();

		// Create the file menu.
		JMenu menuFile = new JMenu("File");
		menuFile.setMnemonic(KeyEvent.VK_F);
		menuBar.add(menuFile);

		menuItemQuit = new JMenuItem("Quit", KeyEvent.VK_Q);
		menuItemQuit.addActionListener(this);
		menuItemQuit.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK));
		menuItemQuit.getAccessibleContext().setAccessibleDescription("Exit the program");
		menuFile.add(menuItemQuit);

		// Create the view.
		JMenu menuView = new JMenu("View");
		menuView.setMnemonic(KeyEvent.VK_V);
		menuBar.add(menuView);

		menuItemClear = new JMenuItem("Clear", KeyEvent.VK_C);
		menuItemClear.addActionListener(this);
		menuItemClear.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
		menuItemClear.getAccessibleContext().setAccessibleDescription("Clear the screen");
		menuView.add(menuItemClear);

		menuView.addSeparator();

		menuItemEnable = new JCheckBoxMenuItem("Enable Native Hook");
		menuItemEnable.addItemListener(this);
		menuItemEnable.setMnemonic(KeyEvent.VK_H);
		menuItemEnable.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_H, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
		menuView.add(menuItemEnable);

		// Create the listeners sub menu.
		menuSubListeners = new JMenu("Listeners");
		menuSubListeners.setMnemonic(KeyEvent.VK_L);
		menuView.add(menuSubListeners);

		menuItemKeyboardEvents = new JCheckBoxMenuItem("Keyboard Events");
		menuItemKeyboardEvents.addItemListener(this);
		menuItemKeyboardEvents.setMnemonic(KeyEvent.VK_K);
		menuItemKeyboardEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_K, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
		menuSubListeners.add(menuItemKeyboardEvents);

		menuItemButtonEvents = new JCheckBoxMenuItem("Button Events");
		menuItemButtonEvents.addItemListener(this);
		menuItemButtonEvents.setMnemonic(KeyEvent.VK_B);
		menuItemButtonEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_B, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
		menuSubListeners.add(menuItemButtonEvents);

		menuItemMotionEvents = new JCheckBoxMenuItem("Motion Events");
		menuItemMotionEvents.addItemListener(this);
		menuItemMotionEvents.setMnemonic(KeyEvent.VK_M);
		menuItemMotionEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
		menuSubListeners.add(menuItemMotionEvents);

		menuItemWheelEvents = new JCheckBoxMenuItem("Wheel Events");
		menuItemWheelEvents.addItemListener(this);
		menuItemWheelEvents.setMnemonic(KeyEvent.VK_W);
		menuItemWheelEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
		menuSubListeners.add(menuItemWheelEvents);

		setJMenuBar(menuBar);

		// Create feedback area.
		txtEventInfo = new JTextArea();
		txtEventInfo.setEditable(false);
		txtEventInfo.setBackground(new Color(0xFF, 0xFF, 0xFF));
		txtEventInfo.setForeground(new Color(0x00, 0x00, 0x00));
		txtEventInfo.setText("");

		JScrollPane scrollPane = new JScrollPane(txtEventInfo);
		scrollPane.setPreferredSize(new Dimension(375, 125));
		add(scrollPane, BorderLayout.CENTER);


		// Disable parent logger and set the desired level.
		logger.setUseParentHandlers(false);
		logger.setLevel(Level.ALL);

		// Add our custom formatter to a console handler.
		ConsoleHandler handler = new ConsoleHandler();
		handler.setFormatter(new LogFormatter());
		handler.setLevel(Level.WARNING);
		logger.addHandler(handler);

		/* Note: JNativeHook does *NOT* operate on the event dispatching thread.
		 * Because Swing components must be accessed on the event dispatching
		 * thread, you *MUST* wrap access to Swing components using the
		 * SwingUtilities.invokeLater() or EventQueue.invokeLater() methods.
		 */
		GlobalScreen.setEventDispatcher(new SwingDispatchService());
		
		setVisible(true);
	}

	/**
	 * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
	 */
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == menuItemQuit) {
			this.dispose();
		}
		else if (e.getSource() == menuItemClear) {
			txtEventInfo.setText("");
		}
	}

	/**
	 * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
	 */
	public void itemStateChanged(ItemEvent e) {
		ItemSelectable item = e.getItemSelectable();

		if (item == menuItemEnable) {
			try {
				// Keyboard checkbox was changed, adjust listeners accordingly.
				if (e.getStateChange() == ItemEvent.SELECTED) {
					// Initialize native hook.  This is done on window open because the
					// listener requires the txtEventInfo object to be constructed.
					GlobalScreen.registerNativeHook();
				}
				else {
					GlobalScreen.unregisterNativeHook();
				}
			}
			catch (NativeHookException ex) {
				txtEventInfo.append("Error: " + ex.getMessage() + "\n");
			}

			// Set the enable menu item to the state of the hook.
			menuItemEnable.setState(GlobalScreen.isNativeHookRegistered());

			// Set enable/disable the sub-menus based on the enable menu item's state.
			menuSubListeners.setEnabled(menuItemEnable.getState());
		}
		else if (item == menuItemKeyboardEvents) {
			// Keyboard checkbox was changed, adjust listeners accordingly
			if (e.getStateChange() == ItemEvent.SELECTED) {
				GlobalScreen.addNativeKeyListener(this);
			}
			else {
				GlobalScreen.removeNativeKeyListener(this);
			}
		}
		else if (item == menuItemButtonEvents) {
			// Button checkbox was changed, adjust listeners accordingly
			if (e.getStateChange() == ItemEvent.SELECTED) {
				GlobalScreen.addNativeMouseListener(this);
			}
			else {
				GlobalScreen.removeNativeMouseListener(this);
			}
		}
		else if (item == menuItemMotionEvents) {
			// Motion checkbox was changed, adjust listeners accordingly
			if (e.getStateChange() == ItemEvent.SELECTED) {
				GlobalScreen.addNativeMouseMotionListener(this);
			}
			else {
				GlobalScreen.removeNativeMouseMotionListener(this);
			}
		}
		else if (item == menuItemWheelEvents) {
			// Motion checkbox was changed, adjust listeners accordingly
			if (e.getStateChange() == ItemEvent.SELECTED) {
				GlobalScreen.addNativeMouseWheelListener(this);
			}
			else {
				GlobalScreen.removeNativeMouseWheelListener(this);
			}
		}
	}

	/**
	 * @see org.jnativehook.keyboard.NativeKeyListener#nativeKeyPressed(org.jnativehook.keyboard.NativeKeyEvent)
	 */
	public void nativeKeyPressed(NativeKeyEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.keyboard.NativeKeyListener#nativeKeyReleased(org.jnativehook.keyboard.NativeKeyEvent)
	 */
	public void nativeKeyReleased(NativeKeyEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.keyboard.NativeKeyListener#nativeKeyTyped(org.jnativehook.keyboard.NativeKeyEvent)
	 */
	public void nativeKeyTyped(NativeKeyEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.mouse.NativeMouseListener#nativeMouseClicked(org.jnativehook.mouse.NativeMouseEvent)
	 */
	public void nativeMouseClicked(NativeMouseEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.mouse.NativeMouseListener#nativeMousePressed(org.jnativehook.mouse.NativeMouseEvent)
	 */
	public void nativeMousePressed(NativeMouseEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.mouse.NativeMouseListener#nativeMouseReleased(org.jnativehook.mouse.NativeMouseEvent)
	 */
	public void nativeMouseReleased(NativeMouseEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.mouse.NativeMouseMotionListener#nativeMouseMoved(org.jnativehook.mouse.NativeMouseEvent)
	 */
	public void nativeMouseMoved(NativeMouseEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.mouse.NativeMouseMotionListener#nativeMouseDragged(org.jnativehook.mouse.NativeMouseEvent)
	 */
	public void nativeMouseDragged(NativeMouseEvent e) {
		displayEventInfo(e);
	}

	/**
	 * @see org.jnativehook.mouse.NativeMouseWheelListener#nativeMouseWheelMoved(org.jnativehook.mouse.NativeMouseWheelEvent)
	 */
	public void nativeMouseWheelMoved(NativeMouseWheelEvent e) {
		displayEventInfo(e);
	}

	/**
	 * Write information about the <code>NativeInputEvent</code> to the text
	 * window.
	 *
	 * @param e the native input event to display.
	 */
	private void displayEventInfo(final NativeInputEvent e) {
		txtEventInfo.append("\n" + e.paramString());

		try {
			//Clean up the history to reduce memory consumption.
			if (txtEventInfo.getLineCount() > 100) {
				txtEventInfo.replaceRange("", 0, txtEventInfo.getLineEndOffset(txtEventInfo.getLineCount() - 1 - 100));
			}

			txtEventInfo.setCaretPosition(txtEventInfo.getLineStartOffset(txtEventInfo.getLineCount() - 1));
		}
		catch (BadLocationException ex) {
			txtEventInfo.setCaretPosition(txtEventInfo.getDocument().getLength());
		}
	}

	/**
	 * Unimplemented
	 *
	 * @see java.awt.event.WindowListener#windowActivated(java.awt.event.WindowEvent)
	 */
	public void windowActivated(WindowEvent e) { /* Do Nothing */ }

	/**
	 * Unimplemented
	 *
	 * @see java.awt.event.WindowListener#windowClosing(java.awt.event.WindowEvent)
	 */
	public void windowClosing(WindowEvent e) { /* Do Nothing */ }

	/**
	 * Unimplemented
	 *
	 * @see java.awt.event.WindowListener#windowDeactivated(java.awt.event.WindowEvent)
	 */
	public void windowDeactivated(WindowEvent e) { /* Do Nothing */ }

	/**
	 * Unimplemented
	 *
	 * @see java.awt.event.WindowListener#windowDeiconified(java.awt.event.WindowEvent)
	 */
	public void windowDeiconified(WindowEvent e) { /* Do Nothing */ }

	/**
	 * Unimplemented
	 *
	 * @see java.awt.event.WindowListener#windowIconified(java.awt.event.WindowEvent)
	 */
	public void windowIconified(WindowEvent e) { /* Do Nothing */ }

	/**
	 * Display information about the native keyboard and mouse along with any
	 * errors that may have occurred.
	 *
	 * @see java.awt.event.WindowListener#windowOpened(java.awt.event.WindowEvent)
	 */
	public void windowOpened(WindowEvent e) {
		// Return the focus to the window.
		this.requestFocusInWindow();

		// Enable the hook, this will cause the GlobalScreen to be initilized.
		menuItemEnable.setSelected(true);

		// Please note that these properties are not available until after the GlobalScreen class is initialized.
		txtEventInfo.append("JNativeHook Version " + System.getProperty("jnativehook.lib.version"));
		txtEventInfo.append("\nAuto Repeat Rate: " + System.getProperty("jnativehook.key.repeat.rate"));
		txtEventInfo.append("\n" + "Auto Repeat Delay: " + System.getProperty("jnativehook.key.repeat.delay"));
		txtEventInfo.append("\n" + "Double Click Time: " + System.getProperty("jnativehook.button.multiclick.iterval"));
		txtEventInfo.append("\n" + "Pointer Sensitivity: " + System.getProperty("jnativehook.pointer.sensitivity"));
		txtEventInfo.append("\n" + "Pointer Acceleration Multiplier: " + System.getProperty("jnativehook.pointer.acceleration.multiplier"));
		txtEventInfo.append("\n" + "Pointer Acceleration Threshold: " + System.getProperty("jnativehook.pointer.acceleration.threshold"));

		try {
			txtEventInfo.setCaretPosition(txtEventInfo.getLineStartOffset(txtEventInfo.getLineCount() - 1));
		}
		catch (BadLocationException ex) {
			txtEventInfo.setCaretPosition(txtEventInfo.getDocument().getLength());
		}

		// Enable all of the listeners.
		menuItemKeyboardEvents.setSelected(true);
		menuItemButtonEvents.setSelected(true);
		menuItemMotionEvents.setSelected(true);
		menuItemWheelEvents.setSelected(true);
	}

	/**
	 * Finalize and exit the program.
	 *
	 * @see java.awt.event.WindowListener#windowClosed(java.awt.event.WindowEvent)
	 */
	public void windowClosed(WindowEvent e) {
		// Clean up the native hook.
		try {
			GlobalScreen.unregisterNativeHook();
		}
		catch (NativeHookException ex) {
			ex.printStackTrace();
		}
		System.runFinalization();
		System.exit(0);
	}

	/**
	 * The demo project entry point.
	 *
	 * @param args unused.
	 */
	public static void main(String[] args) {
		StringBuffer copyright = new StringBuffer("\n")
				.append("JNativeHook: Global keyboard and mouse hooking for Java.\n")
				.append("Copyright (C) 2006-2016 Alexander Barker.  All Rights Received.\n")
				.append("https://github.com/kwhat/jnativehook/\n")
				.append("\n")
				.append("JNativeHook is free software: you can redistribute it and/or modify\n")
				.append("it under the terms of the GNU Lesser General Public License as published\n")
				.append("by the Free Software Foundation, either version 3 of the License, or\n")
				.append("(at your option) any later version.\n")
				.append("\n")
				.append("JNativeHook is distributed in the hope that it will be useful,\n")
				.append("but WITHOUT ANY WARRANTY; without even the implied warranty of\n")
				.append("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n")
				.append("GNU General Public License for more details.\n")
				.append("\n")
				.append("You should have received a copy of the GNU Lesser General Public License\n")
				.append("along with this program.  If not, see <http://www.gnu.org/licenses/>.\n");
		System.out.println(copyright);

		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				new NativeHookDemo();
			}
		});
	}

	/**
	 * A simple log formatter.
	 *
	 * @see java.util.Formatter
	 */
	private final class LogFormatter extends Formatter {
		@Override
		public String format(LogRecord record) {
			StringBuilder line = new StringBuilder();

			line.append(new Date(record.getMillis()))
				.append(" ")
				.append(record.getLevel().getLocalizedName())
				.append(":\t")
				.append(formatMessage(record));

			if (record.getThrown() != null) {
				try {
					StringWriter sw = new StringWriter();
					PrintWriter pw = new PrintWriter(sw);
					record.getThrown().printStackTrace(pw);
					pw.close();
					line.append(sw.toString());
					sw.close();
				}
				catch (Exception ex) { /* Do Nothing */ }
			}

			return line.toString();
		}
	}
}

Travelled to 21 computer(s): agtzawvjhpac, aoiabmzegqzx, bhatertpkbcr, cbybwowwnfue, cfunsshuasjs, gwrvuhgaqvyk, hacelcvcghbr, imzmzdywqqli, ishqpsrjomds, kltaiputbqfu, krzvwbcyrync, lpdgvwnxivlt, mqqgnosmbjvj, onxytkatvevr, pyentgdyhuwx, pzhvpgtvlbxg, tslmcundralx, tvejysmllsmz, vezddojwiuja, vouqrxazstgt, xfasiavlzxuf

Snippet ID:	#1010546
Snippet name:	Test JNativeHook (global key & mouse listeners) [WORKS, tested on Linux & Windows]
Eternal ID of this version:	#1010546/4
Text MD5:	e4e9db878cc8b7c8105928bd4a1bc025
Transpilation MD5:	f7bf3062777d739cd8b3f0d505eed8ca
Author:	stefan
Category:	javax / gui
Type:	JavaX source code (desktop)
Public (visible to everyone):	Yes
Archived (hidden from active list):	No
Created/modified:	2017-09-20 17:07:31
Source code size:	18068 bytes / 512 lines
Pitched / IR pitched:	No / No
Views / Downloads:	1509 / 2283
Version history:	3 change(s)
Referenced in:	[show references]

< > BotCompany Repo | #1010546 // Test JNativeHook (global key & mouse listeners) [WORKS, tested on Linux & Windows]

JavaX source code (desktop) [tags: use-pretranspiled] - run with: x30.jar

1	!7
2
3	lib 1010545 // JNativeHook
4
5	/* JNativeHook: Global keyboard and mouse hooking for Java.
6	* Copyright (C) 2006-2016 Alexander Barker. All Rights Received.
7	* https://github.com/kwhat/jnativehook/
8	*
9	* JNativeHook is free software: you can redistribute it and/or modify
10	* it under the terms of the GNU Lesser General Public License as published
11	* by the Free Software Foundation, either version 3 of the License, or
12	* (at your option) any later version.
13	*
14	* JNativeHook is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU Lesser General Public License
20	* along with this program. If not, see <http://www.gnu.org/licenses/>.
21	*/
22
23	// Imports.
24	import org.jnativehook.GlobalScreen;
25	import org.jnativehook.NativeHookException;
26	import org.jnativehook.NativeInputEvent;
27	import org.jnativehook.dispatcher.SwingDispatchService;
28	import org.jnativehook.keyboard.NativeKeyEvent;
29	import org.jnativehook.keyboard.NativeKeyListener;
30	import org.jnativehook.mouse.NativeMouseEvent;
31	import org.jnativehook.mouse.NativeMouseInputListener;
32	import org.jnativehook.mouse.NativeMouseWheelEvent;
33	import org.jnativehook.mouse.NativeMouseWheelListener;
34	import javax.swing.JCheckBoxMenuItem;
35	import javax.swing.JFrame;
36	import javax.swing.JMenu;
37	import javax.swing.JMenuBar;
38	import javax.swing.JMenuItem;
39	import javax.swing.JScrollPane;
40	import javax.swing.JTextArea;
41	import javax.swing.KeyStroke;
42	import javax.swing.SwingUtilities;
43	import javax.swing.WindowConstants;
44	import javax.swing.text.BadLocationException;
45	import java.awt.BorderLayout;
46	import java.awt.Color;
47	import java.awt.Dimension;
48	import java.awt.ItemSelectable;
49	import java.awt.event.ActionEvent;
50	import java.awt.event.ActionListener;
51	import java.awt.event.ItemEvent;
52	import java.awt.event.ItemListener;
53	import java.awt.event.KeyEvent;
54	import java.awt.event.WindowEvent;
55	import java.awt.event.WindowListener;
56	import java.io.PrintWriter;
57	import java.io.StringWriter;
58	import java.util.Date;
59	import java.util.logging.ConsoleHandler;
60	import java.util.logging.Formatter;
61	import java.util.logging.Level;
62	import java.util.logging.LogRecord;
63	import java.util.logging.Logger;
64
65	p { NativeHookDemo.main(args); }
66
67	/**
68	* A demonstration of how to use the JNativeHook library.
69	*
70	* @author Alexander Barker (<a href="mailto:alex@1stleg.com">alex@1stleg.com</a>)
71	* @version 2.0
72	* @since 1.0
73	*
74	* @see GlobalScreen
75	* @see NativeKeyListener
76	*/
77	public sclass NativeHookDemo extends JFrame implements ActionListener, ItemListener, NativeKeyListener, NativeMouseInputListener, NativeMouseWheelListener, WindowListener {
78	/** The Constant serialVersionUID. */
79	private static final long serialVersionUID = 1541183202160543102L;
80
81	/** Menu Items */
82	private JMenu menuSubListeners;
83	private JMenuItem menuItemQuit, menuItemClear;
84	private JCheckBoxMenuItem menuItemEnable, menuItemKeyboardEvents, menuItemButtonEvents, menuItemMotionEvents, menuItemWheelEvents;
85
86	/** The text area to display event info. */
87	private JTextArea txtEventInfo;
88
89	/** Logging */
90	private static final Logger logger = Logger.getLogger(GlobalScreen.class.getPackage().getName());
91
92	/**
93	* Instantiates a new native hook demo.
94	*/
95	public NativeHookDemo() {
96	// Setup the main window.
97	setTitle("JNativeHook Demo");
98	setLayout(new BorderLayout());
99	setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
100	setSize(600, 300);
101	addWindowListener(this);
102
103	JMenuBar menuBar = new JMenuBar();
104
105	// Create the file menu.
106	JMenu menuFile = new JMenu("File");
107	menuFile.setMnemonic(KeyEvent.VK_F);
108	menuBar.add(menuFile);
109
110	menuItemQuit = new JMenuItem("Quit", KeyEvent.VK_Q);
111	menuItemQuit.addActionListener(this);
112	menuItemQuit.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK));
113	menuItemQuit.getAccessibleContext().setAccessibleDescription("Exit the program");
114	menuFile.add(menuItemQuit);
115
116	// Create the view.
117	JMenu menuView = new JMenu("View");
118	menuView.setMnemonic(KeyEvent.VK_V);
119	menuBar.add(menuView);
120
121	menuItemClear = new JMenuItem("Clear", KeyEvent.VK_C);
122	menuItemClear.addActionListener(this);
123	menuItemClear.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
124	menuItemClear.getAccessibleContext().setAccessibleDescription("Clear the screen");
125	menuView.add(menuItemClear);
126
127	menuView.addSeparator();
128
129	menuItemEnable = new JCheckBoxMenuItem("Enable Native Hook");
130	menuItemEnable.addItemListener(this);
131	menuItemEnable.setMnemonic(KeyEvent.VK_H);
132	menuItemEnable.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_H, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
133	menuView.add(menuItemEnable);
134
135	// Create the listeners sub menu.
136	menuSubListeners = new JMenu("Listeners");
137	menuSubListeners.setMnemonic(KeyEvent.VK_L);
138	menuView.add(menuSubListeners);
139
140	menuItemKeyboardEvents = new JCheckBoxMenuItem("Keyboard Events");
141	menuItemKeyboardEvents.addItemListener(this);
142	menuItemKeyboardEvents.setMnemonic(KeyEvent.VK_K);
143	menuItemKeyboardEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_K, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
144	menuSubListeners.add(menuItemKeyboardEvents);
145
146	menuItemButtonEvents = new JCheckBoxMenuItem("Button Events");
147	menuItemButtonEvents.addItemListener(this);
148	menuItemButtonEvents.setMnemonic(KeyEvent.VK_B);
149	menuItemButtonEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_B, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
150	menuSubListeners.add(menuItemButtonEvents);
151
152	menuItemMotionEvents = new JCheckBoxMenuItem("Motion Events");
153	menuItemMotionEvents.addItemListener(this);
154	menuItemMotionEvents.setMnemonic(KeyEvent.VK_M);
155	menuItemMotionEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
156	menuSubListeners.add(menuItemMotionEvents);
157
158	menuItemWheelEvents = new JCheckBoxMenuItem("Wheel Events");
159	menuItemWheelEvents.addItemListener(this);
160	menuItemWheelEvents.setMnemonic(KeyEvent.VK_W);
161	menuItemWheelEvents.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, ActionEvent.CTRL_MASK + ActionEvent.SHIFT_MASK));
162	menuSubListeners.add(menuItemWheelEvents);
163
164	setJMenuBar(menuBar);
165
166	// Create feedback area.
167	txtEventInfo = new JTextArea();
168	txtEventInfo.setEditable(false);
169	txtEventInfo.setBackground(new Color(0xFF, 0xFF, 0xFF));
170	txtEventInfo.setForeground(new Color(0x00, 0x00, 0x00));
171	txtEventInfo.setText("");
172
173	JScrollPane scrollPane = new JScrollPane(txtEventInfo);
174	scrollPane.setPreferredSize(new Dimension(375, 125));
175	add(scrollPane, BorderLayout.CENTER);
176
177
178	// Disable parent logger and set the desired level.
179	logger.setUseParentHandlers(false);
180	logger.setLevel(Level.ALL);
181
182	// Add our custom formatter to a console handler.
183	ConsoleHandler handler = new ConsoleHandler();
184	handler.setFormatter(new LogFormatter());
185	handler.setLevel(Level.WARNING);
186	logger.addHandler(handler);
187
188	/* Note: JNativeHook does NOT operate on the event dispatching thread.
189	* Because Swing components must be accessed on the event dispatching
190	* thread, you MUST wrap access to Swing components using the
191	* SwingUtilities.invokeLater() or EventQueue.invokeLater() methods.
192	*/
193	GlobalScreen.setEventDispatcher(new SwingDispatchService());
194
195	setVisible(true);
196	}
197
198	/**
199	* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
200	*/
201	public void actionPerformed(ActionEvent e) {
202	if (e.getSource() == menuItemQuit) {
203	this.dispose();
204	}
205	else if (e.getSource() == menuItemClear) {
206	txtEventInfo.setText("");
207	}
208	}
209
210	/**
211	* @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
212	*/
213	public void itemStateChanged(ItemEvent e) {
214	ItemSelectable item = e.getItemSelectable();
215
216	if (item == menuItemEnable) {
217	try {
218	// Keyboard checkbox was changed, adjust listeners accordingly.
219	if (e.getStateChange() == ItemEvent.SELECTED) {
220	// Initialize native hook. This is done on window open because the
221	// listener requires the txtEventInfo object to be constructed.
222	GlobalScreen.registerNativeHook();
223	}
224	else {
225	GlobalScreen.unregisterNativeHook();
226	}
227	}
228	catch (NativeHookException ex) {
229	txtEventInfo.append("Error: " + ex.getMessage() + "\n");
230	}
231
232	// Set the enable menu item to the state of the hook.
233	menuItemEnable.setState(GlobalScreen.isNativeHookRegistered());
234
235	// Set enable/disable the sub-menus based on the enable menu item's state.
236	menuSubListeners.setEnabled(menuItemEnable.getState());
237	}
238	else if (item == menuItemKeyboardEvents) {
239	// Keyboard checkbox was changed, adjust listeners accordingly
240	if (e.getStateChange() == ItemEvent.SELECTED) {
241	GlobalScreen.addNativeKeyListener(this);
242	}
243	else {
244	GlobalScreen.removeNativeKeyListener(this);
245	}
246	}
247	else if (item == menuItemButtonEvents) {
248	// Button checkbox was changed, adjust listeners accordingly
249	if (e.getStateChange() == ItemEvent.SELECTED) {
250	GlobalScreen.addNativeMouseListener(this);
251	}
252	else {
253	GlobalScreen.removeNativeMouseListener(this);
254	}
255	}
256	else if (item == menuItemMotionEvents) {
257	// Motion checkbox was changed, adjust listeners accordingly
258	if (e.getStateChange() == ItemEvent.SELECTED) {
259	GlobalScreen.addNativeMouseMotionListener(this);
260	}
261	else {
262	GlobalScreen.removeNativeMouseMotionListener(this);
263	}
264	}
265	else if (item == menuItemWheelEvents) {
266	// Motion checkbox was changed, adjust listeners accordingly
267	if (e.getStateChange() == ItemEvent.SELECTED) {
268	GlobalScreen.addNativeMouseWheelListener(this);
269	}
270	else {
271	GlobalScreen.removeNativeMouseWheelListener(this);
272	}
273	}
274	}
275
276	/**
277	* @see org.jnativehook.keyboard.NativeKeyListener#nativeKeyPressed(org.jnativehook.keyboard.NativeKeyEvent)
278	*/
279	public void nativeKeyPressed(NativeKeyEvent e) {
280	displayEventInfo(e);
281	}
282
283	/**
284	* @see org.jnativehook.keyboard.NativeKeyListener#nativeKeyReleased(org.jnativehook.keyboard.NativeKeyEvent)
285	*/
286	public void nativeKeyReleased(NativeKeyEvent e) {
287	displayEventInfo(e);
288	}
289
290	/**
291	* @see org.jnativehook.keyboard.NativeKeyListener#nativeKeyTyped(org.jnativehook.keyboard.NativeKeyEvent)
292	*/
293	public void nativeKeyTyped(NativeKeyEvent e) {
294	displayEventInfo(e);
295	}
296
297	/**
298	* @see org.jnativehook.mouse.NativeMouseListener#nativeMouseClicked(org.jnativehook.mouse.NativeMouseEvent)
299	*/
300	public void nativeMouseClicked(NativeMouseEvent e) {
301	displayEventInfo(e);
302	}
303
304	/**
305	* @see org.jnativehook.mouse.NativeMouseListener#nativeMousePressed(org.jnativehook.mouse.NativeMouseEvent)
306	*/
307	public void nativeMousePressed(NativeMouseEvent e) {
308	displayEventInfo(e);
309	}
310
311	/**
312	* @see org.jnativehook.mouse.NativeMouseListener#nativeMouseReleased(org.jnativehook.mouse.NativeMouseEvent)
313	*/
314	public void nativeMouseReleased(NativeMouseEvent e) {
315	displayEventInfo(e);
316	}
317
318	/**
319	* @see org.jnativehook.mouse.NativeMouseMotionListener#nativeMouseMoved(org.jnativehook.mouse.NativeMouseEvent)
320	*/
321	public void nativeMouseMoved(NativeMouseEvent e) {
322	displayEventInfo(e);
323	}
324
325	/**
326	* @see org.jnativehook.mouse.NativeMouseMotionListener#nativeMouseDragged(org.jnativehook.mouse.NativeMouseEvent)
327	*/
328	public void nativeMouseDragged(NativeMouseEvent e) {
329	displayEventInfo(e);
330	}
331
332	/**
333	* @see org.jnativehook.mouse.NativeMouseWheelListener#nativeMouseWheelMoved(org.jnativehook.mouse.NativeMouseWheelEvent)
334	*/
335	public void nativeMouseWheelMoved(NativeMouseWheelEvent e) {
336	displayEventInfo(e);
337	}
338
339	/**
340	* Write information about the <code>NativeInputEvent</code> to the text
341	* window.
342	*
343	* @param e the native input event to display.
344	*/
345	private void displayEventInfo(final NativeInputEvent e) {
346	txtEventInfo.append("\n" + e.paramString());
347
348	try {
349	//Clean up the history to reduce memory consumption.
350	if (txtEventInfo.getLineCount() > 100) {
351	txtEventInfo.replaceRange("", 0, txtEventInfo.getLineEndOffset(txtEventInfo.getLineCount() - 1 - 100));
352	}
353
354	txtEventInfo.setCaretPosition(txtEventInfo.getLineStartOffset(txtEventInfo.getLineCount() - 1));
355	}
356	catch (BadLocationException ex) {
357	txtEventInfo.setCaretPosition(txtEventInfo.getDocument().getLength());
358	}
359	}
360
361	/**
362	* Unimplemented
363	*
364	* @see java.awt.event.WindowListener#windowActivated(java.awt.event.WindowEvent)
365	*/
366	public void windowActivated(WindowEvent e) { /* Do Nothing */ }
367
368	/**
369	* Unimplemented
370	*
371	* @see java.awt.event.WindowListener#windowClosing(java.awt.event.WindowEvent)
372	*/
373	public void windowClosing(WindowEvent e) { /* Do Nothing */ }
374
375	/**
376	* Unimplemented
377	*
378	* @see java.awt.event.WindowListener#windowDeactivated(java.awt.event.WindowEvent)
379	*/
380	public void windowDeactivated(WindowEvent e) { /* Do Nothing */ }
381
382	/**
383	* Unimplemented
384	*
385	* @see java.awt.event.WindowListener#windowDeiconified(java.awt.event.WindowEvent)
386	*/
387	public void windowDeiconified(WindowEvent e) { /* Do Nothing */ }
388
389	/**
390	* Unimplemented
391	*
392	* @see java.awt.event.WindowListener#windowIconified(java.awt.event.WindowEvent)
393	*/
394	public void windowIconified(WindowEvent e) { /* Do Nothing */ }
395
396	/**
397	* Display information about the native keyboard and mouse along with any
398	* errors that may have occurred.
399	*
400	* @see java.awt.event.WindowListener#windowOpened(java.awt.event.WindowEvent)
401	*/
402	public void windowOpened(WindowEvent e) {
403	// Return the focus to the window.
404	this.requestFocusInWindow();
405
406	// Enable the hook, this will cause the GlobalScreen to be initilized.
407	menuItemEnable.setSelected(true);
408
409	// Please note that these properties are not available until after the GlobalScreen class is initialized.
410	txtEventInfo.append("JNativeHook Version " + System.getProperty("jnativehook.lib.version"));
411	txtEventInfo.append("\nAuto Repeat Rate: " + System.getProperty("jnativehook.key.repeat.rate"));
412	txtEventInfo.append("\n" + "Auto Repeat Delay: " + System.getProperty("jnativehook.key.repeat.delay"));
413	txtEventInfo.append("\n" + "Double Click Time: " + System.getProperty("jnativehook.button.multiclick.iterval"));
414	txtEventInfo.append("\n" + "Pointer Sensitivity: " + System.getProperty("jnativehook.pointer.sensitivity"));
415	txtEventInfo.append("\n" + "Pointer Acceleration Multiplier: " + System.getProperty("jnativehook.pointer.acceleration.multiplier"));
416	txtEventInfo.append("\n" + "Pointer Acceleration Threshold: " + System.getProperty("jnativehook.pointer.acceleration.threshold"));
417
418	try {
419	txtEventInfo.setCaretPosition(txtEventInfo.getLineStartOffset(txtEventInfo.getLineCount() - 1));
420	}
421	catch (BadLocationException ex) {
422	txtEventInfo.setCaretPosition(txtEventInfo.getDocument().getLength());
423	}
424
425	// Enable all of the listeners.
426	menuItemKeyboardEvents.setSelected(true);
427	menuItemButtonEvents.setSelected(true);
428	menuItemMotionEvents.setSelected(true);
429	menuItemWheelEvents.setSelected(true);
430	}
431
432	/**
433	* Finalize and exit the program.
434	*
435	* @see java.awt.event.WindowListener#windowClosed(java.awt.event.WindowEvent)
436	*/
437	public void windowClosed(WindowEvent e) {
438	// Clean up the native hook.
439	try {
440	GlobalScreen.unregisterNativeHook();
441	}
442	catch (NativeHookException ex) {
443	ex.printStackTrace();
444	}
445	System.runFinalization();
446	System.exit(0);
447	}
448
449	/**
450	* The demo project entry point.
451	*
452	* @param args unused.
453	*/
454	public static void main(String[] args) {
455	StringBuffer copyright = new StringBuffer("\n")
456	.append("JNativeHook: Global keyboard and mouse hooking for Java.\n")
457	.append("Copyright (C) 2006-2016 Alexander Barker. All Rights Received.\n")
458	.append("https://github.com/kwhat/jnativehook/\n")
459	.append("\n")
460	.append("JNativeHook is free software: you can redistribute it and/or modify\n")
461	.append("it under the terms of the GNU Lesser General Public License as published\n")
462	.append("by the Free Software Foundation, either version 3 of the License, or\n")
463	.append("(at your option) any later version.\n")
464	.append("\n")
465	.append("JNativeHook is distributed in the hope that it will be useful,\n")
466	.append("but WITHOUT ANY WARRANTY; without even the implied warranty of\n")
467	.append("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n")
468	.append("GNU General Public License for more details.\n")
469	.append("\n")
470	.append("You should have received a copy of the GNU Lesser General Public License\n")
471	.append("along with this program. If not, see <http://www.gnu.org/licenses/>.\n");
472	System.out.println(copyright);
473
474	SwingUtilities.invokeLater(new Runnable() {
475	public void run() {
476	new NativeHookDemo();
477	}
478	});
479	}
480
481	/**
482	* A simple log formatter.
483	*
484	* @see java.util.Formatter
485	*/
486	private final class LogFormatter extends Formatter {
487	@Override
488	public String format(LogRecord record) {
489	StringBuilder line = new StringBuilder();
490
491	line.append(new Date(record.getMillis()))
492	.append(" ")
493	.append(record.getLevel().getLocalizedName())
494	.append(":\t")
495	.append(formatMessage(record));
496
497	if (record.getThrown() != null) {
498	try {
499	StringWriter sw = new StringWriter();
500	PrintWriter pw = new PrintWriter(sw);
501	record.getThrown().printStackTrace(pw);
502	pw.close();
503	line.append(sw.toString());
504	sw.close();
505	}
506	catch (Exception ex) { /* Do Nothing */ }
507	}
508
509	return line.toString();
510	}
511	}
512	}