DrawLine() public method

Draws a line between the specified points.
This method doesn't return an error code if it fails. To determine whether a drawing operation (such as DrawLine) failed, check the result returned by the M:SharpDX.Direct2D1.RenderTarget.EndDraw(System.Int64@,System.Int64@) or M:SharpDX.Direct2D1.RenderTarget.Flush(System.Int64@,System.Int64@) methods.
public DrawLine ( RawVector2 point0, RawVector2 point1, Brush brush ) : void
point0 RawVector2 The start point of the line, in device-independent pixels.
point1 RawVector2 The end point of the line, in device-independent pixels.
brush Brush The brush used to paint the line's stroke.
return void
Beispiel #1
0
        public void OnRender(RenderTarget target)
        {
            if(gBorderBrush == null)
            {
                gBackgroundBrush = Brushes.Solid[0xCC555555];
                gBackgroundHoverBrush = Brushes.Solid[0xCC888888];
                gClickBrush = Brushes.Solid[0xFFFF7F00];
                gBackgroundClickedBrush = Brushes.Solid[0xCCBBBBBB];
                gBorderBrush = Brushes.White;
            }

            target.DrawTextLayout(new Vector2(Position.X + Size + 7, Position.Y - 2), mTextDraw, Brushes.White);

            var brush = gBackgroundBrush;
            if (mIsPressed)
                brush = gBackgroundClickedBrush;
            else if (mIsHovered)
                brush = gBackgroundHoverBrush;

            target.FillRectangle(mTargetRect, brush);
            target.DrawRectangle(mTargetRect, gBorderBrush);
            if (!Checked) return;

            target.DrawLine(Position + new Vector2(3, 3), Position + new Vector2(mSize - 3, mSize - 3), gClickBrush,
                mSize / 4.0f);
            target.DrawLine(new Vector2(Position.X + 3, Position.Y + mSize - 3),
                new Vector2(Position.X + mSize - 3, Position.Y + 3), gClickBrush, mSize / 4.0f);
        }
Beispiel #2
0
        protected void DrawHintAndInput()
        {
            if (!Paradigm.Config.Gui.InputBarVisibility)
            {
                return;
            }

            /* Draw Hint */
            if (HintText != null)
            {
                SharedBrush.Color = new Color(ForegroundColor.R, ForegroundColor.G, ForegroundColor.B, 0.7F);
                RenderTarget.DrawText(HintText, InputTextFormat, new RawRectangleF(10, 0, Width - 10, InputBoxHeight / 2),
                                      SharedBrush, D2D1.DrawTextOptions.None);
            }

            /* Draw user input text */
            if (InputTextLayout != null)
            {
                var rect = HintText == null
                    ? new RawRectangleF(10, 5, Width - 10, InputBoxHeight - 5)
                    : new RawRectangleF(10, InputBoxHeight / 2, Width - 10, InputBoxHeight);
                InputTextLayout.MaxWidth  = rect.Right - rect.Left;
                InputTextLayout.MaxHeight = rect.Bottom - rect.Top;
                InputTextLayout.Draw(_customColorRenderer, rect.Left, rect.Top);
            }

            /* Draw Input Box Bottom Line */
            SharedBrush.Color = ForegroundColor;
            RenderTarget.DrawLine(new RawVector2(10, InputBoxHeight + 2), new RawVector2(Width - 10, InputBoxHeight + 2), SharedBrush, 2);
        }
Beispiel #3
0
        public static void DrawLine(this SharpDX.Direct2D1.RenderTarget target, ID2DPen pen, float x1, float y1, float x2, float y2)
        {
            var pt1 = new RawVector2(x1, y1);
            var pt2 = new RawVector2(x2, y2);

            target.DrawLine(pt1, pt2, pen.Brush.NativeBrush, pen.StrokeWidth, pen.StrokeStyle);
        }
 public void Draw(double x, double y, double width, double height)
 {
     render.DrawLine(new Vector2((float)x, (float)(y)),
                     new Vector2((float)(x + width - 1), (float)(y)),
                     this.brush,
                     this.thickness,
                     this.stroke);
 }
