Exemple #1
0
        private void OnMouseMoveExtFirst(object sender, HookMouseEventArg e)
        {
            _oldPoint = e.Point; //new Point(e.X,e.Y);
            //_oldScreenRect = Config.ScreenFromPixel(_oldPoint).InPixel.Bounds;
            _oldZone = _zones.FromPx(_oldPoint);

            Hook.MouseMove -= _handler;

            if (Config.AllowCornerCrossing)
            {
                _handler = MouseMoveCross;
            }
            else
            {
                _handler = MouseMoveStraight;
            }

            Hook.MouseMove += _handler;

            //e.Handled = false;
        }
Exemple #2
0
 private static void Hook_MouseMove(object sender, HookMouseEventArg e)
 {
     Console.WriteLine(e.Point.X.ToString(CultureInfo.InvariantCulture) + "," + e.Point.Y.ToString(CultureInfo.InvariantCulture));
 }
Exemple #3
0
 private void Hook_MouseMove(object sender, HookMouseEventArg e)
 {
     TextBlock.Text = e.Point.X.ToString(CultureInfo.InvariantCulture) + "," + e.Point.Y.ToString(CultureInfo.InvariantCulture);
 }
Exemple #4
0
        private void MouseMoveCross(object sender, HookMouseEventArg e)
        {
            // TODO : if (e.Clicked) return;
            var pIn = e.Point;

            if (_oldZone.ContainsPx(pIn))
            {
                _oldPoint = pIn;
                e.Handled = false;
                return;
            }

            var  pInMmOld = _oldZone.Px2Mm(_oldPoint);
            var  pInMm    = _oldZone.Px2Mm(pIn);
            Zone zoneOut  = null;

            var trip    = new Segment(pInMmOld, pInMm);
            var minDist = double.PositiveInfinity;

            var pOutInMm = pInMm;

            foreach (var zone in _zones.All.Where(z => !ReferenceEquals(z, _oldZone)))
            {
                foreach (var p in trip.Line.Intersect(zone.Mm))
                {
                    var travel = new Segment(pInMmOld, p);
                    if (!travel.Rect.Contains(pInMm))
                    {
                        continue;
                    }
                    var dist = travel.SizeSquared;
                    if (dist > minDist)
                    {
                        continue;
                    }

                    minDist  = dist;
                    zoneOut  = zone;
                    pOutInMm = p;
                }
            }

            if (zoneOut == null)
            {
                LbmMouse.CursorPos = _oldZone.InsidePx(pIn);
                e.Handled          = true;
                return;
            }

            var pOut = zoneOut.Mm2Px(pOutInMm);

            pOut               = zoneOut.InsidePx(pOut);
            _oldZone           = zoneOut.Main;
            _oldPoint          = pOut;
            LbmMouse.CursorPos = pOut;
            ZoneChanged?.Invoke(this, new ZoneChangeEventArgs(_oldZone, zoneOut));
            e.Handled = true;
            return;

            //}

            //finally
            //{
            //    if (_count >= 0) _timer.Stop();
            //    _count++;
            //}
        }
