备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

用 WPF 写的颜色拾取器

2017-10-25 1371
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

之前都是用别人的颜色拾取器，今天自己用WPF写了一个颜色拾取器小程序 拾取鼠标所在位置的颜色，按键盘上的空格键停止取色

程序下载：MyWPFScreenColorE.rar 

程序里面有一个全局的勾子实现键盘的按下事件停止拾取（有全局勾子可能会报毒 勾子总被用于木马 现在的杀软对勾子很警惕 ）

但是我还没有好的办法不用勾子去实现停止拾取，如果看到帖子的人有好的办法请指点一下，谢谢。

是基于framework 3.5

用vs2008开发的

操作：

1点击开始取色就会根据鼠标的移动记录下鼠标下的颜色并显示在颜色预览里

2,按键盘上的空格键就会停止取色，自己复制下来RGB的值

开发思路：

1记录鼠标的坐标

2拾取鼠标下的颜色

开始上代码开发吧

记录鼠标的坐标

public  class  MyPoint
    {
        [StructLayout(LayoutKind.Sequential)]
        public  struct  POINT
        {
            public  int  X;
            public  int  Y;
            public  POINT( int  x, int  y)
            {
                this .X = x;
                this .Y = y;
            }
        }
 
        [DllImport( "user32.dll" , CharSet = CharSet.Auto)]
        public  static  extern  bool  GetCursorPos( out  POINT pt);
 
    }　　

拾取颜色返回鼠标下的Color

public  class  ScreenColor
     {
         [DllImport( "user32.dll" )]
         static  extern  IntPtr GetDC(IntPtr hwnd);
 
         [DllImport( "user32.dll" )]
         static  extern  Int32 ReleaseDC(IntPtr hwnd, IntPtr hdc);
 
         [DllImport( "gdi32.dll" )]
         static  extern  uint  GetPixel(IntPtr hdc, int  nXPos, int  nYPos);
 
         static  public  System.Drawing.Color GetPixelColor( int  x, int  y)
         {
             IntPtr hdc = GetDC(IntPtr.Zero);
             uint  pixel = GetPixel(hdc, x, y);
             ReleaseDC(IntPtr.Zero, hdc);
             Color color = Color.FromArgb(( int )(pixel & 0x000000FF),
                          ( int )(pixel & 0x0000FF00) >> 8,
                          ( int )(pixel & 0x00FF0000) >> 16);
             return  color;
         }
 
     }

调用

MyPoint.POINT POINT = new  MyPoint.POINT();
MyPoint.GetCursorPos( out  POINT);　　

用键盘让程序停下来我还真没有什么好办法就用了一个键盘勾子

这是一个全局的勾子实现拾取键盘的按键