Beispiel #5
0
            //---------------------------------------------------------------------------------------------------------
            /// <summary>
            /// Рисование линии
            /// </summary>
            //---------------------------------------------------------------------------------------------------------
            public override void Draw()
            {
                Direct2D.RenderTarget render_target = XDirect2DManager.D2DRenderTarget;

                if (mIsStroked)
                {
                    render_target.DrawLine(mStartPoint.ToRawVector2(),
                                           mEndPoint.ToRawVector2(), mStroke.Brush.D2DBrush, mStroke.Thickness, mStroke.mD2DStrokeStyle);
                }
            }
        public void Create3dObjects()
        {
            //Create RenderWindow
            RenderWindowInstance = new ModelRenderWindow();
            FormInstance = RenderWindowInstance.CreateWindow(1080,1240,FormStartPosition.CenterScreen);

            //Create SwapChain
            SwapChainCreator = new ModelSwapChainDesc();
            SwapChainD = SwapChainCreator.CreateSwapChain(2, Usage.RenderTargetOutput, FormInstance.Handle, true, 0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm, 1,0,SwapChainFlags.AllowModeSwitch, SwapEffect.Discard);

            //Create Device
            Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.BgraSupport, SwapChainD, out GraphicsDevice, out NewSwapChain);

            //Create Back buffer
            BackBuffer = Surface.FromSwapChain(NewSwapChain, 0);

            //Create Factory
            FactoryD2D FactoryInstance = new FactoryD2D();

            //Create RenderTarget
            RenderTargetInstance = new ModelRenderTarget();
            RenderTarget = RenderTargetInstance.CreateRenderTarget(SharpDX.Direct2D1.FeatureLevel.Level_DEFAULT, new PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Ignore), RenderTargetType.Default, RenderTargetUsage.None, BackBuffer, FactoryInstance);

            RenderLoop.Run(FormInstance, () =>
            {

                RenderTarget.BeginDraw();
                RenderTarget.Transform = Matrix3x2.Identity;
                RenderTarget.Clear(Color.White);

                using (var brush = new SolidColorBrush(RenderTarget, Color.Red))
                {
                    //for (int x = 0; x < RenderTarget.Size.Width; x += 10)
                    //    RenderTarget.DrawLine(new Vector2(x, 0), new Vector2(x, RenderTarget.Size.Height), brush, 0.5f);

                    //for (int y = 0; y < RenderTarget.Size.Height; y += 10)
                    //    RenderTarget.DrawLine(new Vector2(0, y), new Vector2(RenderTarget.Size.Width, y), brush, 0.5f);
                    RenderTarget.DrawLine(new Vector2(300, 10), new Vector2(300, 300), brush,1.5f);
                   // RenderTarget.FillRectangle(new RectangleF(RenderTarget.Size.Width / 2 - 50, RenderTarget.Size.Height / 2 - 50, 100, 100), brush);
                }

              //  RenderTarget.DrawRectangle(
                   // new RectangleF(RenderTarget.Size.Width / 2 - 100, RenderTarget.Size.Height / 2 - 100, 200, 200),
                   // new SolidColorBrush(RenderTarget, Color.CornflowerBlue));

                RenderTarget.EndDraw();

                NewSwapChain.Present(0, PresentFlags.None);
            });

            RenderTarget.Dispose();
            NewSwapChain.Dispose();
            GraphicsDevice.Dispose();
        }
Beispiel #7
0
        public void OnRender(RenderTarget target)
        {
            target.FillRectangle(new RectangleF(0, 0, mSize.X, mSize.Y), Brushes.Solid[0xFF333333]);

            target.PushAxisAlignedClip(new RectangleF(0, 100, mSize.X, mSize.Y - 100), AntialiasMode.Aliased);
            foreach (var label in mMapLabels)
                label.OnRender(target);
            target.PopAxisAlignedClip();

            target.DrawLine(new Vector2(0, 100.0f), new Vector2(mSize.X, 100.0f), Brushes.White);

            mTitleLabel.OnRender(target);
            mLabelScroll.OnRender(target);
        }
Beispiel #8
0
        /// <summary>
        /// Draws the given line with the given brush.
        /// </summary>
        public void DrawLine(Vector2 start, Vector2 end, BrushResource brush, float strokeWidth = 1f)
        {
            if (m_renderTarget == null)
            {
                return;
            }

            brush.EnsureNotNull(nameof(brush));
            strokeWidth.EnsurePositiveAndNotZero(nameof(strokeWidth));

            m_renderTarget.DrawLine(
                start.ToDXVector(), end.ToDXVector(),
                brush.GetBrush(m_device),
                strokeWidth);
        }
