private Dictionary<string, int> GetWindowSize(string processName)
		{
			IntPtr handle = IntPtr.Zero;
			foreach (Process process in Process.GetProcesses())
			{


				if (process.MainWindowTitle.IndexOf(processName) >= 0)
				{
					handle = process.MainWindowHandle;
				}
			}
			if (handle == IntPtr.Zero)
				throw new WindowNotFoundException();

			RECT rect = new RECT(); POINT point = new POINT();
			GetClientRect(handle, out rect);
			ClientToScreen(handle, out point);
			var result = new Dictionary<string, int>();
			result.Add("width", (int)(rect.right - rect.left));
			result.Add("height", (int)(rect.bottom - rect.top));
			result.Add("x", (int)point.x);
			result.Add("y", (int)point.y);
			return result;
		}

        public MainAppContext()
        {
            NotifyIcon trayIcon = new NotifyIcon() { Icon = Properties.Resources.TopMost, Text = "MakeTopMost", Visible = true };
            trayIcon.Click += (s, e) =>
                {
                    if (this.lastMenu != null)
                    {
                        this.lastMenu.Dispose();
                    }

                    this.lastMenu = this.CreateMenu();

                    NativeWindow trayIconWindow = (NativeWindow)typeof(NotifyIcon).GetField("window", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(trayIcon);
                    POINT cursorLocation = new POINT(); NativeMethods.GetCursorPos(out cursorLocation);
                    SystemWindow.ForegroundWindow = new SystemWindow(trayIconWindow.Handle);
                    NativeMethods.TrackPopupMenuEx(new HandleRef(this.lastMenu, this.lastMenu.Handle), 72, cursorLocation.X, cursorLocation.Y, new HandleRef(trayIconWindow, trayIconWindow.Handle), IntPtr.Zero);
                    NativeMethods.PostMessage(new HandleRef(trayIconWindow, trayIconWindow.Handle), 0, IntPtr.Zero, IntPtr.Zero);
                };

            this.ThreadExit += (s, e) =>
                {
                    trayIcon.Dispose();
                    if (this.lastMenu != null)
                    {
                        this.lastMenu.Dispose();
                    }
                };
        }

        private int HandleMouseEvent(int inEvtDispId, IHTMLEventObj pIEventObj)
        {
            // WinLive 160252: MSHTML throws a COMException with HRESULT 0x8000FFFF (E_UNEXPECTED) when calling
            // IHTMLPaintSite.TransformGlobalToLocal if the table has no height.
            IHTMLElement tableElement = (IHTMLElement)_table;
            if (tableElement.offsetHeight <= 0 || tableElement.offsetWidth <= 0)
            {
                return HRESULT.S_FALSE;
            }

            // compute the element local coordinates of the point
            POINT clientMouseLocation = new POINT();
            clientMouseLocation.x = pIEventObj.clientX;
            clientMouseLocation.y = pIEventObj.clientY;
            POINT localMouseLocation = new POINT();
            _paintSite.TransformGlobalToLocal(clientMouseLocation, ref localMouseLocation);

            // determine if the point is within our bounds
            int tableWidth = tableElement.offsetWidth + 4; // extra padding for mouse handling at right edge
            Rectangle elementBounds = new Rectangle(-1, -1, tableWidth, tableElement.offsetHeight + 1);
            bool mouseInElement = elementBounds.Contains(localMouseLocation.x, localMouseLocation.y);

            if (mouseInElement || _sizingOperation.InProgress)
            {
                // create args
                TableColumnMouseEventArgs mouseEventArgs = new TableColumnMouseEventArgs(
                    new Point(clientMouseLocation.x, clientMouseLocation.y),
                    new Point(localMouseLocation.x, localMouseLocation.y));

                // fire the event
                switch (inEvtDispId)
                {
                    case DISPID_HTMLELEMENTEVENTS2.ONMOUSEMOVE:
                        OnMouseMove(mouseEventArgs);
                        break;
                    case DISPID_HTMLELEMENTEVENTS2.ONMOUSEDOWN:
                        OnMouseDown(mouseEventArgs);
                        break;
                    case DISPID_HTMLELEMENTEVENTS2.ONMOUSEUP:
                        OnMouseUp(mouseEventArgs);
                        break;
                    default:
                        Trace.Fail("unexpected event id");
                        break;
                }

                // indicate whether we should mask the event from the editor
                return mouseEventArgs.Handled ? HRESULT.S_OK : HRESULT.S_FALSE;

            }
            else
            {
                // if the mouse is not inside the element the end sizing
                _sizingOperation.EndSizing();
            }

            // event not handled
            return HRESULT.S_FALSE;
        }

        public static IntPtr WindowFormPoint(System.Drawing.Point point)
        {
            var p = new POINT();
            p.x = point.X;
            p.y = point.Y;

            return WindowFromPoint(p);
        }

        public static System.Drawing.Point UpperLeftCornerOfWindow(IntPtr hWnd)
        {
            Interop.POINT p = new POINT(0, 0);
            ScreenToClient(hWnd, ref p);

            // Make these positive
            return new Point(p.X * -1, p.Y * -1);
        }

        public static string GetWindowTextUnderCursor()
        {
            POINT pointCursor = new POINT();

            if (!(GetCursorPos(out pointCursor))) return string.Empty;

            return GetWindowText(pointCursor);
        }

 public static IntPtr GetCurrentMonitor()
 {
     POINT point = new POINT();
     if (!GetCursorPos(out point))
     {
         throw new Win32Exception(Marshal.GetLastWin32Error());
     }
     return MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST);
 }

		//********************************
		//using DllImports from DLL_User32
		//********************************
		public static Point NativeScreenToClient(IntPtr window, Point originalPoint)
		{
			POINT pOINT = new POINT(originalPoint.X, originalPoint.Y);
			if (ScreenToClient(window, ref pOINT))
			{
				return new Point(pOINT.x, pOINT.y);
			}
			return Point.Empty;
		}	

 public static extern int UpdateLayeredWindow(IntPtr hWnd, 
     IntPtr hdcDst,
     ref POINT pptDst, 
     ref SIZE psize,
     IntPtr hdcSrc, 
     ref POINT pptSrc, 
     uint crKey, 
     ref BLENDFUNCTION pblend, 
     uint dwFlags);

 public Point TransformGlobalToLocal(Point ptGlobal)
 {
     POINT pointLocal = new POINT();
     POINT pointGlobal = new POINT();
     pointGlobal.x = ptGlobal.X;
     pointGlobal.y = ptGlobal.Y;
     HTMLPaintSite.TransformGlobalToLocal(pointGlobal, ref pointLocal);
     return new Point(pointLocal.x, pointLocal.y);
 }

 /// <summary>
 /// Clients to screen.
 /// </summary>
 /// <param name="handle">A handle.</param>
 /// <param name="point">A point.</param>
 /// <returns></returns>
 public static POINT ClientToScreen(WindowHandle handle, POINT point)
 {
     POINT point1 = point;
     if (!ClientToScreen(handle, ref point1))
     {
         throw new Win32Exception();
     }
     return point1;
 }

 /// <summary>
 /// Функция находит дочернее окно в данной точке.
 /// </summary>
 /// <param name="pt">Точка в абсолютных координатах</param>
 /// <returns>Возвращает дескриптор окна</returns>
 public IntPtr FindWindowAtPos(System.Drawing.Point pt)
 {
     FindedHandle = IntPtr.Zero;
       POINT APIpt = new POINT();
       APIpt.X = pt.X;
       APIpt.Y = pt.Y;
       GCHandle GCPoint = GCHandle.Alloc(APIpt);
       EnumWindowsProc cbFinder = new EnumWindowsProc(FindNextLevelWindowAtPos);
       EnumChildWindows(ParentHandle,FindNextLevelWindowAtPos, GCHandle.ToIntPtr(GCPoint));
       return FindedHandle;
 }

        /// <summary>
        ///     Transform a point from "screen" coordinate space into the
        ///     "client" coordinate space of the window.
        /// </summary>
        public static Point TransformScreenToClient(this HwndSource hwndSource, Point point)
        {
            HWND hwnd = new HWND(hwndSource.Handle);

            POINT pt = new POINT();
            pt.x = (int)point.X;
            pt.y = (int)point.Y;

            NativeMethods.ScreenToClient(hwnd, ref pt);

            return new Point(pt.x, pt.y);
        }

        public MouseUpEventArgs(MouseButtons button, POINT pt, IntPtr hWnd)
        {
            Button = button;
            ScreenPoint = new Point(pt.x, pt.y);

            if (hWnd == IntPtr.Zero)
                return;

            WindowHandle = hWnd;
            PInvoke.ScreenToClient(hWnd, ref pt);
            WindowPoint = new Point(pt.x, pt.y);
        }

        public static void SetPosition(int x, int y)
        {
            POINT pt = new POINT(x, y);

            if (m_windowHandle != IntPtr.Zero)
            {
                unsafe
                {
                    ClientToScreen(m_windowHandle.ToPointer(), &pt);
                }
            }
            SetCursorPos(pt.X, pt.Y);
        }

	void WndOnMouseDown()
	{
		var hwnd = FindWindow(null, "CooldogAssistant");

		if (hwnd != IntPtr.Zero)
		{
			POINT p;
			GetCursorPos(out p);
			p.X -= Screen.width / 2;
			p.Y -= Screen.width / 4;

			DragStart = p;
			Dragging = false;
		}
	}

		public void EqualityTest()
		{
			POINT p = new POINT(20, 40);
			POINT p2 = new POINT(20, 40);
			Point p3 = new Point(20, 40);

			Assert.AreEqual(p, p2);
			Assert.AreEqual(p, p3);

			Point p4 = new Point(30, 30);
			POINT p5 = new POINT(50, 60);

			Assert.AreNotEqual(p, p4);
			Assert.AreNotEqual(p, p5);
		}

        public void SetView(Bitmap newView, int newOpacity)
        {
            if (newView == null) return;

            if (newView.PixelFormat != PixelFormat.Format32bppArgb)
                throw new ApplicationException("The bitmap must be 32ppp with alpha-channel.");

            View = newView;
            Opacity = newOpacity%256;

            IntPtr screenDc = User.GetDC(IntPtr.Zero);
            IntPtr memDc = GDI.CreateCompatibleDC(screenDc);
            IntPtr hBitmap = IntPtr.Zero;
            IntPtr oldBitmap = IntPtr.Zero;

            try
            {
                hBitmap = newView.GetHbitmap(Color.FromArgb(0));
                oldBitmap = GDI.SelectObject(memDc, hBitmap);

                var size = new SIZE {cx = newView.Width, cy = newView.Height};
                var pointSource = new POINT {x = 0, y = 0};
                var topPos = new POINT {x = Left, y = Top};
                var blend = new User.BLENDFUNCTION
                            {
                                BlendOp = User.AC_SRC_OVER,
                                BlendFlags = 0,
                                SourceConstantAlpha = (byte) newOpacity,
                                AlphaFormat = User.AC_SRC_ALPHA
                            };

                User.UpdateLayeredWindow(Handle, screenDc, ref topPos,
                                         ref size, memDc, ref pointSource,
                                         0,
                                         ref blend, User.ULW_ALPHA);
            }
            finally
            {
                User.ReleaseDC(IntPtr.Zero, screenDc);
                if (hBitmap != IntPtr.Zero)
                {
                    GDI.SelectObject(memDc, oldBitmap);
                    GDI.DeleteObject(hBitmap);
                }
                GDI.DeleteDC(memDc);
            }
        }

		static public void MouseMoveToPointInClientRect(
			IntPtr WindowHandle,
			Vektor2DInt DestinationPointInClientRect,
			out POINT DestinationPointInScreen)
		{
			DestinationPointInScreen = DestinationPointInClientRect.AsWindowsPoint();

			// get screen coordinates
			BotEngine.WinApi.User32.ClientToScreen(WindowHandle, ref DestinationPointInScreen);

			var lParam = (IntPtr)((((int)DestinationPointInClientRect.B) << 16) | ((int)DestinationPointInClientRect.A));
			var wParam = IntPtr.Zero;

			BotEngine.WinApi.User32.SetCursorPos(DestinationPointInScreen.x, DestinationPointInScreen.y);

			BotEngine.WinApi.User32.SendMessage(WindowHandle, (uint)SictMessageTyp.WM_MOUSEMOVE, wParam, lParam);
		}

        public void SetIMEWindowLocation(int x, int y)
        {
            POINT p = new POINT();
            p.x = x;
            p.y = y;

            COMPOSITIONFORM lParam = new COMPOSITIONFORM();
            lParam.dwStyle = CFS_POINT;
            lParam.ptCurrentPos = p;
            lParam.rcArea = new RECT();

            int i = SendMessage(
                        hIMEWnd,
                        WM_IME_CONTROL,
                        IMC_SETCOMPOSITIONWINDOW,
                        lParam
                        );
        }