Exemple #5
0
        private void MouseMoveStraight(object sender, HookMouseEventArg e)
        {
            //TODO : if (e.Clicked) return;
            var pIn = e.Point;

            if (_oldZone.ContainsPx(pIn))
            {
                _oldPoint = pIn;
                e.Handled = false;
                return;
            }


            //Point oldpInMm = _oldZone.Px2Mm(_oldPoint);
            Point pInMm   = _oldZone.Px2Mm(pIn);
            Zone  zoneOut = null;

            var minDx = 0.0;
            var minDy = 0.0;

            if (pIn.Y > _oldZone.Px.Bottom)
            {
                foreach (var zone in _zones.All /*.Where(z => z.Mm.Top > _oldZone.Mm.Bottom)*/)
                {
                    if (zone.Mm.Left > pInMm.X || zone.Mm.Right < pInMm.X)
                    {
                        continue;
                    }
                    var dy = zone.Mm.Top - _oldZone.Mm.Bottom;

                    if (dy < 0)
                    {
                        continue;
                    }
                    if (dy > minDy && minDy > 0)
                    {
                        continue;
                    }


                    // = pInMm + new Vector(0, dy);
                    minDy   = dy;
                    zoneOut = zone;
                }
            }
            else if (pIn.Y < _oldZone.Px.Top)
            {
                foreach (var zone in _zones.All /*.Where(z => !ReferenceEquals(z, _oldZone))*/)
                {
                    if (zone.Mm.Left > pInMm.X || zone.Mm.Right < pInMm.X)
                    {
                        continue;
                    }
                    var dy = zone.Mm.Bottom - _oldZone.Mm.Top;

                    if (dy > 0)
                    {
                        continue;
                    }
                    if (dy < minDy && minDy < 0)
                    {
                        continue;
                    }

                    minDy   = dy;
                    zoneOut = zone;
                }
            }

            if (pIn.X > _oldZone.Px.Right)
            {
                foreach (var zone in _zones.All)
                {
                    if (zone.Mm.Top > pInMm.Y || zone.Mm.Bottom < pInMm.Y)
                    {
                        continue;
                    }
                    var dx = zone.Mm.Left - _oldZone.Mm.Right;

                    if (dx < 0)
                    {
                        continue;
                    }
                    if (dx > minDx && minDx > 0)
                    {
                        continue;
                    }

                    minDx   = dx;
                    zoneOut = zone;
                }
            }
            else if (pIn.X < _oldZone.Px.Left)
            {
                foreach (var zone in _zones.All)
                {
                    if (zone.Mm.Top > pInMm.Y || zone.Mm.Bottom < pInMm.Y)
                    {
                        continue;
                    }
                    var dx = zone.Mm.Right - _oldZone.Mm.Left;

                    if (dx < minDx && minDx < 0)
                    {
                        continue;
                    }
                    if (dx > 0)
                    {
                        continue;
                    }

                    minDx   = dx;
                    zoneOut = zone;
                }
            }

            if (zoneOut == null)
            {
                LbmMouse.CursorPos = _oldZone.InsidePx(pIn);
                e.Handled          = true;
                return;
            }

            var pOut = zoneOut.Mm2Px(new Point(pInMm.X + minDx, pInMm.Y + minDy));

            pOut      = zoneOut.InsidePx(pOut);
            _oldZone  = zoneOut.Main;
            _oldPoint = pOut;

            //IntPtr hwnd = OpenInputDesktop(0, false, DESKTOP_SWITCHDESKTOP);
            //SetThreadDesktop(hwnd);

            //var movement = new INPUT { Type = (UInt32)0 };
            //movement.Data.Mouse.Flags = (UInt32)(MouseFlag.Move | MouseFlag.Absolute | MouseFlag.VirtualDesk);
            //movement.Data.Mouse.X = (int)pOut.X;
            //movement.Data.Mouse.Y = (int)pOut.Y;

            //INPUT[] inputs = {movement};

            //SendInput((UInt32)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT)));

            LbmMouse.CursorPos = pOut;

            var p = LbmMouse.CursorPos;

            if (Math.Abs(pOut.X - p.X) >= 1 || Math.Abs(pOut.Y - p.Y) >= 1)
            {
                IntPtr hOldDesktop = GetThreadDesktop(GetCurrentThreadId());
                IntPtr hwnd        = OpenInputDesktop(0, true, (uint)DESKTOP_ACCESS.GENERIC_ALL);

                Thread t = new Thread(() =>
                {
                    SwitchDesktop(hwnd);
                    var b = SetThreadDesktop(hwnd);

                    var b2 = LbmMouse.MouseEvent(
                        NativeMethods.MOUSEEVENTF.ABSOLUTE | NativeMethods.MOUSEEVENTF.MOVE
                        | NativeMethods.MOUSEEVENTF.VIRTUALDESK
                        , pOut.X, pOut.Y);
                    if (b2 == 0)
                    {
                        var s = NativeMethods.GetLastError();
                    }

                    //LbmMouse.CursorPos = pOut;
                    var b3 = NativeMethods.SetCursorPos((int)pOut.X, (int)pOut.Y);

                    if (b3 == false)
                    {
                        var s = NativeMethods.GetLastError();
                    }

                    //    IList<string> list = new List<string>();
                    //    GCHandle gch = GCHandle.Alloc(list);
                    //    EnumWindowStationsDelegate childProc = new EnumWindowStationsDelegate(EnumWindowStationsCallback);

                    //    EnumWindowStations(childProc, GCHandle.ToIntPtr(gch));


                    //}
                });

                t.Start();
                t.Join();

                SwitchDesktop(hOldDesktop);

                //var w = new Window
                //{
                //    WindowStyle = WindowStyle.None,
                //    Visibility = Visibility.Collapsed,
                //    Width = 0,
                //    Height = 0
                //};
                //w.Show();

                ////const int DESKTOP_SWITCHDESKTOP = 256;
                ////IntPtr hwnd = OpenInputDesktop(0, false, 0x00020000);
                ////var b = SetThreadDesktop(hwnd);

                //LbmMouse.CursorPos = pOut;

                //w.Close();
            }

            ZoneChanged?.Invoke(this, new ZoneChangeEventArgs(_oldZone, zoneOut));
            e.Handled = true;
        }