Beispiel #9
0
        public void OnRender(RenderTarget target)
        {
            var borderStart = new Vector2(mPosition.X + BorderOffsets.X, mPosition.Y);
            var borderEnd = new Vector2(mPosition.X + mSize.X - BorderOffsets.Y, mPosition.Y);

            target.FillRectangle(mTargetRectangle, Brushes.Solid[0xCC333333]);
            target.DrawLine(borderStart, borderEnd, Brushes.White);

            var ot = target.Transform;

            target.Transform *= Matrix3x2.Translation(Position.X, Position.Y);
            foreach (var item in Items)
                item.OnRender(target);

            target.Transform = ot;
        }
Beispiel #10
0
        public void Draw(ServiceResult serviceResult, float currentTime, float duration)
        {
            if (!uiInitialized)
            {
                return;
            }
            if (!redraw)
            {
                return;
            }
            redraw = false;

            target2d.BeginDraw();
            target2d.Clear(new Color4(0, 0, 0, 0.7f));

            target2d.DrawLine(new Vector2(0, 1), new Vector2(1024, 1), blueBrush, 2);
            target2d.DrawLine(new Vector2(0, 511), new Vector2(1024, 511), blueBrush, 2);

            textFormat.TextAlignment      = SharpDX.DirectWrite.TextAlignment.Center;
            textFormatSmall.TextAlignment = SharpDX.DirectWrite.TextAlignment.Center;

            if (serviceResult.contentType == ServiceResult.ContentType.video)
            {
                target2d.DrawText("now playing:", textFormatSmall, new RectangleF(0, 0, 1024, 100), textBrush);
                target2d.DrawText(serviceResult.TitleWithFallback, textFormat, new RectangleF(0, 50, 1024, 100), textBrush);

                var barLength     = 1024 - 265;
                var currentLength = barLength * (currentTime / duration);

                target2d.DrawLine(new Vector2(128, 384), new Vector2(1024 - 128, 384), textBrush, 6);
                target2d.DrawLine(new Vector2(128, 384), new Vector2(128 + currentLength, 384), blueBrush, 6);
                var ellipse = new DX2D.Ellipse(new Vector2(128 + currentLength + 3.5f, 384), 7, 7);
                target2d.FillEllipse(ellipse, blueBrush);

                target2d.DrawEllipse(new DX2D.Ellipse(new Vector2(512, 256), 48, 48), textBrush, 2);
                var dist = 8;
                var len  = 10;
                target2d.DrawLine(new Vector2(512 - dist, 256 - len), new Vector2(512 - dist, 256 + len), textBrush, 2);
                target2d.DrawLine(new Vector2(512 + dist, 256 - len), new Vector2(512 + dist, 256 + len), textBrush, 2);

                textFormatSmall.TextAlignment = SharpDX.DirectWrite.TextAlignment.Trailing;
                target2d.DrawText((new TimeSpan(0, 0, (int)Math.Floor(duration))).ToString(), textFormatSmall, new Rectangle(1024 - 128 - 150, 384, 150, 50), textBrush);


                int positionx = (int)(128 + currentLength - 74 / 2);
                positionx = MathUtil.Clamp(positionx, 128, 1024 - 128 - 74);
                textFormatSmall.TextAlignment = SharpDX.DirectWrite.TextAlignment.Center;
                target2d.DrawText((new TimeSpan(0, 0, (int)Math.Floor(currentTime))).ToString(), textFormatSmall, new Rectangle(positionx, 340, 74, 32), textBrush);
            }

            target2d.EndDraw();
        }
