Exemplo n.º 1
0
 public SerializableCursorPath(SerializablePoint destination, SerializableRectangle bounds,
                               int MouseDownTime, int[][] path)
 {
     this.Destination   = destination;
     this.Bounds        = bounds;
     this.MouseDownTime = MouseDownTime;
     this.Path          = path;
 }
Exemplo n.º 2
0
        public SerializableCursorPath GetRandomSuitablePath(int dx, int dy)
        {
            const double INITIAL_TOLERANCE      = 0.5;
            const double MAX_TOLERANCE          = 4.0;
            const int    MAX_LOOPS              = 100;
            const int    MINIMUM_SUITABLE_PATHS = 10;

            IEnumerable <SerializableCursorPath> SuitablePaths = null;

            SerializablePoint Destination = new SerializablePoint(dx, dy);

            double tolerance = INITIAL_TOLERANCE;

            int i = 0;

            do
            {
                if (i > MAX_LOOPS)
                {
                    throw new Exception("Not enough suitable paths found");
                }

                SuitablePaths = Paths.Where(p =>
                                            p.Destination.IsTolerant(Destination, tolerance));

                tolerance *= 1.5;
                i++;
            } while (SuitablePaths.Count() < MINIMUM_SUITABLE_PATHS &&
                     !(tolerance > MAX_TOLERANCE && SuitablePaths.Count() > 0));
            // (tolerance <= MAX_TOLERANCE || SuitablePaths.Count == 0)
            // SuitablePaths.Count == 0 || (SuitablePaths.Count() < MINIMUM_SUITABLE_PATHS)

            // select a random SuitablePath
            return(SuitablePaths.ElementAt(
                       RandomGenerator.NextInt(SuitablePaths.Count())));
        }
Exemplo n.º 3
0
        bool MouseEvent(Point p, MouseEventIdentifier id, uint timestamp)
        {
            const double MOUSE_DRAG_LIMIT = 5.0; // 5 pixels

            if (timestamp - previous_timestamp > 1000)
            {
                // this automatically disqualifies the first path as well
                disqualified = true;
            }

            switch (id)
            {
            case MouseEventIdentifier.LeftUp:
            case MouseEventIdentifier.RightUp:
                SerializablePoint relative_p =
                    new SerializablePoint(p.X - origin_x, p.Y - origin_y);

                // limits amount of pixels the cursor can drag while pressed
                if (!disqualified && mouse_down_pos.DistanceTo(relative_p) < MOUSE_DRAG_LIMIT)
                {
                    CurrentPath.Add(new int[] {
                        (int)(timestamp - origin_timestamp), // relative_time
                        relative_p.X,                        // relative_x
                        relative_p.Y                         // relative_y
                    });
                    Paths.Add(new SerializableCursorPath(
                                  mouse_down_pos, bounds, mouse_down_relative_time,
                                  CurrentPath.ToArray()));
                }
                ResetPath();

                break;

            default:
                // check if first move, init origins
                if (CurrentPath.Count() == 0)
                {
                    origin_timestamp = timestamp;
                    origin_x         = p.X;
                    origin_y         = p.Y;
                }

                int relative_time = (int)(timestamp - origin_timestamp);
                int relative_x    = p.X - origin_x;
                int relative_y    = p.Y - origin_y;

                if (id == MouseEventIdentifier.LeftDown || id == MouseEventIdentifier.RightDown)
                {
                    mouse_down_relative_time = relative_time;
                    mouse_down_pos           = new SerializablePoint(relative_x, relative_y);
                }

                bounds.PushBounds(relative_x, relative_y);

                // record data relative to start position and time
                CurrentPath.Add(new int[] { relative_time, relative_x, relative_y });
                break;
            }

            previous_timestamp = timestamp;
            return(false); // don't block mouse input events from going to other applications
        }
Exemplo n.º 4
0
 public bool Contains(Point point)
 {
     return(Contains(SerializablePoint.FromPoint(point)));
 }
Exemplo n.º 5
0
 public bool Contains(SerializablePoint point)
 {
     return(Left <= point.X && point.X <= Right &&
            Top <= point.Y && point.Y <= Bottom);
 }
Exemplo n.º 6
0
 public double DistanceTo(SerializablePoint b)
 {
     return(DistanceTo(b.X, b.Y));
 }
Exemplo n.º 7
0
 public bool IsTolerant(SerializablePoint other, double tolerance)
 {
     return(AreDimensionsTolerant(this.X, other.X, tolerance) &&
            AreDimensionsTolerant(this.Y, other.Y, tolerance));
 }