public void Draw(
            Graphics g,
            InkPressureFeedbackMode pressureMode,
            Capture.CalibratedInkSample lastSample,
            Capture.CalibratedInkSample currentSample,
            Capture.RawInkSample lastRawSample,
            Capture.RawInkSample currentRawSample)
        {
            GraphicsState OriginalGraphicsState = g.Save();
            g.SmoothingMode = SmoothingMode.HighQuality;

            Point p1 = new Point(lastRawSample.X, lastRawSample.Y);
            Point p2 = new Point(currentRawSample.X, currentRawSample.Y);

            //ink space ==> pixel space transformation
            Capture.Calibration.InkCalibration.Current.InkRenderer.InkSpaceToPixel(g, ref p1);
            Capture.Calibration.InkCalibration.Current.InkRenderer.InkSpaceToPixel(g, ref p2);

            switch (pressureMode)
            {
                case InkPressureFeedbackMode.Size:
                    //drawing circles (uninverting then inverting)
                    _Raster.Begin(g);

                    if (!lastSample.IsInvalid())
                        _Raster.InvertCircle(p1, GetRadius(g, lastSample.Pressure));    //uninvert the last circle

                    if (!currentSample.IsInvalid())
                        _Raster.InvertCircle(p2, GetRadius(g, currentSample.Pressure)); //invert the next circle

                    _Raster.Commit(g);
                    break;

                default:
                    //drawing lines or similar (connecting two valid points)
                    if (!lastRawSample.IsInvalid()
                        && !currentRawSample.IsInvalid())
                    {
                        switch (pressureMode)
                        {
                            case InkPressureFeedbackMode.Color:
                                DrawPressureLine(g, p1, p2, currentSample.Pressure);
                                break;
                            case InkPressureFeedbackMode.Width:
                                DrawWidth(g, p1, p2, lastSample.Pressure, currentSample.Pressure);
                                break;
                            case InkPressureFeedbackMode.None:
                            default:
                                DrawLine(g, p1, p2);
                                break;
                        }
                    }
                    break;
            }

            g.Restore(OriginalGraphicsState);
        }
Ejemplo n.º 2
0
        private void InterpretHeaderLine(string line)
        {
            string[] Part = line.Split(new string[] { ": " }, 2, StringSplitOptions.None);
            if (Part.Length != 2)
            {
                return;
            }

            try
            {
                switch (Part[0])
                {
                case "DirectFeedback":
                    _DirectFeedback = bool.Parse(Part[1]);
                    break;

                case "Cognitive":
                    _Cognitive = bool.Parse(Part[1]);
                    break;

                case "CognitiveFeedback":
                    _CognitiveFeedback = bool.Parse(Part[1]);
                    break;

                case "PressureFeedback":
                    _PressureFeedback = (InkPressureFeedbackMode)Enum.Parse(typeof(InkPressureFeedbackMode), Part[1]);
                    break;

                case "TimeLimit":
                    _TimeLimit = int.Parse(Part[1]);
                    break;

                case "Instructions":
                    _Instructions = Part[1];
                    break;

                case "StartingPoint":
                    string[] Subparts = Part[1].Replace(" ", "").Split(new char[] { ',' }, 2);
                    _StartingPoint = new Point(int.Parse(Subparts[0]), int.Parse(Subparts[1]));
                    break;
                }
            }
            catch
            {
            }
        }
        private static void DrawInk(GraphicsPath p, InkPressureFeedbackMode m, Size s, Graphics g)
        {
            RectangleF PathBounds = p.GetBounds();  //get the bounds of the path and compute the square scale transform
            float ds = 0.8f * Math.Min(s.Width / PathBounds.Width, s.Height / PathBounds.Height);

            GraphicsState OriginalGraphicsState = g.Save();

            g.TranslateTransform(s.Width >> 1, s.Height >> 1);
            g.ScaleTransform(ds, -ds);

            switch (m)
            {
                case InkPressureFeedbackMode.Size:
                    g.FillEllipse(Brushes.Black, new Rectangle(-800, -800, 1600, 1600));
                    break;

                case InkPressureFeedbackMode.Width:
                    g.DrawLine(new Pen(Color.Black, 500f), new Point(-500, 0), new Point(500, 0));
                    break;

                case InkPressureFeedbackMode.None:
                case InkPressureFeedbackMode.Color:
                default:
                    GraphicsPath InkRegion = new GraphicsPath();    //upper-left triangular clip region to fake "ink"
                    InkRegion.AddPolygon(new Point[] { Point.Empty, new Point(s.Width, 0), new Point(0, s.Height) });
                    Matrix InverseTransform = g.Transform;
                    InverseTransform.Invert();
                    InkRegion.Transform(InverseTransform);

                    g.IntersectClip(new Region(InkRegion));
                    g.DrawPath(new Pen(Color.Blue, 4 / ds), p);
                    break;
            }

            g.Restore(OriginalGraphicsState);
        }
        private static void DrawInk(GraphicsPath p, InkPressureFeedbackMode m, Size s, Graphics g)
        {
            RectangleF PathBounds = p.GetBounds();  //get the bounds of the path and compute the square scale transform
            float      ds         = 0.8f * Math.Min(s.Width / PathBounds.Width, s.Height / PathBounds.Height);

            GraphicsState OriginalGraphicsState = g.Save();

            g.TranslateTransform(s.Width >> 1, s.Height >> 1);
            g.ScaleTransform(ds, -ds);

            switch (m)
            {
            case InkPressureFeedbackMode.Size:
                g.FillEllipse(Brushes.Black, new Rectangle(-800, -800, 1600, 1600));
                break;

            case InkPressureFeedbackMode.Width:
                g.DrawLine(new Pen(Color.Black, 500f), new Point(-500, 0), new Point(500, 0));
                break;

            case InkPressureFeedbackMode.None:
            case InkPressureFeedbackMode.Color:
            default:
                GraphicsPath InkRegion = new GraphicsPath();        //upper-left triangular clip region to fake "ink"
                InkRegion.AddPolygon(new Point[] { Point.Empty, new Point(s.Width, 0), new Point(0, s.Height) });
                Matrix InverseTransform = g.Transform;
                InverseTransform.Invert();
                InkRegion.Transform(InverseTransform);

                g.IntersectClip(new Region(InkRegion));
                g.DrawPath(new Pen(Color.Blue, 4 / ds), p);
                break;
            }

            g.Restore(OriginalGraphicsState);
        }
