controlhelper.cs

破解的飞信源代码

namespace Imps.Client.Utils
{
    using Imps.Client.Utils.Win32;
    using Imps.Utils;
    using System;
    using System.ComponentModel;
    using System.Drawing;
    using System.Reflection;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Windows.Forms;

    public static class ControlHelper
    {
        private static char[] _mobileNoChars = "0123456789+".ToCharArray();

        private static void ctrl_ImeModeChanged(object sender, EventArgs e)
        {
            ((Control) sender).ImeMode = ImeMode.Disable;
        }

        private static void ctrlAcceptDigitOnly_KeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                if (((((e.KeyValue > 0x69) || (e.KeyValue < 0x60)) && (((e.KeyValue < 0x30) || (e.KeyValue > 0x39)) || e.Shift)) && ((e.KeyValue >= 0x30) && !e.Control)) && !e.Alt)
                {
                    e.set_SuppressKeyPress(true);
                }
            }
            catch
            {
            }
        }

        private static void ctrlAcceptDigitOnly_KeyPress(object sender, KeyPressEventArgs e)
        {
            try
            {
                int keyChar = e.KeyChar;
                if ((keyChar > 0x39) || ((Imps.Client.Utils.Win32.NativeMethods.GetKeyState(0x10) & 0x8000) != 0))
                {
                    if ((keyChar >= 0xff10) && (keyChar <= 0xff19))
                    {
                        e.set_KeyChar((char) (keyChar - 0xfee0));
                    }
                    else
                    {
                        e.Handled = true;
                    }
                }
            }
            catch
            {
            }
        }

        private static void ctrlAcceptDigitOnly_TextChanged(object sender, EventArgs e)
        {
            try
            {
                StringBuilder builder = new StringBuilder();
                string text = ((Control) sender).Text;
                for (int i = 0; i < text.Length; i++)
                {
                    if (char.IsDigit(text[i]))
                    {
                        builder.Append(text[i]);
                    }
                }
                if (builder.Length < text.Length)
                {
                    ((Control) sender).Text = builder.ToString();
                }
            }
            catch
            {
            }
        }

        private static void ctrlAcceptPasswordChar_KeyPress(object sender, KeyPressEventArgs e)
        {
            try
            {
                if (!IsPasswordChar(e.KeyChar) && (e.KeyChar > '\x001b'))
                {
                    e.Handled = true;
                }
            }
            catch
            {
            }
        }

        private static void ctrlAcceptPasswordChar_TextChanged(object sender, EventArgs e)
        {
            try
            {
                StringBuilder builder = new StringBuilder();
                string text = ((Control) sender).Text;
                for (int i = 0; i < text.Length; i++)
                {
                    if (IsPasswordChar(text[i]))
                    {
                        builder.Append(text[i]);
                    }
                }
                if (builder.Length < text.Length)
                {
                    ((Control) sender).Text = builder.ToString();
                }
            }
            catch
            {
            }
        }

        public static void DoEventsExceptWnd(IntPtr hwnd)
        {
            IntPtr ancestor = Imps.Client.Utils.Win32.NativeMethods.GetAncestor(hwnd, 3);
            Imps.Client.Utils.Win32.MSG msg = new Imps.Client.Utils.Win32.MSG();
            while (Imps.Client.Utils.Win32.NativeMethods.PeekMessage(ref msg, IntPtr.Zero, 0, 0, 0))
            {
                if (Imps.Client.Utils.Win32.NativeMethods.GetMessage(ref msg, IntPtr.Zero, 0, 0))
                {
                    IntPtr ptr2 = Imps.Client.Utils.Win32.NativeMethods.GetAncestor(msg.hwnd, 2);
                    IntPtr ptr3 = Imps.Client.Utils.Win32.NativeMethods.GetAncestor(msg.hwnd, 3);
                    if ((hwnd == ptr2) || (ancestor != ptr3))
                    {
                        Imps.Client.Utils.Win32.NativeMethods.TranslateMessage(ref msg);
                        Imps.Client.Utils.Win32.NativeMethods.DispatchMessage(ref msg);
                    }
                }
            }
        }

        public static void FadeinImage(object host, Image pic)
        {
            new FadeinImageHelper(host, pic);
        }

        public static void FlashWindow(Form flashForm)
        {
            new FlashWindowHelper(flashForm, 15, 10).Start();
        }

        public static void FlashWindow(Form flashForm, int totalSeconds)
        {
            new FlashWindowHelper(flashForm, 15, totalSeconds).Start();
        }

        public static void FlashWindow(Form flashForm, int interval, int totalSeconds)
        {
            new FlashWindowHelper(flashForm, interval, totalSeconds).Start();
        }

        public static void ForceControlImeDisable(Control ctrl)
        {
            ForceControlImeDisable(ctrl, true);
        }

        public static void ForceControlImeDisable(Control ctrl, bool disabled)
        {
            if (disabled)
            {
                ctrl.ImeMode = ImeMode.Disable;
                ctrl.ImeModeChanged += new EventHandler(ControlHelper.ForceControlImeDisable_ImeModeChanged);
                ctrl.Disposed += delegate (object sender, EventArgs e) {
                    ((Control) sender).ImeModeChanged -= new EventHandler(ControlHelper.ForceControlImeDisable_ImeModeChanged);
                };
            }
            else
            {
                ctrl.ImeMode = ImeMode.NoControl;
                ctrl.ImeModeChanged -= new EventHandler(ControlHelper.ForceControlImeDisable_ImeModeChanged);
            }
        }

        private static void ForceControlImeDisable_ImeModeChanged(object sender, EventArgs e)
        {
            ((Control) sender).ImeMode = ImeMode.Disable;
        }

        public static void ForceControlImeHangul(Control ctrl)
        {
            ForceControlImeHangul(ctrl, true);
        }

        public static void ForceControlImeHangul(Control ctrl, bool value)
        {
            if (value)
            {
                ctrl.GotFocus += new EventHandler(ControlHelper.ForceControlImeHangul_GotFocus);
                ctrl.Disposed += delegate (object sender, EventArgs e) {
                    ((Control) sender).GotFocus -= new EventHandler(ControlHelper.ForceControlImeHangul_GotFocus);
                };
            }
            else
            {
                ctrl.GotFocus -= new EventHandler(ControlHelper.ForceControlImeHangul_GotFocus);
            }
        }

        private static void ForceControlImeHangul_GotFocus(object sender, EventArgs e)
        {
            TryForceControlImeHangul((Control) sender);
        }

        private static bool IsPasswordChar(char ch)
        {
            int num = ch;
            if (num >= 0x21)
            {
                return (num < 0x7f);
            }
            return false;
        }

        public static bool IsValidPassword(string pass)
        {
            if ((pass.Length < 6) || (pass.Length > 0x10))
            {
                return false;
            }
            foreach (char ch in pass)
            {
                if (!IsPasswordChar(ch))
                {
                    return false;
                }
            }
            return true;
        }

        public static Form LookupOwnedForm(Control ctrl)
        {
            while (ctrl != null)
            {
                if (ctrl is Form)
                {
                    return (Form) ctrl;
                }
                ctrl = ctrl.Parent;
            }
            return null;
        }

        public static bool MakeWindowRectAllVisible(ref Imps.Client.Utils.Win32.RECT rtWnd)
        {
            bool flag = false;
            try
            {
                IntPtr pvParam = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Imps.Client.Utils.Win32.RECT)));
                if (!Imps.Client.Utils.Win32.NativeMethods.SystemParametersInfo(0x30, 0, pvParam, 0))
                {
                    return false;
                }
                Imps.Client.Utils.Win32.RECT rect = (Imps.Client.Utils.Win32.RECT) Marshal.PtrToStructure(pvParam, typeof(Imps.Client.Utils.Win32.RECT));
                int width = rtWnd.Width;
                int height = rtWnd.Height;
                if (rtWnd.Width > rect.Width)
                {
                    rtWnd.Left = rect.Left;
                    rtWnd.Right = rect.Right;
                    flag = true;
                }
                else if (rtWnd.Right > rect.Right)
                {
                    rtWnd.Right = rect.Right;
                    rtWnd.Left = rect.Right - width;
                    flag = true;
                }
                else if (rtWnd.Left < rect.Left)
                {
                    rtWnd.Left = rect.Left;
                    rtWnd.Right = rect.Left + width;
                    flag = true;
                }
                if (rtWnd.Height > rect.Height)
                {
                    rtWnd.Top = rect.Top;
                    rtWnd.Bottom = rect.Bottom;
                    return true;
                }
                if (rtWnd.Bottom > rect.Bottom)
                {
                    rtWnd.Bottom = rect.Bottom;
                    rtWnd.Top = rect.Bottom - height;
                    return true;
                }
                if (rtWnd.Top < rect.Top)
                {
                    rtWnd.Top = rect.Top;