Beispiel #11
0
        public Result DrawUnderline(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref DW.Underline underline, ComObject clientDrawingEffect)
        {
            D2D.RenderTarget render = clientDrawingContext as D2D.RenderTarget;
            if (render == null)
            {
                return(SharpDX.Result.Ok);
            }

            D2D.SolidColorBrush foreBrush = this.factory.GetSolidColorBrush(this.DefaultFore);
            DrawingEffect       effect    = clientDrawingEffect as DrawingEffect;

            if (clientDrawingEffect != null && effect != null)
            {
                foreBrush = this.factory.GetSolidColorBrush(effect.Fore);
                float thickness = effect.isBoldLine ? D2DRenderCommon.BoldThickness : D2DRenderCommon.NormalThickness;
                if (effect.Stroke == HilightType.Squiggle)
                {
                    SquilleLineMarker marker = new D2DSquilleLineMarker(render, this.factory.GetSolidColorBrush(effect.Fore), this.factory.GetStroke(effect.Stroke), 1);
                    marker.Draw(
                        baselineOriginX, baselineOriginY + underline.Offset,
                        underline.Width, underline.RunHeight
                        );
                }
                else
                {
                    LineMarker marker = new LineMarker(render, this.factory.GetSolidColorBrush(effect.Fore), this.factory.GetStroke(effect.Stroke), GetThickness(render, thickness));
                    marker.Draw(
                        baselineOriginX, baselineOriginY + underline.Offset,
                        underline.Width, 0
                        );
                }
            }
            if (effect == null)
            {
                render.DrawLine(new Vector2(baselineOriginX, baselineOriginY + underline.Offset),
                                new Vector2(baselineOriginX + underline.Width - 1, baselineOriginY + underline.Offset),
                                foreBrush,
                                GetThickness(render, underline.Thickness));
            }

            return(SharpDX.Result.Ok);
        }
Beispiel #12
0
        /// <summary>
        /// Draws a line.
        /// </summary>
        /// <param name="pen">The stroke pen.</param>
        /// <param name="p1">The first point of the line.</param>
        /// <param name="p2">The second point of the line.</param>
        public void DrawLine(Pen pen, Point p1, Point p2)
        {
            if (pen != null)
            {
                var size = new Rect(p1, p2).Size;

                using (var d2dBrush = CreateBrush(pen.Brush, size))
                    using (var d2dStroke = pen.ToDirect2DStrokeStyle(_renderTarget))
                    {
                        if (d2dBrush.PlatformBrush != null)
                        {
                            _renderTarget.DrawLine(
                                p1.ToSharpDX(),
                                p2.ToSharpDX(),
                                d2dBrush.PlatformBrush,
                                (float)pen.Thickness,
                                d2dStroke);
                        }
                    }
            }
        }
Beispiel #13
0
        public void OnRender(RenderTarget target)
        {
            UpdateCaret();

            var transform = target.Transform;
            target.Transform *= Matrix3x2.Translation(Position);

            target.AntialiasMode = AntialiasMode.Aliased;
            target.FillRectangle(new RectangleF(0, 0, mSize.X, mSize.Y), Brushes.Solid[0xCC111111]);
            target.DrawRectangle(new RectangleF(0, 0, mSize.X, mSize.Y), Brushes.Solid[System.Drawing.Color.White]);
            target.PushAxisAlignedClip(new RectangleF(4, 0, mSize.X - 8, mSize.Y), AntialiasMode.Aliased);
            target.DrawTextLayout(new Vector2(mStartPosition, 0), mTextDraw, Brushes.Solid[0xFFFFFFFF]);
            target.PopAxisAlignedClip();
            if (mCaretVisible && mIsFocused)
            {
                target.DrawLine(new Vector2(mCaretOffset, 4), new Vector2(mCaretOffset, 23),
                    Brushes.Solid[0xFFFFFFFF], 2.0f);
            }

            target.Transform = transform;
        }
Beispiel #14
0
        public Result DrawStrikethrough(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref DW.Strikethrough strikethrough, ComObject clientDrawingEffect)
        {
            D2D.RenderTarget render = clientDrawingContext as D2D.RenderTarget;
            if (render == null)
            {
                return(SharpDX.Result.Ok);
            }

            D2D.SolidColorBrush foreBrush = this.factory.GetSolidColorBrush(this.DefaultFore);
            DrawingEffect       effect    = clientDrawingEffect as DrawingEffect;

            if (clientDrawingEffect != null && clientDrawingEffect != null)
            {
                foreBrush = this.factory.GetSolidColorBrush(effect.Fore);
            }
            if (effect == null)
            {
                render.DrawLine(new Vector2(baselineOriginX, baselineOriginY + strikethrough.Offset),
                                new Vector2(baselineOriginX + strikethrough.Width - 1, baselineOriginY + strikethrough.Offset),
                                foreBrush,
                                GetThickness(render, strikethrough.Thickness));
            }
            return(Result.Ok);
        }
