public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
		{
			double thickness = (double) value;
			DrawingAttributes attr = new DrawingAttributes
			                         	{Width = thickness, Height = thickness, FitToCurve = false, Color = Colors.White};
			return attr;
		}

        protected override void DrawCore(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            if (drawingContext == null)
            {
                throw new ArgumentNullException("drawingContext");
            }
            if (null == drawingAttributes)
            {
                throw new ArgumentNullException("drawingAttributes");
            }
            Pen pen = new Pen
            {
                StartLineCap = PenLineCap.Round,
                EndLineCap = PenLineCap.Round,
                Brush = new SolidColorBrush(drawingAttributes.Color),
                Thickness = drawingAttributes.Width
            };

            BrushConverter bc = new BrushConverter();
            Brush BackGround = (Brush)bc.ConvertFromString(drawingAttributes.GetPropertyData(DrawAttributesGuid.BackgroundColor).ToString());

            drawingContext.DrawRectangle(
                BackGround,
                pen,
                new Rect(new Point(StylusPoints[0].X, StylusPoints[0].Y),
                    new Point(StylusPoints[1].X, StylusPoints[1].Y)));
        }

        public override void OnMouseMove(InkCanvas inkCanvas, System.Windows.Input.MouseEventArgs e)
        {
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                var p = e.GetPosition(inkCanvas);
                if (p != point)
                {
                    point = p;
                    GetBrush(pts, (s) =>
                    {
                        if (StrokeResult != null)
                            inkCanvas.Strokes.Remove(StrokeResult);

                        DrawingAttributes drawingAttributes = new DrawingAttributes
                        {
                            Color = inkCanvas.DefaultDrawingAttributes.Color,
                            Width = inkCanvas.DefaultDrawingAttributes.Width,
                            StylusTip = StylusTip.Ellipse,
                            IgnorePressure = true,
                            FitToCurve = true
                        };

                        StrokeResult = new BrushStroke(s, drawingAttributes);
                        inkCanvas.Strokes.Add(StrokeResult);
                    }
                   );
                }
            }
        }

        /// <summary>
        /// Render the StrokeCollection under the specified DrawingContext. This draw method uses the
        /// passing in drawing attribute to override that on the stroke.
        /// </summary>
        /// <param name="drawingContext"></param>
        /// <param name="drawingAttributes"></param>
        public void Draw(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            if (null == drawingContext)
            {
                throw new System.ArgumentNullException("context");
            }

            if (null == drawingAttributes)
            {
                throw new System.ArgumentNullException("drawingAttributes");
            }

            //             context.VerifyAccess();

            //our code never calls this public API so we can assume that opacity
            //has not been set up

            if (drawingAttributes.IsHighlighter)
            {
                drawingContext.PushOpacity(StrokeRenderer.HighlighterOpacity);
                try
                {
                    this.DrawInternal(drawingContext, StrokeRenderer.GetHighlighterAttributes(this, this.DrawingAttributes), false);
                }
                finally
                {
                    drawingContext.Pop();
                }
            }
            else
            {
                this.DrawInternal(drawingContext, drawingAttributes, false);
            }
        }

        //Переопределение базового метода, который позволяет рисовать круг, имея координаты центра и радиус
        protected override void DrawCore(DrawingContext context, DrawingAttributes overrides)
        {
            StylusPointCollection points = this.GetBezierStylusPoints();

            StylusPoint p1 = points[0];
            context.DrawEllipse(new SolidColorBrush(fillColor), new Pen(new SolidColorBrush(strokeColor), thickness), new Point(p1.X, p1.Y), xRadius, yRaduis);
        }

        protected override void DrawCore(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            if (drawingContext == null)
            {
                throw new ArgumentNullException("drawingContext");
            }
            if (null == drawingAttributes)
            {
                throw new ArgumentNullException("drawingAttributes");
            }
            Pen pen = new Pen
            {
                StartLineCap = PenLineCap.Round,
                EndLineCap = PenLineCap.Round,
                Brush = new SolidColorBrush(drawingAttributes.Color),
                Thickness = drawingAttributes.Width
            };

            BrushConverter bc = new BrushConverter();
            Brush BackGround = (Brush)bc.ConvertFromString(drawingAttributes.GetPropertyData(DrawAttributesGuid.BackgroundColor).ToString());
            GeometryConverter gc = new GeometryConverter();
            Geometry geometry = (Geometry)gc.ConvertFromString(string.Format("M {0},{1} {2},{3} {4},{5} Z", StylusPoints[0].X, StylusPoints[1].Y, (Math.Abs(StylusPoints[1].X - StylusPoints[0].X))/2 + StylusPoints[0].X, StylusPoints[0].Y, StylusPoints[1].X, StylusPoints[1].Y));
            GeometryDrawing gd = new GeometryDrawing(BackGround, pen, geometry);
            drawingContext.DrawDrawing(gd);
        }

        public static WindowsInk.Stroke ToWindowsStroke(NineInk.Stroke nineStroke)
        {
            var points = new StylusPointCollection();

            foreach (var point in nineStroke.Points)
                points.Add(new StylusPoint(point.X, point.Y, point.Pressure));

            var drwAttr = new WindowsInk.DrawingAttributes();
            var c = new Color();
            c.R = nineStroke.DrawingAttributes.Color.R;
            c.G = nineStroke.DrawingAttributes.Color.G;
            c.B = nineStroke.DrawingAttributes.Color.B;
            c.A = nineStroke.DrawingAttributes.Color.A;
            drwAttr.Color = c;

            switch (nineStroke.DrawingAttributes.Brush.Name)
            {
                case "Rectangle":
                    drwAttr.StylusTip = WindowsInk.StylusTip.Rectangle;
                    break;
                case "Ellipse":
                default:
                    drwAttr.StylusTip = WindowsInk.StylusTip.Ellipse;
                    break;
            }
            drwAttr.Height = nineStroke.DrawingAttributes.Height;
            drwAttr.Width = nineStroke.DrawingAttributes.Width;
            drwAttr.IsHighlighter = nineStroke.DrawingAttributes.IsHighlighter;

            return new WindowsInk.Stroke(points, drwAttr);
        }

        public override void OnMouseMove(InkCanvas inkCanvas, System.Windows.Input.MouseEventArgs e)
        {
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                endPoint = e.GetPosition(inkCanvas);

                if (startPoint != endPoint)
                {
                    StylusPointCollection pts = new StylusPointCollection();
                    GetLine(pts, (s) =>
                    {
                        if (StrokeResult != null)
                            inkCanvas.Strokes.Remove(StrokeResult);

                        DrawingAttributes drawingAttributes = new DrawingAttributes
                        {
                            Color = inkCanvas.DefaultDrawingAttributes.Color,
                            Width = inkCanvas.DefaultDrawingAttributes.Width,
                            StylusTip = StylusTip.Ellipse,
                            IgnorePressure = true,
                            FitToCurve = true
                        };

                        StrokeResult = new ArrowLineStroke(s, drawingAttributes);
                        inkCanvas.Strokes.Add(StrokeResult);
                    }
                    );
                }
            }
        }

        //-------------------------------------------------------------------------------
        //
        // Public Methods
        //
        //-------------------------------------------------------------------------------

        #region Public Methods

        /// <summary>
        /// AttachVisual method
        /// </summary>
        /// <param name="visual">The stroke visual which needs to be attached</param>
        /// <param name="drawingAttributes">The DrawingAttributes of the stroke</param>
        public void AttachVisuals(Visual visual, DrawingAttributes drawingAttributes)
        {
            VerifyAccess();

            EnsureRootVisual();
            _renderer.AttachIncrementalRendering(visual, drawingAttributes);
        }

 public void SetValue(string value)
 {
     try
     {
         if (String.IsNullOrEmpty(value) || !(value.Contains(':'))) return;
         var parts = value.Split(new[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
         switch (parts[0])
         {
             case "SetDrawingAttributes":
                 //This should come in the format of "SetDrawingAttributes:FF FF FF FF:15:false"
                 if (parts.Count() < 4 || String.IsNullOrEmpty(parts[2]) || String.IsNullOrEmpty(parts[3]) || !(parts[1].Contains(' '))) return;
                 var ARGBvalues = parts[1].Split(new[] { ' ' });
                 if (!(ARGBvalues.Count() == 4)) return;
                 Commands.SetLayer.Execute("sketch");
                 var color = Color.FromArgb(Byte.Parse(ARGBvalues[0]), Byte.Parse(ARGBvalues[1]), Byte.Parse(ARGBvalues[2]), Byte.Parse(ARGBvalues[3]));
                 var da = new DrawingAttributes { Color = color, Height = Double.Parse(parts[2]), Width = Double.Parse(parts[2]), IsHighlighter = Boolean.Parse(parts[3]) };
                 Commands.SetDrawingAttributes.Execute(da);
                 break;
             case "SetInkCanvasMode":
                 //This should come in the format of "SetInkCanvas:Ink"
                 if (parts.Count() < 2 || String.IsNullOrEmpty(parts[1]) || !(new []{"Ink","EraseByStroke","Select","None"}.Contains(parts[1]))) return;
                 Commands.SetInkCanvasMode.Execute(parts[1]);
                 break;                    
             case "SetLayer":
                 //This should come in the format of "SetLayer:Sketch"
                 if (parts.Count() < 2 || String.IsNullOrEmpty(parts[1]) || !(new []{"Select","Sketch","Text","Insert","View"}.Contains(parts[1]))) return;
                 Commands.SetLayer.Execute(parts[1]);
                 break;
         }
     }
     catch (Exception e)
     {
         App.auditor.error("SetValue", "CommandBridgeAutomationPeer", e);
     }
 }

        public override void OnMouseMove(System.Windows.Controls.InkCanvas inkCanvas, System.Windows.Input.MouseEventArgs e)
        {
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                bottomRight = e.GetPosition(inkCanvas);
                if(topLeft != bottomRight)
                {
                    StylusPointCollection pts = new StylusPointCollection();
                    GetRectangle(pts, (s) =>
                    {
                        if (StrokeResult != null)
                            inkCanvas.Strokes.Remove(StrokeResult);

                        DrawingAttributes drawingAttributes = new DrawingAttributes
                        {
                            Color = inkCanvas.DefaultDrawingAttributes.Color,
                            Width = inkCanvas.DefaultDrawingAttributes.Width,
                            StylusTip = StylusTip.Ellipse,
                            IgnorePressure = true,
                            FitToCurve = true
                        };
                        var BackgroundColor = inkCanvas.DefaultDrawingAttributes.GetPropertyData(DrawAttributesGuid.BackgroundColor);
                        drawingAttributes.AddPropertyData(DrawAttributesGuid.BackgroundColor, BackgroundColor);

                        StrokeResult = new RectangleStroke(s, drawingAttributes);
                        inkCanvas.Strokes.Add(StrokeResult);
                    }
                    );
                }

            }
        }

        internal static Cursor GetPenCursor(DrawingAttributes drawingAttributes, bool isHollow, bool isRightToLeft)
        {
            // Create pen Drawing.
            Drawing penDrawing = CreatePenDrawing(drawingAttributes, isHollow, isRightToLeft);

            // Create Cursor from Drawing
            return CreateCursorFromDrawing(penDrawing, new Point(0, 0));
        }

        //Переопределение базового метода DrawCore, который позволяет отрисовать линию штрихом, соединяющим заданные точки
        protected override void DrawCore(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            StylusPointCollection points = this.StylusPoints;

            StylusPoint p1 = points[0];
            StylusPoint p2 = points[1];

            drawingContext.DrawLine(new Pen(new SolidColorBrush(this.strokeColor), this.thickness), (Point)p1, (Point)p2);
        }

        //Переопредение базового метода, которое позволяет построить прямоугольник, имея левую нижнюю и правую верхнюю вершины
        protected override void DrawCore(DrawingContext context, DrawingAttributes overrides)
        {
            StylusPointCollection points = this.StylusPoints;

            StylusPoint p1 = points[0];
            StylusPoint p2 = points[1];

            context.DrawRectangle(new SolidColorBrush(this.fillColor), new Pen(new SolidColorBrush(this.strokeColor), thickness), new Rect((Point)p1, new Vector(p2.X - p1.X, p2.Y - p1.Y)));
        }

		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
		{
			Brush colorBrush = (Brush) value;
			SolidColorBrush newBrush = (SolidColorBrush) colorBrush;
			DrawingAttributes attr = new DrawingAttributes()
			                         	{
			                         		Color = newBrush.Color
			                         	};
			return attr;
		}

 private void penSize_Click(object sender, RoutedEventArgs e)
 {
     var rad = sender as RadioButton;
     var inkDA = new DrawingAttributes();
     inkDA.Width = rad.FontSize;
     inkDA.Height = rad.FontSize;
     inkDA.Color = InkCanv.DefaultDrawingAttributes.Color;
     inkDA.IsHighlighter = InkCanv.DefaultDrawingAttributes.IsHighlighter;
     InkCanv.DefaultDrawingAttributes = inkDA;
 }

 private void penSize_Click(object sender, RoutedEventArgs e)
 {
     RadioButton rad = sender as RadioButton;
     var inkDA = new DrawingAttributes();
     this.InkCanvas.UsesTouchShape = false;
     inkDA.Width = rad.FontSize;
     inkDA.Height = rad.FontSize;
     inkDA.Color = this.InkCanvas.DefaultDrawingAttributes.Color;
     inkDA.IsHighlighter = this.InkCanvas.DefaultDrawingAttributes.IsHighlighter;
     this.InkCanvas.DefaultDrawingAttributes = inkDA;
 }

 public static Cursor generateCursor(DrawingAttributes pen) 
 {
     using (DdMonitor.Lock(lockObject))
     {
         if (pen == previousPen) return previousCursor;
         var color = System.Drawing.Color.FromArgb(pen.Color.A, pen.Color.R, pen.Color.G, pen.Color.B);
         previousPen = pen;
         previousCursor = CursorHelper.CreateCursor((int)pen.Width, (int)pen.Height, color, (int)(pen.Width / 2), (int)(pen.Height / 2));
         return previousCursor;
     }
 }

        /// <summary>
        ///     Creates a mutable default value 
        /// </summary>
        internal override object CreateDefaultValue(DependencyObject owner, DependencyProperty property) 
        { 
            // Instantiate our default value instance.
            DrawingAttributes defaultValue = new DrawingAttributes(); 

            // Add event handlers for tracking the changes on the default value instance.
            DrawingAttributesDefaultPromoter promoter = new DrawingAttributesDefaultPromoter((InkCanvas)owner);
 
            defaultValue.AttributeChanged += new PropertyDataChangedEventHandler(promoter.OnDrawingAttributesChanged);
            defaultValue.PropertyDataChanged += new PropertyDataChangedEventHandler(promoter.OnDrawingAttributesChanged); 
 
            return defaultValue;
        } 

        /// <summary>
        /// Create a new Brush
        /// </summary>
        /// <param name="brushColor">The color of the brush</param>
        /// <param name="brushSize">The width and height of the brush</param>
        /// <returns></returns>
        public DrawingAttributes CreateBrush(Color brushColor, double brushSize)
        {
            DrawingAttributes newDA = new DrawingAttributes();

            newDA.Color = brushColor;
            newDA.IsHighlighter = false;
            newDA.IgnorePressure = true;
            newDA.StylusTip = StylusTip.Ellipse;
            newDA.Height = brushSize;
            newDA.Width = brushSize;

            return newDA;
        }