急！如何取得系统桌面鼠标的单，双击事件！

Question

如何取得系统桌面鼠标的单、双击事件啊，谢谢给个实例啊

Answer 1

安装鼠标钩子，然后再钩子函数中判断按键，键位满足条件再判断消息的窗口句柄，窗口句柄的获取方法可以通过API函数来实现，给你的C++的获取桌面句柄的函数，自己改下。
HWND   GetDesktopListViewHandle(void) 
{ 
HWND   hResult; 
hResult=::FindWindow( "ProgMan ",NULL); 
hResult=::GetWindow(hResult,GW_CHILD); 
hResult=::GetWindow(hResult,GW_CHILD); 
return   hResult; 
} 

Answer 2

首先你要知道怎么写全局钩子，用C++写个钩鼠标的DLL
HHOOK SetWindowsHookEx(//安装钩子
  int idHook,        // hook type
  HOOKPROC lpfn,     // hook procedure（MouseProc）
  HINSTANCE hMod,    // handle to application instance
  DWORD dwThreadId   // thread identifier
);
LRESULT CALLBACK MouseProc(
  int nCode,      // hook code
  WPARAM wParam,  // 这个参数判断单击还是双击
  LPARAM lParam   // 这个参数指向下面那个结构体
);
typedef struct tagMOUSEHOOKSTRUCT { 
    POINT     pt; 
    HWND      hwnd; //这是接受消息的窗口句柄，这里判断是否等于桌面窗口的句柄
    UINT      wHitTestCode; 
    ULONG_PTR dwExtraInfo; 
} MOUSEHOOKSTRUCT, *PMOUSEHOOKSTRUCT; 

Answer 3

