精华内容
下载资源
问答
  • Java全局监听鼠标点击

    2021-06-12 22:05:42
    GlobalMouseListener.java package cxzgwing; import java.awt.*; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.*; import javax.swing.text.BadLocationException; ...

    说明

    Java全局监听鼠标点击,不管是在窗体内点击还是在窗体外点击,都能监听到。

    效果图

    GlobalMouseListener.java

    package cxzgwing;
    
    import java.awt.*;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    import javax.swing.*;
    import javax.swing.text.BadLocationException;
    
    import org.jnativehook.GlobalScreen;
    import org.jnativehook.NativeHookException;
    import org.jnativehook.mouse.NativeMouseEvent;
    import org.jnativehook.mouse.NativeMouseInputListener;
    import org.jnativehook.mouse.NativeMouseListener;
    import org.jnativehook.mouse.NativeMouseMotionListener;
    
    /**
     * https://github.com/kwhat/jnativehook
     */
    public class GlobalMouseListener extends JFrame implements NativeMouseInputListener {
    
        private final JTextArea info;
    
        public GlobalMouseListener() {
            info = new JTextArea();
            // 关闭日志
            Logger.getLogger(GlobalScreen.class.getPackage().getName()).setLevel(Level.OFF);
    
            setTitle("GlobalMouseListener");
            setLayout(new BorderLayout());
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setSize(600, 300);
    
            info.setEditable(false);
            info.setBackground(new Color(0xFF, 0xFF, 0xFF));
            info.setForeground(new Color(0x00, 0x00, 0x00));
            info.setText("");
    
            JScrollPane scrollPane = new JScrollPane(info);
            scrollPane.setPreferredSize(new Dimension(375, 125));
            add(scrollPane, BorderLayout.CENTER);
    
            try {
                GlobalScreen.registerNativeHook();
            } catch (NativeHookException e) {
                e.printStackTrace();
                info.append("Error: " + e.getMessage() + "\n");
            }
            GlobalScreen.addNativeMouseListener(this);
    
            setVisible(true);
        }
    
        /**
         * @see NativeMouseListener#nativeMouseClicked(NativeMouseEvent)
         */
        public void nativeMouseClicked(NativeMouseEvent e) {
            appendDisplay(e.paramString());
        }
    
        /**
         * @see NativeMouseListener#nativeMousePressed(NativeMouseEvent)
         */
        public void nativeMousePressed(NativeMouseEvent e) {
            appendDisplay(e.paramString());
        }
    
        /**
         * @see NativeMouseListener#nativeMouseReleased(NativeMouseEvent)
         */
        public void nativeMouseReleased(NativeMouseEvent e) {
            appendDisplay(e.paramString());
        }
    
        /**
         * @see NativeMouseMotionListener#nativeMouseMoved(NativeMouseEvent)
         */
        public void nativeMouseMoved(NativeMouseEvent e) {
            appendDisplay(e.paramString());
        }
    
        /**
         * @see NativeMouseMotionListener#nativeMouseDragged(NativeMouseEvent)
         */
        public void nativeMouseDragged(NativeMouseEvent e) {
            appendDisplay(e.paramString());
        }
    
        private void appendDisplay(final String output) {
            info.append(output + "\n");
            try {
                if (info.getLineCount() > 100) {
                    info.replaceRange("", 0, info.getLineEndOffset(info.getLineCount() - 1 - 100));
                }
                info.setCaretPosition(info.getLineStartOffset(info.getLineCount() - 1));
            } catch (BadLocationException ex) {
                info.setCaretPosition(info.getDocument().getLength());
            }
        }
    
        public static void main(String[] args) {
            SwingUtilities.invokeLater(GlobalMouseListener::new);
        }
    }
    

    maven

            <!-- https://mvnrepository.com/artifact/com.1stleg/jnativehook -->
            <dependency>
                <groupId>com.1stleg</groupId>
                <artifactId>jnativehook</artifactId>
                <version>2.1.0</version>
            </dependency>

    技术点

    JNativeHook

    参考链接

    [1] kwhat.JNativeHook: Global keyboard and mouse listeners for Java..2021-03-24 12:29

    https://github.com/kwhat/jnativehook

    [2] codeday.java-如何从JNativeHook库中删除日志记录数据.2019-10-29

    http://www.cocoachina.com/articles/99009

     

     

    展开全文
  • java全局鼠标键盘监听

    千次阅读 2015-09-18 21:42:35
    鼠标和键盘,这两个侦听器都有很大的限制:鼠标监听只有在鼠标位于Java程序所在的窗口范围之内才能有效,而键盘监听限制更严 格,仅当Java程序成为当前的活动窗口时才有效。很显然,单纯用Java来实现全屏幕、所有...

    Java提供了两个事件侦听接口用来管理鼠标移动和键盘动作,分别是MouseMotionListener和KeyListener,可以用它们来捕捉鼠标和键盘,这两个侦听器都有很大的限制:鼠标监听只有在鼠标位于Java程序所在的窗口范围之内才能有效,而键盘监听限制更严格,仅当Java程序成为当前的活动窗口时才有效。很显然,单纯用Java来实现全屏幕、所有程序鼠标和键盘的话动是不行的。

            实现办法可以用JNI调用本地库或者调用第三方库比如jintellitypeSWT Win32 Extension等来实现,但是想跨平台就有点困难了。

     

    展开全文
  • Java监听键盘鼠标全局事件

    千次阅读 2012-02-29 17:43:24
    标准的Java键盘事件监听器(KeyListener)和鼠标事件监听器...要想让你的Java程序能够在系统后台跟踪全局键盘和鼠标事件,那就需要使用JNI(Java Native Interface)来创建一个钩子监听操作系统的事件了。本

    转自:http://dengpeng.sensorapp.net/?p=495


    标准的Java键盘事件监听器(KeyListener)和鼠标事件监听器(MouseListener)只能在该Java程序聚焦的时候监听事件。要想让你的Java程序能够在系统后台跟踪全局键盘和鼠标事件,那就需要使用JNI(Java Native Interface)来创建一个钩子监听操作系统的事件了。本文只讨论,Java程序与Windows操作系统的交互,如果你知道如何实现Java监听Linux事件,请留言,谢谢。开发运行环境:Windows XP SP3, Java 1.6_15, Eclipse 3.5

    直接上代码

    SysHook.cpp:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    #include <windows.h>
    #include "SysHook.h"
    #include <jni.h>
     
    HINSTANCE hInst = NULL;
     
    JavaVM * jvm = NULL;
    jobject hookObj_kb = NULL;
    jobject hookObj_ms = NULL;
    jobject g_kl = NULL;
     
    jmethodID processKeyID_kb = NULL;
    jmethodID processKeyID_ms = NULL;
    DWORD hookThreadId = 0;
     
    LONG    g_mouseLocX = -1;    // x-location of mouse position
    LONG    g_mouseLocY = -1;    // y-location of mouse position
     
    extern "C"
    BOOL APIENTRY DllMain(HINSTANCE _hInst, DWORD reason, LPVOID reserved)
    {
     switch (reason)
     {
     case DLL_PROCESS_ATTACH:
     printf("C++: DllMain - DLL_PROCESS_ATTACH.\n");
     hInst = _hInst;
     break;
     default:
     break;
     }
     
    return TRUE;
    }
     
    LRESULT CALLBACK MouseTracker(int nCode, WPARAM wParam, LPARAM lParam)
    {
     JNIEnv * env;
     KBDLLHOOKSTRUCT * p = (KBDLLHOOKSTRUCT *)lParam;
     
     if (jvm->AttachCurrentThread((void **)&env, NULL) >= 0)
     {
     
     if (nCode==HC_ACTION)
     {
     MOUSEHOOKSTRUCT* pStruct = (MOUSEHOOKSTRUCT*)lParam;
     if (pStruct->pt.x != g_mouseLocX || pStruct->pt.y != g_mouseLocY)
     {
     env->CallVoidMethod(hookObj_ms, processKeyID_ms, (jint)pStruct->pt.x,(jint)pStruct->pt.y, g_kl);
     g_mouseLocX = pStruct->pt.x;
     g_mouseLocY = pStruct->pt.y;
     }
     
     }
     
     }
     else
     {
     printf("C++: LowLevelKeyboardProc - Error on the attach current thread.\n");
     }
     
     return CallNextHookEx(NULL, nCode, wParam, lParam);
    }
     
    LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
    {
     JNIEnv * env;
     KBDLLHOOKSTRUCT * p = (KBDLLHOOKSTRUCT *)lParam;
     
     if (jvm->AttachCurrentThread((void **)&env, NULL) >= 0)
     {
     switch (wParam)
     {
     case WM_KEYDOWN:
     case WM_SYSKEYDOWN:
     env->CallVoidMethod(hookObj_kb, processKeyID_kb, (jboolean)TRUE, p->vkCode,g_kl);
     break;
     case WM_KEYUP:
     case WM_SYSKEYUP:
     env->CallVoidMethod(hookObj_kb, processKeyID_kb, (jboolean)FALSE, p->vkCode,g_kl);
     break;
     default:
     break;
     }
     }
     else
     {
     printf("C++: LowLevelKeyboardProc - Error on the attach current thread.\n");
     }
     
     return CallNextHookEx(NULL, nCode, wParam, lParam);
    }
     
    void MsgLoop()
    {
     MSG message;
     while (GetMessage(&message, NULL, 0, 0))
     {
     TranslateMessage(&message);
     DispatchMessage(&message);
     }
    }
     
    JNIEXPORT void JNICALL Java_SysHook_registerHook(JNIEnv * env, jobject obj,jobject kl)
    {
     HHOOK hookHandle_ms = SetWindowsHookEx(WH_MOUSE_LL, MouseTracker, hInst, 0);
     HHOOK hookHandle_kb = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, hInst, 0);
     
     g_kl = kl;
     
     if (hookHandle_ms == NULL)
     {
     printf("C++: Java_SysHook_registerKeyHook - Hook failed!\n");
     return;
     }
     else
     {
     printf("C++: Java_SysHook_registerKeyHook - Hook successful\n");
     }
     
     if (hookHandle_kb == NULL)
     {
     printf("C++: Java_SysHook_registerKeyHook - Hook failed!\n");
     return;
     }
     else
     {
     printf("C++: Java_SysHook_registerKeyHook - Hook successful\n");
     }
     
     hookObj_kb = env->NewGlobalRef(obj);
     jclass cls_kb = env->GetObjectClass(hookObj_kb);
     processKeyID_kb = env->GetMethodID(cls_kb, "processKey", "(ZILGlobalEventListener;)V");
     
     hookObj_ms = env->NewGlobalRef(obj);
     jclass cls_ms = env->GetObjectClass(hookObj_ms);
     processKeyID_ms = env->GetMethodID(cls_ms, "mouseMoved", "(IILGlobalEventListener;)V");
     
     env->GetJavaVM(&jvm);
     hookThreadId = GetCurrentThreadId();
     
     MsgLoop();
     
     if (!UnhookWindowsHookEx(hookHandle_kb))
     {
     printf("C++: Java_SysHook_registerKeyHook - Unhook failed\n");
     }
     else
     {
     printf("C++: Java_SysHook_registerKeyHook - Unhook successful\n");
     }
     
     if (!UnhookWindowsHookEx(hookHandle_ms))
     {
     printf("C++: Java_SysHook_registerKeyHook - Unhook failed\n");
     }
     else
     {
     printf("C++: Java_SysHook_registerKeyHook - Unhook successful\n");
     }
    }
     
    JNIEXPORT void JNICALL Java_SysHook_unRegisterHook(JNIEnv *env, jobject object)
    {
     if (hookThreadId == 0)
     return;
     
     printf("C++: Java_SysHook_unRegisterKeyHook - call PostThreadMessage.\n");
     PostThreadMessage(hookThreadId, WM_QUIT, 0, 0L);
    }

    SysHook.h:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    /* DO NOT EDIT THIS FILE - it is machine generated */
    #include <jni.h>
    /* Header for class SysHook */
     
    #ifndef _Included_SysHook
    #define _Included_SysHook
    #ifdef __cplusplus
    extern "C" {
    #endif
    /*
     * Class:     SysHook
     * Method:    registerHook
     * Signature: (LGlobalEventListener;)V
     */
    JNIEXPORT void JNICALL Java_SysHook_registerHook  (JNIEnv *, jobject, jobject);
     
    /*
     * Class:     SysHook
     * Method:    unRegisterHook
     * Signature: ()V
     */
    JNIEXPORT void JNICALL Java_SysHook_unRegisterHook  (JNIEnv *, jobject);
     
    #ifdef __cplusplus
    }
    #endif
    #endif

    KeyboardEventListener.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    import java.util.*;
     
    public interface KeyboardEventListener extends EventListener {
     public void GlobalKeyPressed(KeyboardEvent event);
     
     public void GlobalKeyReleased(KeyboardEvent event);
    }
     
    class KeyboardEvent extends EventObject {
     private static final long serialVersionUID = 2341653211621224652L;
     boolean ts, ap, ek;
     int vk;
     
     public KeyboardEvent(Object source, boolean ts, int vk, boolean ap,
     boolean ek) {
     super(source);
     this.ts = ts;
     this.vk = vk;
     this.ap = ap;
     this.ek = ek;
     }
     
     public boolean getTransitionState() {
     return ts;
     }
     
     public long getVirtualKeyCode() {
     return vk;
     }
     
     public boolean isAltPressed() {
     return ap;
     }
     
     public boolean isExtendedKey() {
     return ek;
     }
     
     public boolean equals(KeyboardEvent event) {
     if (event.getVirtualKeyCode() == vk) {
     if (event.isExtendedKey() == ek) {
     if (event.isAltPressed() == ap) {
     return true;
     }
     }
     }
     return false;
     }
    }

    MouseEventListenter.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    import java.util.*;
     
    public interface MouseEventListener extends EventListener {
     public void GlobalMouseX(MouseEvent event);
     
     public void GlobalMouseY(MouseEvent event);
    }
     
    class MouseEvent extends EventObject {
     
     private static final long serialVersionUID = 14654L;
     int cord_x, cord_y;
     
     public MouseEvent(Object source, int cord_x, int cord_y) {
     super(source);
     this.cord_x = cord_x;
     this.cord_y = cord_y;
     }
     
     public int getMouseX() {
     return cord_x;
     }
     
     public int getMouseY() {
     return cord_y;
     }
     
    }

    GlobalEventListener.java :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    public class GlobalEventListener {
     PoolHook pt;
     
     public GlobalEventListener() {
     pt = new PoolHook(this);
     pt.start();
     
     }
     
     protected javax.swing.event.EventListenerList listenerList = new javax.swing.event.EventListenerList();
     
     public void addKeyboardEventListener(KeyboardEventListener listener) {
     listenerList.add(KeyboardEventListener.class, listener);
     }
     
     public void removeKeyboardEventListener(KeyboardEventListener listener) {
     listenerList.remove(KeyboardEventListener.class, listener);
     }
     
     public void addMouseEventListener(MouseEventListener listener) {
     listenerList.add(MouseEventListener.class, listener);
     }
     
     public void removeMouseEventListener(MouseEventListener listener) {
     listenerList.remove(MouseEventListener.class, listener);
     }
     
     void keyPressed(KeyboardEvent event) {
     Object[] listeners = listenerList.getListenerList();
     for (int i = 0; i < listeners.length; i += 2) {
     if (listeners[i] == KeyboardEventListener.class) {
     ((KeyboardEventListener) listeners[i + 1])
     .GlobalKeyPressed(event);
     }
     }
     }
     
     void mouseMoved(MouseEvent event) {
     Object[] listeners = listenerList.getListenerList();
     for (int i = 0; i < listeners.length; i += 2) {
     if (listeners[i] == MouseEventListener.class) {
     ((MouseEventListener) listeners[i + 1]).GlobalMouseX(event);
     ((MouseEventListener) listeners[i + 1]).GlobalMouseY(event);
     }
     }
     }
     
     void keyReleased(KeyboardEvent event) {
     Object[] listeners = listenerList.getListenerList();
     for (int i = 0; i < listeners.length; i += 2) {
     if (listeners[i] == KeyboardEventListener.class) {
     ((KeyboardEventListener) listeners[i + 1])
     .GlobalKeyReleased(event);
     }
     }
     }
     
    }

    SysHook.java:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    class PoolHook extends Thread {
     SysHook hook;
     GlobalEventListener g_gl;
     
     PoolHook(GlobalEventListener gl) {
     g_gl = gl;
     }
     
     public void run() {
     hook = new SysHook();
     hook.registerHook(g_gl);
     }
     
    }
     
    class SysHook {
     
     static {
     System.loadLibrary("SysHook");
     }
     
     void processKey(boolean ts, int vk, GlobalEventListener gl) {
     KeyboardEvent event = new KeyboardEvent(this, ts, vk, false, false);
     gl.keyPressed(event);
     }
     
     void mouseMoved(int cord_x, int cord_y, GlobalEventListener gl) {
     MouseEvent event = new MouseEvent(this, cord_x, cord_y);
     gl.mouseMoved(event);
     }
     
     native void registerHook(GlobalEventListener gl);
     
     native void unRegisterHook();
     
    }

    Example.java:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    public class Example implements KeyboardEventListener, MouseEventListener {
     
     static GlobalEventListener gl;
     
     public static void main(String[] args) throws Exception {
     Example inst = new Example();
     gl = new GlobalEventListener();
     gl.addKeyboardEventListener(inst);
     gl.addMouseEventListener(inst);
     }
     
     @Override
     public void GlobalKeyPressed(KeyboardEvent event) {
     
     System.out.println("Key Pressed: " + event.getVirtualKeyCode());
     }
     
     @Override
     public void GlobalKeyReleased(KeyboardEvent event) {
     }
     
     @Override
     public void GlobalMouseX(MouseEvent event) {
     System.out.println("Mouse X: " + event.getMouseX());
     
     }
     
     @Override
     public void GlobalMouseY(MouseEvent event) {
     System.out.println("Mouse Y: " + event.getMouseY());
     }
     
    }

    C++文件需要用Visual Studio编译为你的目标系统的DLL文件。如果是标准32位Windows XP,可以在这里下载已编译的文件。

    在Eclipse创建工程后,需要做的设置是将该DLL所在目录添加到Native library location如图:

    本文摘录、翻译并修改自http://www.jotschi.de/?p=90



    展开全文
  • #include <windows.h> #include "SysHook.h" #include <jni.h> HINSTANCEhInst = NULL; JavaVM * jvm = NULL; jobject hookObj_kb = NULL; jobject hookObj_ms = NULL; jobject g_kl = NULL; jmethodID processKeyID
  • 有时候在网页上点一下,上方出现一个五颜六色...其中的全局鼠标点击监听源码来自于:https://blog.csdn.net/capricio/article/details/83213309感谢。 颜文字的悬浮类: package com.ui; import java.awt.Color...

    有时候在网页上点一下,上方出现一个五颜六色的颜文字,觉得挺好玩的,js我已经试过了,就想着搬到桌面上来,就用java写了一个小应用,源码如下:

    其中的全局鼠标点击监听源码来自于:https://blog.csdn.net/capricio/article/details/83213309 感谢。

    颜文字的悬浮类:

    package com.ui;
    
    import java.awt.Color;
    import java.util.Random;
    
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    
    /**
     * 随机表情颜色窗口 创建后1秒后自动销毁窗口
     *
     */
    public class Special extends JFrame {
    	private static final long serialVersionUID = 1L;
    	private final int WIDTH = 100, HEIGHT = 30;
    	private JLabel doc;
    
    	public Special(int x, int y) {
    		// 隐藏标题栏
    		setUndecorated(true);
    		// 背景透明
    		setBackground(new Color(0, 0, 0, 0));
    		// 窗口置顶
    		setAlwaysOnTop(true);
    		// 隐藏任务栏图标
    		setType(JFrame.Type.UTILITY);
    		// 设置窗口位置和坐标
    		setBounds(x, y, WIDTH, HEIGHT);
    		// 设置文本标签
    		setData();
    		// 将窗体设为可见
    		setVisible(true);
    		// 线程关闭窗口
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				int top = y;
    				// 每100ms循环一次,1.2s后循环完成
    				for (float i = 1; i <= 12; i += 2) {
    					// 变浅窗口
    					setOpacity(1f - i / 12);
    					// 窗口上移
    					top -= 4;
    					// 定位在鼠标当前位置
    					setBounds(x, top, WIDTH, HEIGHT);
    					try {
    						Thread.sleep(100);
    					} catch (Exception e) {
    						System.err.println("窗体延迟消失时出错");
    					}
    				}
    				// 关闭窗口
    				dispose();
    			}
    		}).start();
    	}
    
    	/**
    	 * 设置显示的文本
    	 */
    	private void setData() {
    		Random random = new Random();
    		String[] brow = { "(*^▽^*)", "o(´^`)o", "(•́へ•́╬)", "!!!∑(゚Д゚ノ)ノ", "ᕦ(・ㅂ・)ᕤ", "ヽ(・ω・´メ)", "(๑•ω•๑)", "ヽ(#`Д´)ノ",
    				"o(╥﹏╥)o", "罒ω罒" };
    		doc = new JLabel(brow[random.nextInt(brow.length)], JLabel.CENTER);
    		doc.setForeground(new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)));
    		doc.setBounds(0, 0, WIDTH, HEIGHT);
    		doc.setOpaque(false);
    		add(doc);
    	}
    }
    

    点击监听的类:

    package com.ui;
    
    import java.awt.MouseInfo;
    import java.awt.Point;
    
    import javax.swing.JFrame;
    
    import com.sun.jna.platform.win32.Kernel32;
    import com.sun.jna.platform.win32.User32;
    import com.sun.jna.platform.win32.WinDef.HMODULE;
    import com.sun.jna.platform.win32.WinDef.LRESULT;
    import com.sun.jna.platform.win32.WinDef.WPARAM;
    import com.sun.jna.platform.win32.WinUser;
    
    /**
     * 按键点击触发特效
     *
     */
    public class ClickListener extends JFrame {
    	private static final long serialVersionUID = 1L;
    
    	public static final int WM_MOUSEMOVE = 512;
    	public static final int WM_LEFT_BUTTONDOWN = 513;
    	public static final int WM_LEFT_BUTTONUP = 514;
    	public static final int WM_RIGHT_BUTTONDOWN = 516;
    	public static final int WM_RIGHT_BUTTONUP = 517;
    	public static final int WM_MID_BUTTONDOWN = 519;
    	public static final int WM_MID_BUTTONUP = 520;
    
    	private WinUser.HHOOK hhk;
    
    	public ClickListener() {
    		setHookOn();
    	}
    
    	/**
    	 * 钩子的回调函数
    	 */
    	private WinUser.LowLevelKeyboardProc mouseProc = new WinUser.LowLevelKeyboardProc() {
    
    		@Override
    		public LRESULT callback(int nCode, WPARAM wParam, WinUser.KBDLLHOOKSTRUCT event) {
    			if (nCode >= 0) {
    				if (wParam.intValue() == WM_LEFT_BUTTONUP) {
    					Point pinfo = MouseInfo.getPointerInfo().getLocation();
    					new Special((int) pinfo.getX() - 50, (int) pinfo.getY() - 35);
    				}
    			}
    			return User32.INSTANCE.CallNextHookEx(hhk, nCode, wParam, null);
    		}
    
    	};
    
    	/**
    	 * 安装钩子
    	 */
    	public void setHookOn() {
    		HMODULE hMod = Kernel32.INSTANCE.GetModuleHandle(null);
    		hhk = User32.INSTANCE.SetWindowsHookEx(User32.WH_MOUSE_LL, mouseProc, hMod, 0);
    		int result;
    		WinUser.MSG msg = new WinUser.MSG();
    		while ((result = User32.INSTANCE.GetMessage(msg, null, 0, 0)) != 0) {
    			if (result == -1) {
    				setHookOff();
    				break;
    			} else {
    				User32.INSTANCE.TranslateMessage(msg);
    				User32.INSTANCE.DispatchMessage(msg);
    			}
    		}
    	}
    
    	/**
    	 * 卸载钩子
    	 */
    	public void setHookOff() {
    		User32.INSTANCE.UnhookWindowsHookEx(hhk);
    	}
    
    	public static void main(String[] args) {
    		new ClickListener();
    	}
    }
    

    实现的效果如下图:(我点了4下)

     

    展开全文
  • java鼠标监听器源码GKM 基于事件的全局键盘和鼠标侦听器。 在 Windows 7 上测试过,但也可以在 Linux 和 Mac OS X 上运行(未经测试)。 为什么? Node 当时没有任何可用的全局键盘和鼠标侦听器。 要求 GKM 依赖于在...
  • java调用cpp生成文件来实现全局键盘鼠标动作监听20180228
  • JAVA的swing只能监听本应用的鼠标键盘事件,但是使用JAVA的JNA工具则可做到鼠标与键盘的全局监听。有了这样的工具,配合swing robot就可以实现类似键盘精灵的功能。 以下这段代码是JNA调用的核心代码,只适用于win...
  • 前段时间,闲来无聊,想做个像QQ截图一样的截图工具,在却在做的过程中发现java自带API中的监听器带有很大的局限性,java鼠标监听器只有在鼠标在程序窗口之上时才会生效,而键盘监听器则更加局限,只有在当前窗
  • jnativehook, 用于Java全局键盘和鼠标侦听器 JNativeHook是... 这将允许你监听全局快捷方式或者鼠标运动,否则使用纯Java就不可能。 为了完成这项任务,JNativeHook利用平台依赖的本机代码来创建低级别系统的宽挂钩。
  • Java(低级)系统挂钩为Java提供了非常轻量级的全局键盘和鼠标侦听器。 通常,如果注册的组件处于焦点位置,则Java中的键盘和鼠标事件仅起作用。 例如,在任何窗口失去焦点(例如最小化)的情况下,它将停止接收更多...
  • 1.前段时间,闲来无聊,想做个像QQ截图一样的截图工具,在却在做的过程中发现java自带API中的监听器带有很大的局限性,java鼠标监听器只有在鼠标在程序窗口之上时才会生效,而键盘监听器则更加局限,只有在当前...
  • 前段时间,闲来无聊,想做个像QQ截图一样的截图工具,在却在做的过程中发现java自带API中的监听器带有很大的局限性,java鼠标监听器只有在鼠标在程序窗口之上时才会生效,而键盘监听器则更加局限,只有在当前窗口...
  • 1.jintellitype-1.3.9.jar包,用于Java键盘全局监听,内有JIntellitype.dll、JIntellitype64.dll、jintellitype-1.3.9.jar; 2.java用jna实现后台键盘和鼠标监听时需要的jna.jar、platform.jar文件,亲测有用!
  • 我用JIntellitype实现全局热键设置,监听键盘事件ctrl+c和ctrl+v并且与系统剪贴板结合,当用户按下ctrl+v时打印出用户复制的存于剪贴板中的内容,现在情况是这样的当用户按快捷键ctrl+C复制时复制的内容并没有存入...
  • Java 实现 Hook 对鼠标键盘监听

    千次阅读 2009-08-06 20:09:00
    Java 实现全局(全操作系统)的鼠标和键盘监控,使用的是SWT Win32 Extension 项目,在以前若使用Java恐怕是很难实现的!SWT Win32 Extension 让Java拥有了许多对操作系统底层操作的功能! 注:本程序需要SWT Win32...
  • java Swing 鼠标图标的改变 先创建一个Swing窗口 然后将要用的变量定义...然后在按钮处添加鼠标监听 并且选择鼠标移入事件和离开事件 这里是改变鼠标图标的代码 ```java //鼠标图标 tk=Toolkit.getDefaultToolkit();
  • 那么首先声明一个JLabel的变量(注意是全局变量),在构造方法里面赋值,使用ImageIcon,同时可以设置鼠标监听事件,当鼠标放在上面就可以改变颜色了,下面是具体代码: package bk_01; import java.awt.Color; ...
  • 按键记录器 这是一个简单的Java应用程序,用于记录键盘和鼠标输入的顺序,延迟以及使用热键进行播放。 如何使用它 要记录序列,请运行RecordMain 按下键盘1(NumLock开启)创建序列,并...用于监听全局键盘和鼠标的运动
  • //定义全局变量:可以在所有位置使用 private static final long serialVersionUID = 1L; public PlaneFrame(){ this.setSize(400, 654); //x y? this.setLocation(150,50); this.setIconImage(new ...
  • 实现了全局键盘、鼠标监听,当你的窗口失去焦点时依然能够起作用。利用c++获取了系统的钩子,变异成dll文件之后,java再使用dll文件实现全局键盘鼠标监听
  • 都知道java中类只能单继承,但可以实现多个接口,但我发现实现多个接口之后,多个接口却不能共享同一个数据,应用开发中想实现:当用户按着ctrl键时,可以用鼠标点击拖动组件,比如说文本框。 编写一个监听实现...
  • Java开发实战1200例.第2卷.part3

    热门讨论 2013-05-08 22:46:34
    实例002 CSS改变XML中鼠标指针形状 5 实例003 CSS在XML中添加背景图 7 实例004 CSS制作XML表格 8 实例005 XML中的提取节点字符串值 10 实例006 在XML内部定义DTD 12 实例007 在XML外部引用DTD 14 实例008 验证XML...
  • Java开发实战1200例.第2卷.part2

    热门讨论 2013-05-08 22:45:35
    实例002 CSS改变XML中鼠标指针形状 5 实例003 CSS在XML中添加背景图 7 实例004 CSS制作XML表格 8 实例005 XML中的提取节点字符串值 10 实例006 在XML内部定义DTD 12 实例007 在XML外部引用DTD 14 实例008 验证XML...
  • Java开发实战1200例.第2卷.part1

    热门讨论 2013-05-08 22:44:13
    实例002 CSS改变XML中鼠标指针形状 5 实例003 CSS在XML中添加背景图 7 实例004 CSS制作XML表格 8 实例005 XML中的提取节点字符串值 10 实例006 在XML内部定义DTD 12 实例007 在XML外部引用DTD 14 实例008 验证XML...
  • netscanner.rar

    2020-08-31 16:14:38
    使用java引用别的包,进行键盘的全局监听,在java程序界面外边也可以实现监听键盘的操作,当按下一个键后可以实现一个方法,比如按下一个键可以实现鼠标的连点,用途:枪战游戏的压枪连点
  • 这个包是用来进行java本身无法完成的鼠标全局监听的包,本项目提供了一个软件开发工具库,能够让您使用Java语言开发原生的Windows应用程序而不需要编写额外的JNI代码。 使用SWT Win32 Extension,您将不需要创建...
  • 实例002 CSS改变XML中鼠标指针形状 实例003 CSS在XML中添加背景图 实例004 CSS制作XML表格 实例005 XML中的提取节点字符串值 实例006 在XML内部定义DTD 实例007 在XML外部引用DTD 实例008 验证XML是否符合DTD的定义 ...

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

java全局监听鼠标

java 订阅