//Declare wrapper managed POINT class.
    [StructLayout(LayoutKind.Sequential)]
    public  class  POINT
    {
        public  int  x;
        public  int  y;
    }
 
    //Declare wrapper managed MouseHookStruct class.
    [StructLayout(LayoutKind.Sequential)]
    public  class  MouseHookStruct
    {
        public  POINT pt;
        public  int  hwnd;
        public  int  wHitTestCode;
        public  int  dwExtraInfo;
    }
 
    //Declare wrapper managed KeyboardHookStruct class.
    [StructLayout(LayoutKind.Sequential)]
    public  class  KeyboardHookStruct
    {
        public  int  vkCode; //Specifies a virtual-key code. The code must be a value in the range 1 to 254.
        public  int  scanCode; // Specifies a hardware scan code for the key.
        public  int  flags; // Specifies the extended-key flag, event-injected flag, context code, and transition-state flag.
        public  int  time; // Specifies the time stamp for this message.
        public  int  dwExtraInfo; // Specifies extra information associated with the message.
    }
 
    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; //Declare mouse hook handle as int.
        static  int  hKeyboardHook = 0; //Declare keyboard hook handle as int.
 
        //values from Winuser.h in Microsoft SDK.
        public  const  int  WH_MOUSE_LL = 14; //mouse hook constant
        public  const  int  WH_KEYBOARD_LL = 13; //keyboard hook constant
 
        GlobalHookProc MouseHookProcedure; //Declare MouseHookProcedure as HookProc type.
        GlobalHookProc KeyboardHookProcedure; //Declare KeyboardHookProcedure as HookProc type.
 
 
 
        //Import for SetWindowsHookEx function.
        //Use this function to install a hook.
        [DllImport( "user32.dll" , CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public  static  extern  int  SetWindowsHookEx( int  idHook, GlobalHookProc lpfn,
            IntPtr hInstance, int  threadId);
 
        //Import for UnhookWindowsHookEx.
        //Call this function to uninstall the hook.
        [DllImport( "user32.dll" , CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public  static  extern  bool  UnhookWindowsHookEx( int  idHook);
 
        //Import for CallNextHookEx.
        //Use this function to pass the hook information to next hook procedure in chain.
        [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()
        {
            // install Mouse hook
            if  (hMouseHook == 0)
            {
                // Create an instance of HookProc.
                MouseHookProcedure = new  GlobalHookProc(MouseHookProc);
 
                try
                {
                    hMouseHook = SetWindowsHookEx(WH_MOUSE_LL,
                        MouseHookProcedure,
                        Marshal.GetHINSTANCE(
                        Assembly.GetExecutingAssembly().GetModules()[0]),
                        0);
                }
                catch  (Exception err)
                { }
 
                //If SetWindowsHookEx fails.
                if  (hMouseHook == 0)
                {
                    Stop();
                    throw  new  Exception( "SetWindowsHookEx failed." );
                }
            }
 
            // install Keyboard hook
            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 SetWindowsHookEx fails.
                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 UnhookWindowsHookEx fails.
            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 ok and someone listens to our events
            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;
 
                //Marshall the data from callback.
                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);
        }
 
        //The ToAscii function translates the specified virtual-key code and keyboard state to the corresponding character or characters. The function translates the code using the input language and physical keyboard layout identified by the keyboard layout handle.
        [DllImport( "user32" )]
        public  static  extern  int  ToAscii( int  uVirtKey, //[in] Specifies the virtual-key code to be translated.
            int  uScanCode, // [in] Specifies the hardware scan code of the key to be translated. The high-order bit of this value is set if the key is up (not pressed).
            byte [] lpbKeyState, // [in] Pointer to a 256-byte array that contains the current keyboard state. Each element (byte) in the array contains the state of one key. If the high-order bit of a byte is set, the key is down (pressed). The low bit, if set, indicates that the key is toggled on. In this function, only the toggle bit of the CAPS LOCK key is relevant. The toggle state of the NUM LOCK and SCROLL LOCK keys is ignored.
            byte [] lpwTransKey, // [out] Pointer to the buffer that receives the translated character or characters.
            int  fuState); // [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise.
 
        //The GetKeyboardState function copies the status of the 256 virtual keys to the specified buffer.
        [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)
        {
            // it was ok and someone listens to events
            if  ((nCode >= 0) && (KeyDown != null  || KeyUp != null  || KeyPress != null ))
            {
                KeyboardHookStruct MyKeyboardHookStruct =
                    (KeyboardHookStruct)Marshal.PtrToStructure(lParam,
                    typeof (KeyboardHookStruct));
                // raise KeyDown
                if  (KeyDown != null  && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
                {
                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
                    KeyEventArgs e = new  KeyEventArgs(keyData);
                    KeyDown( this , e);
                }
 
                // raise KeyPress
                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);
                    }
                }
 
                // raise KeyUp
                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);
        }
    }

　　

调用的时候

GlobalHook my_Hook = new  GlobalHook();
my_Hook.KeyDown += new  System.Windows.Forms.KeyEventHandler(my_Hook_KeyDown);      <br>my_Hook.Start();
 
void  my_Hook_KeyDown( object  sender, System.Windows.Forms.KeyEventArgs e)
         {
             
             if  (e.KeyCode == System.Windows.Forms.Keys.Space ) //(e.Alt || e.Control || e.Shift)
             {
                 ifStart = false ;
             }
         }

　　

程序下载：MyWPFScreenColorE.rar 

 本文转自lpxxn博客园博客，原文链接：http://www.cnblogs.com/li-peng/archive/2013/03/08/2950015.html，如需转载请自行联系原作者

文章标签：
C#
关键词：
wpf颜色
吞吞吐吐的
目录
相关文章
杰克.陈
|
C#
GDI+与WPF中的颜色简析
原文:GDI+与WPF中的颜色简析 --------------------------------------------------------------------------------引用或转载时请保留以下信息：大可山 [MSN:a3news(AT)hotmail.
杰克.陈
1210 0
杰克.陈
|
C#
WPF中取得预定义颜色
原文:WPF中取得预定义颜色 使用XAML代码取得.net预定义颜色:                    Public, Static                                         ...
杰克.陈
796 0
杰克.陈
|
C#
创建一个显示所有预定义WPF颜色的ListBox
原文 Creating a ListBox that Shows All Predefined WPF Colors 在WPF中，您可以使用Colors类访问一系列预定义颜色，这些颜色定义为Colors类的静态属性。
杰克.陈
948 0
杰克.陈
|
算法 C# 图形学
WPF绘制深度不同颜色的3D模型填充图和线框图
原文:WPF绘制深度不同颜色的3D模型填充图和线框图 在机械测量过程中，测量的数据需要进行软件处理。通常测量一个零件之后，需要重建零件的3D模型，便于观察测量结果是否与所测工件一致。
杰克.陈
2859 0
杰克.陈
|
C#
WinForm和WPF颜色对象的转换
原文:WinForm和WPF颜色对象的转换 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/huangli321456/article/details/52956846 ...
杰克.陈
849 0
杰克.陈
|
C#
WPF中让TextBlock每一个字符显示不同的颜色
原文:WPF中让TextBlock每一个字符显示不同的颜色 XAML代码: R G B ...
杰克.陈
1634 0
杰克.陈
|
C#
WPF圆角按钮与触发颜色变化
原文:WPF圆角按钮与触发颜色变化 ...
杰克.陈
1541 0
杰克.陈
|
C#
WPF 颜色转换
原文:WPF 颜色转换 从字符串到画刷： var converter = new System.Windows.Media.BrushConverter(); var brush = (Brush)converter.
杰克.陈
894 0
老朱教授
|
C# vr&ar
WPF动态改变主题颜色
老朱教授
1445 0
追逐时光者
|
16天前
|
C# 开发者 Windows
基于Material Design风格开源、易用、强大的WPF UI控件库
基于Material Design风格开源、易用、强大的WPF UI控件库
追逐时光者
47 0