Beispiel #15
0
        public virtual void Draw(RenderTarget g)
        {
            //Texture draw call
            if (Texture != null)
            {
                DrawingPositionRect = new RectangleF(X - Game.VIEWPORT.X, Y - Game.VIEWPORT.Y, Width, Height);
                Texture.DrawTexture(g, new RectangleF(X, Y, Width, Height));
            }

            //Debug drawing options
            if (Config.DEBUG_MODE == DebugMode.DISPLAY_HITBOX)
            {
                g.DrawRectangle(new RectangleF(Hitbox.X, Hitbox.Y, Hitbox.Width, Hitbox.Height), Resources.SCBRUSH_RED);
            }
            else if (Config.DEBUG_MODE == DebugMode.DISPLAY_RECT)
            {
                g.DrawRectangle(new RectangleF(X, Y, Width, Height), Resources.SCBRUSH_RED);
                g.DrawLine(new Vector2(X, Y), new Vector2(X + Width, Y + Height), Resources.SCBRUSH_RED);
                g.DrawLine(new Vector2(X, Y + Height), new Vector2(X + Width, Y), Resources.SCBRUSH_RED);
            }
            /* Used for debug purposes
            if (drawHitbox)
                g.DrawRectangle(Hitbox, Resources.SCBRUSH_BLACK, 3f);
            */
        }
        private void DrawFpsSamples(RenderTarget target)
        {
            var maxValue = mFpsSamples.Max();
            var minValue = mFpsSamples.Min();
            if (MathUtil.WithinEpsilon(minValue, maxValue, 0.5f)) maxValue = minValue + 10;

            var baseOffset = 0.0f;
            var step = mSize.X / 19.0f;
            var diff = (DateTime.Now - mLastFpsSample);

            if (mFpsSamples.Count == 20)
                baseOffset = (float)diff.TotalSeconds * step;

            var curPos = mFpsRectangle.Left - baseOffset;
            var endY = mFpsRectangle.Bottom - 5;
            var height = mFpsRectangle.Height - 20;

            target.PushAxisAlignedClip(mFpsRectangle, AntialiasMode.Aliased);

            for (var i = 1; i < mFpsSamples.Count; ++i)
            {
                var sat = (mFpsSamples[i] - minValue) / (maxValue - minValue);
                var satPrev = (mFpsSamples[i - 1] - minValue) / (maxValue - minValue);
                target.DrawLine(new Vector2(curPos, endY - satPrev * height), new Vector2(curPos + step, endY - sat * height), Brushes.White);
                curPos += step;
            }

            var satLast = (mFpsSamples.Last() - minValue) / (maxValue - minValue);
            target.DrawLine(new Vector2(curPos, endY - satLast * height),
                new Vector2(curPos + (float)diff.TotalSeconds * step, endY - satLast * height), Brushes.White);

            target.PopAxisAlignedClip();

            mFpsMin.Text = minValue.ToString("F2");
            mFpsMax.Text = maxValue.ToString("F2");

            target.DrawTextLayout(new Vector2(Position.X + 3.0f, mFpsRectangle.Top - 20.0f), mFpsMax, Brushes.White);
            target.DrawTextLayout(new Vector2(Position.X + 3.0f, mFpsRectangle.Bottom + 2.0f), mFpsMin, Brushes.White);
        }
        private void DrawMemorySamples(RenderTarget target)
        {
            var maxValue = mMemorySamples.Max();
            var minValue = mMemorySamples.Min();
            if (minValue == maxValue) maxValue = minValue + 50;

            var baseOffset = 0.0f;
            var step = mSize.X / 19.0f;
            var diff = (DateTime.Now - mLastMemorySample);

            if (mMemorySamples.Count == 20)
                baseOffset = ((float)diff.TotalSeconds / 0.5f) * step;

            var curPos = mMemoryRectangle.Left - baseOffset;
            var endY = mMemoryRectangle.Bottom - 5;
            var height = mMemoryRectangle.Height - 20;

            target.PushAxisAlignedClip(mMemoryRectangle, AntialiasMode.Aliased);

            for (var i = 1; i < mMemorySamples.Count; ++i)
            {
                var sat = (mMemorySamples[i] - (float)minValue) / (maxValue - minValue);
                var satPrev = (mMemorySamples[i - 1] - (float)minValue) / (maxValue - minValue);
                target.DrawLine(new Vector2(curPos, endY - satPrev * height), new Vector2(curPos + step, endY - sat * height), Brushes.White);
                curPos += step;
            }

            var satLast = (mMemorySamples.Last() - (float) minValue) / (maxValue - minValue);
            target.DrawLine(new Vector2(curPos, endY - satLast * height),
                new Vector2(curPos + ((float)diff.TotalSeconds / 0.5f) * step, endY - satLast * height), Brushes.White);

            target.PopAxisAlignedClip();

            DrawMemoryStrings(target, maxValue, minValue);
        }