Ejemplo n.º 5
0
        public void Draw(
            Graphics g,
            InkPressureFeedbackMode pressureMode,
            Capture.CalibratedInkSample lastSample,
            Capture.CalibratedInkSample currentSample,
            Capture.RawInkSample lastRawSample,
            Capture.RawInkSample currentRawSample)
        {
            GraphicsState OriginalGraphicsState = g.Save();

            g.SmoothingMode = SmoothingMode.HighQuality;

            Point p1 = new Point(lastRawSample.X, lastRawSample.Y);
            Point p2 = new Point(currentRawSample.X, currentRawSample.Y);

            //ink space ==> pixel space transformation
            Capture.Calibration.InkCalibration.Current.InkRenderer.InkSpaceToPixel(g, ref p1);
            Capture.Calibration.InkCalibration.Current.InkRenderer.InkSpaceToPixel(g, ref p2);

            switch (pressureMode)
            {
            case InkPressureFeedbackMode.Size:
                //drawing circles (uninverting then inverting)
                _Raster.Begin(g);

                if (!lastSample.IsInvalid())
                {
                    _Raster.InvertCircle(p1, GetRadius(g, lastSample.Pressure));        //uninvert the last circle
                }
                if (!currentSample.IsInvalid())
                {
                    _Raster.InvertCircle(p2, GetRadius(g, currentSample.Pressure));     //invert the next circle
                }
                _Raster.Commit(g);
                break;

            default:
                //drawing lines or similar (connecting two valid points)
                if (!lastRawSample.IsInvalid() &&
                    !currentRawSample.IsInvalid())
                {
                    switch (pressureMode)
                    {
                    case InkPressureFeedbackMode.Color:
                        DrawPressureLine(g, p1, p2, currentSample.Pressure);
                        break;

                    case InkPressureFeedbackMode.Width:
                        DrawWidth(g, p1, p2, lastSample.Pressure, currentSample.Pressure);
                        break;

                    case InkPressureFeedbackMode.None:
                    default:
                        DrawLine(g, p1, p2);
                        break;
                    }
                }
                break;
            }

            g.Restore(OriginalGraphicsState);
        }
        private void InterpretHeaderLine(string line)
        {
            string[] Part = line.Split(new string[] { ": " }, 2, StringSplitOptions.None);
            if (Part.Length != 2) return;

            try
            {
                switch (Part[0])
                {
                    case "DirectFeedback":
                        _DirectFeedback = bool.Parse(Part[1]);
                        break;
                    case "Cognitive":
                        _Cognitive = bool.Parse(Part[1]);
                        break;
                    case "CognitiveFeedback":
                        _CognitiveFeedback = bool.Parse(Part[1]);
                        break;
                    case "PressureFeedback":
                        _PressureFeedback = (InkPressureFeedbackMode)Enum.Parse(typeof(InkPressureFeedbackMode), Part[1]);
                        break;
                    case "TimeLimit":
                        _TimeLimit = int.Parse(Part[1]);
                        break;
                    case "Instructions":
                        _Instructions = Part[1];
                        break;
                    case "StartingPoint":
                        string[] Subparts = Part[1].Replace(" ", "").Split(new char[] { ',' }, 2);
                        _StartingPoint = new Point(int.Parse(Subparts[0]), int.Parse(Subparts[1]));
                        break;
                }
            }
            catch
            {
            }
        }