一个全局键盘、鼠标钩子  封装类  参考
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Reflection;namespace Test
{
    
   
    [StructLayout(LayoutKind.Sequential)]
    public class POINT 
    {
        public int x;
        public int y;
    }    
    [StructLayout(LayoutKind.Sequential)]
    public class MouseHookStruct 
    {
        public POINT pt;
        public int hwnd;
        public int wHitTestCode;
        public int dwExtraInfo;
    }   
    [StructLayout(LayoutKind.Sequential)]
    public class KeyboardHookStruct
    {
        public int vkCode; 
        public int scanCode; 
        public int flags; 
        public int time;
        public int dwExtraInfo;
    }    public class GlobalHook
    {
        public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);        public GlobalHook() 
        {
            Start();
        }        ~GlobalHook() 
        { 
            Stop();
        }         public event MouseEventHandler OnMouseActivity;
        public event KeyEventHandler KeyDown;
        public event KeyPressEventHandler KeyPress;
        public event KeyEventHandler KeyUp;        public delegate int GlobalHookProc(int nCode, Int32 wParam, IntPtr lParam);        static int hMouseHook = 0; 
        static int hKeyboardHook = 0;       
        public const int WH_MOUSE_LL = 14; 
        public const int WH_KEYBOARD_LL = 13;         GlobalHookProc MouseHookProcedure;
        GlobalHookProc KeyboardHookProcedure;         
        [DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, GlobalHookProc lpfn, 
            IntPtr hInstance, int threadId);        
        [DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);       
        [DllImport("user32.dll",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode, 
            Int32 wParam, IntPtr lParam);         public void Start()
        {
            
            if(hMouseHook == 0)
            {
               
                MouseHookProcedure = new GlobalHookProc(MouseHookProc);                try
                {
                    hMouseHook = SetWindowsHookEx(WH_MOUSE_LL,
                        MouseHookProcedure,
                        Marshal.GetHINSTANCE(
                        Assembly.GetExecutingAssembly().GetModules()[0]),
                        0);
                }
                catch (Exception err)
                { }               
                if(hMouseHook == 0 ) 
                {
                    Stop();
                    throw new Exception("SetWindowsHookEx failed.");
                }
            }          
            if(hKeyboardHook == 0)
            {
                KeyboardHookProcedure = new GlobalHookProc(KeyboardHookProc);
                try
                {
                    hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL,
                        KeyboardHookProcedure,
                        Marshal.GetHINSTANCE(
                        Assembly.GetExecutingAssembly().GetModules()[0]),
                        0);
                }
                catch (Exception err2)
                { }               
                if(hKeyboardHook == 0 ) 
                {
                    Stop();
                    throw new Exception("SetWindowsHookEx ist failed.");
                }
            }
        }        public void Stop()
        {
            bool retMouse =true;
            bool retKeyboard = true;
            if(hMouseHook != 0)
            {
                retMouse = UnhookWindowsHookEx(hMouseHook);
                hMouseHook = 0;
            }             if(hKeyboardHook != 0)
            {
                retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
                hKeyboardHook = 0;
            }             
            if (!(retMouse && retKeyboard)) 
                throw new Exception("UnhookWindowsHookEx failed.");
        }        private const int WM_MOUSEMOVE = 0x200;
        private const int WM_LBUTTONDOWN = 0x201;
        private const int WM_RBUTTONDOWN = 0x204;
        private const int WM_MBUTTONDOWN = 0x207;
        private const int WM_LBUTTONUP = 0x202;
        private const int WM_RBUTTONUP = 0x205;
        private const int WM_MBUTTONUP = 0x208;
        private const int WM_LBUTTONDBLCLK = 0x203;
        private const int WM_RBUTTONDBLCLK = 0x206;
        private const int WM_MBUTTONDBLCLK = 0x209;        private int MouseHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
           
            if ((nCode >= 0) && (OnMouseActivity!=null)) 
            {
                MouseButtons button=MouseButtons.None;
                switch (wParam)
                {
                    case WM_LBUTTONDOWN: 
                        //case WM_LBUTTONUP: 
                        //case WM_LBUTTONDBLCLK: 
                        button=MouseButtons.Left; 
                        break;
                    case WM_RBUTTONDOWN: 
                        //case WM_RBUTTONUP: 
                        //case WM_RBUTTONDBLCLK: 
                        button=MouseButtons.Right; 
                        break;
                }
                int clickCount=0;
                if (button!=MouseButtons.None)
                    if (wParam==WM_LBUTTONDBLCLK || wParam==WM_RBUTTONDBLCLK) 
                        clickCount=2;
                else 
                    clickCount=1;              
                MouseHookStruct MyMouseHookStruct =
                    (MouseHookStruct) Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));
                MouseEventArgs e=new MouseEventArgs(
                    button, 
                    clickCount, 
                    MyMouseHookStruct.pt.x, 
                    MyMouseHookStruct.pt.y, 
                    0 );
                OnMouseActivity(this, e);
            }
            return CallNextHookEx(hMouseHook, nCode, wParam, lParam); 
        }       
        [DllImport("user32")] 
        public static extern int ToAscii(int uVirtKey, 
            int uScanCode, 
            byte[] lpbKeyState,
            byte[] lpwTransKey, 
            int fuState);        [DllImport("user32")] 
        public static extern int GetKeyboardState(byte[] pbKeyState);        private const int WM_KEYDOWN = 0x100;
        private const int WM_KEYUP = 0x101;
        private const int WM_SYSKEYDOWN = 0x104;
        private const int WM_SYSKEYUP = 0x105;        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
          
            if ((nCode >= 0) && (KeyDown!=null || KeyUp!=null || KeyPress!=null))
            {
                KeyboardHookStruct MyKeyboardHookStruct = 
                    (KeyboardHookStruct) Marshal.PtrToStructure(lParam,
                    typeof(KeyboardHookStruct));
              
                if ( KeyDown!=null && ( wParam ==WM_KEYDOWN || wParam==WM_SYSKEYDOWN ))
                {
                    Keys keyData=(Keys)MyKeyboardHookStruct.vkCode;
                    KeyEventArgs e = new KeyEventArgs(keyData);
                    KeyDown(this, e);
                }               
                if ( KeyPress!=null && wParam ==WM_KEYDOWN )
                {
                    byte[] keyState = new byte[256];
                    GetKeyboardState(keyState);                    byte[] inBuffer= new byte[2];
                    if (ToAscii(MyKeyboardHookStruct.vkCode,
                        MyKeyboardHookStruct.scanCode,
                        keyState,
                        inBuffer,
                        MyKeyboardHookStruct.flags)==1) 
                    {
                        KeyPressEventArgs e = new KeyPressEventArgs((char)inBuffer[0]);
                        KeyPress(this, e);
                    }
                }             
                if ( KeyUp!=null && ( wParam ==WM_KEYUP || wParam==WM_SYSKEYUP ))
                {
                    Keys keyData=(Keys)MyKeyboardHookStruct.vkCode;
                    KeyEventArgs e = new KeyEventArgs(keyData);
                    KeyUp(this, e);
                }
            }
            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam); 
        }
    }
}

Answer 4

楼主的意思应该是点击后出现Windows桌面一样的菜单吧.相当于在Listview中右击图标显示系统菜单?