Beispiel #18
0
 public void DrawLine(Location From, Location To)
 {
     _renderTarget.DrawLine(From.ToD2D(), To.ToD2D(), brush);
 }
Beispiel #19
0
 public void Draw(SharpDX.Direct2D1.RenderTarget renderTarget)
 {
     renderTarget.DrawLine(From, To, Color, StrokeWidth);
 }
        protected override void Draw(D2D1.RenderTarget renderTarget)
        {
            renderTarget.Clear(Color.Black);

            double[][] samples;
            lock (_values)
                samples = _values.ToArray();
            var sampleCount = samples.Length;

            double range;

            double[] chMeans;
            {
                var channelSums = new double[_channelNum];
                var max         = double.NegativeInfinity;
                var min         = double.PositiveInfinity;
                foreach (var channels in samples)
                {
                    for (var ch = 0; ch < channels.Length; ch++)
                    {
                        var channel = channels[ch];
                        channelSums[ch] += channel;
                        if (max < channel)
                        {
                            max = channel;
                        }
                        if (min > channel)
                        {
                            min = channel;
                        }
                    }
                }

                range = max - (min + max) / 2;
                for (var i = 0; i < channelSums.Length; i++)
                {
                    channelSums[i] /= sampleCount;
                }
                chMeans = channelSums;
            }

            var clientSize     = ClientSize;
            var channelHeight  = clientSize.Height / (float)_channelNum;
            var sampleInterval = clientSize.Width / (float)_windowLength;

            RawVector2 Point(float xOffset, float yOffset, int sIdx, int chIdx) =>
            new RawVector2(xOffset, (float)(yOffset + channelHeight / 2 + (samples[sIdx][chIdx] - chMeans[chIdx]) / range * channelHeight / 2 * 0.9));

            SolidColorBrush.Color = Color.White;
            if (!samples.IsEmpty())
            {
                for (var ch = 0; ch < _channelNum; ch++)
                {
                    var yOffset = ch * channelHeight;
                    var xOffset = (float)Width;
                    var s       = samples.Length - 1;
                    var prev    = Point(xOffset, yOffset, s, ch);
                    for (; s >= 0; s--)
                    {
                        xOffset -= sampleInterval;
                        var current = Point(xOffset, yOffset, s, ch);
                        renderTarget.DrawLine(prev, current, SolidColorBrush, 2);
                        prev = current;
                    }
                }
            }
        }
Beispiel #21
0
        /// <summary>
        /// render the circle to specific render target of Direct2D1
        /// </summary>
        /// <param name="renderTarget"></param>
        public void Render2D( RenderTarget renderTarget, SharpDX.Direct2D1.Brush brush )
        {
            // if the brush is dirty renew it
            if ( m_isLineColorBrushDirty ) {
                // clean the color brush
                if ( m_lineColorBrush != null )
                    m_lineColorBrush.Dispose();

                // allocate a new one
                m_lineColorBrush = new SolidColorBrush( renderTarget, m_lineColor );

                // clean the flag
                m_isLineColorBrushDirty = false;
            }

            if (m_useDefaultColor || m_lineColorBrush == null)
            {
                renderTarget.DrawLine(m_pStart, m_pEnd, brush, m_lineWidth);
            }
            else
            {
                // draw
                renderTarget.DrawLine(m_pStart, m_pEnd, m_lineColorBrush, m_lineWidth);
            }
        }