/// <summary>
 /// Constructor
 /// </summary>
 /// <param name="position">The position the arrow points to.</param>
 /// <param name="angle">angle of arrow with respect to x axis.</param>
 /// <param name="text">The text associated with the arrow.</param>
 public ArrowItem( PointD position, double angle, string text )
 {
     to_ = position;
     angle_ = -angle;
     text_ = text;
     Init();
 }

 public static void DrawTemplates(List<Tools.IToolFilter> templates, System.Drawing.Graphics gc, Tools.Render.RenderParameter rp, Tools.Render.RenderHint state, Tools.Render.IDrawVisitor drawMethods, PointD mousePosition)
 {
     foreach (Tools.IToolFilter filter in templates)
     {
         filter.Draw(gc, rp, state, drawMethods, mousePosition);
     }
 }

 static void ProduceIMAGE()
 {
     BitmapData data_bac = IMAGE.GetBitmapData();
     PointD p = data_bac.Half();
     PointD vector;
     double angle;
     for (int i = 0; i < 50; i++)
     {
         angle = i * 0.04 * Math.PI;
         vector = new PointD(Math.Sin(angle), -Math.Cos(angle));
         data_bac.DrawLine(Color.FromArgb(255, 255, 0), p.Add(vector, i % 5 == 0 ? 35 : 45), p.Add(vector, i % 5 == 0 ? 25 : 40));
     }
     for (int i = 0; i < 10; i++)
     {
         angle = i * 0.2 * Math.PI;
         vector = new PointD(Math.Sin(angle), -Math.Cos(angle));
         data_bac.Paste(i.ToString(),
             p.Add(vector, 40.0),
             Color.FromArgb(255, 255, 255),
             FONT_FOR_INITIALIZE,
             StringAlign.Middle,
             StringRowAlign.Middle);
     }
     data_bac.Multiply_A(0.5);
     IMAGE.UnlockBits(data_bac);
 }

 public MoveHandleAction(Handle handle, Session session, PointD oldLocation)
 {
     this.handle = handle;
       this.session = session;
       this.oldLocation = oldLocation;
       this.newLocation = handle.Location;
 }

 public Map(PointU16 mapSize, Orientation orientation, PointD cellSize, PointD origin, MapShapes mapShape = MapShapes.Rectangle)
 {
     _mapSize = mapSize;
     _shape = mapShape;
     mapLayout = new Layout(orientation, cellSize, origin);
     hexes = new List<Hex>();
 }

 public static double distance(PointD a, PointD b)
 {
     double xCuadrado = (a.X - b.X) * (a.X - b.X);
     double yCuadrado = (a.Y - b.Y) * (a.Y - b.Y);
     double distancia = Math.Sqrt(xCuadrado + yCuadrado);
     return distancia;
 }

        /// <summary>
        /// Returns a list of regular polygon's vertices, which has a 
        /// specified amount of sides and is inscribed into
        /// a circle of certain radius and center point.
        /// 
        /// The first vertice will be located at specified angle (counting counterclockwise)
        /// from the circle's rightmost point.
        /// </summary>
        /// <param name="sideCount">The total amount of polygon's sides. May be equal to 2 (then the resulting vertices will make up a line).</param>
        /// <param name="circleCenter">The center of the surrounding circle.</param>
        /// <param name="circleRadius">The radius of the surrounding circle.</param>
        /// <param name="initialAngle">The angle (in radians, counting counterclockwise from the circle's rightmost point) at which the first vertice will be located.</param>
        /// <returns>The list of regular polygon's vertices.</returns>
        public static List<PointD> RegularPolygonInscribedIntoCircle(int sideCount, PointD circleCenter, double circleRadius, double initialAngle = 0)
        {
            // Вектор в ноль градусов.
            VectorD initialVector = new VectorD(circleCenter, new PointD(circleCenter.X + circleRadius, circleCenter.Y));

            List<PointD> points = new List<PointD>(sideCount);

            // Вектор установлен на начальный угол.
            
            if(initialAngle != 0)
                initialVector = initialVector.VectorRotatedNewStartPoint(initialAngle, initialVector.StartPoint);
    
            points.Add(initialVector.EndPoint);

            double rotationAngle = 2 * Math.PI / sideCount;

            VectorD currentVector;

            for(int i=1; i<sideCount; i++)
            {
                currentVector = initialVector.VectorRotatedNewStartPoint(i * rotationAngle, initialVector.StartPoint);
                points.Add(currentVector.EndPoint);
            }

            return points;
        }

        private PointLatLng getLatLong(PointD i_location)
        {
            PointLatLng coordinates;
            coordinates = new PointLatLng(i_location.X, i_location.Y);

            return coordinates;
        }

        /// <summary>
        /// Draws the point plot on a GDI+ surface against the provided x and y axes.
        /// </summary>
        /// <param name="g">The GDI+ surface on which to draw.</param>
        /// <param name="xAxis">The X-Axis to draw against.</param>
        /// <param name="yAxis">The Y-Axis to draw against.</param>
        public virtual void Draw( Graphics g, PhysicalAxis xAxis, PhysicalAxis yAxis )
        {
            SequenceAdapter data_ =
                new SequenceAdapter( this.DataSource, this.DataMember, this.OrdinateData, this.AbscissaData );

            float leftCutoff_ = xAxis.PhysicalMin.X - marker_.Size;
            float rightCutoff_ = xAxis.PhysicalMax.X + marker_.Size;

            for (int i=0; i<data_.Count; ++i)
            {
                if ( !Double.IsNaN(data_[i].X) && !Double.IsNaN(data_[i].Y) )
                {
                    PointF xPos = xAxis.WorldToPhysical( data_[i].X, false);
                    if (xPos.X < leftCutoff_ || rightCutoff_ < xPos.X)
                        continue;

                    PointF yPos = yAxis.WorldToPhysical( data_[i].Y, false);
                    marker_.Draw( g, (int)xPos.X, (int)yPos.Y );
                    if (marker_.DropLine)
                    {
                        PointD yMin = new PointD( data_[i].X, Math.Max( 0.0f, yAxis.Axis.WorldMin ) );
                        PointF yStart = yAxis.WorldToPhysical( yMin.Y, false );
                        g.DrawLine( marker_.Pen, (int)xPos.X,(int)yStart.Y, (int)xPos.X,(int)yPos.Y );
                    }
                }
            }
        }

        private void MainForm_MouseDown(object sender, MouseEventArgs e)
        {
            if (checkBoxAddPoint.Checked)
            {
                scene.DataPoints.Add(new PointD(e.X, e.Y));
                this.Invalidate();
                return;
            }

            mouse_start = e.Location;
            this.Text = mouse_start.ToString();
            capture = scene.HitTest(e.X, e.Y);
            switch (capture)
            {
                case 1:
                    point_start = scene.CurrentBezier.Point1;
                    break;

                case 2:
                    point_start = scene.CurrentBezier.Point2;
                    break;

                case 3:
                    point_start = scene.CurrentBezier.Point3;
                    break;

                case 4:
                    point_start = scene.CurrentBezier.Point4;
                    break;

                default:
                    break;
            }
        }

 public override void DrawRegionRepresentation(System.Drawing.Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods, PointD mousePosition)
 {
     if (m_Param.Path.IsVisible((System.Drawing.Point)mousePosition))
     {
         gc.DrawString(ToString(), r.FontType, new System.Drawing.SolidBrush(r.RegionGuides.Color), new System.Drawing.PointF((float)mousePosition.X, (float)mousePosition.Y - 15));
     }
 }

 public void AddPoint(PointD p)
 {
     lock (tempRoute)
     {
         tempRoute.Add(p);
     }
 }

        public override bool DoMouseWheel(MouseEventArgs e, Control ctr, KeyEventArgs lastKeyEventArgs)
        {
            NPlot.PlotSurface2D ps = ((NPlot.Windows.PlotSurface2D)ctr).Inner;

            ((NPlot.Windows.PlotSurface2D)ctr).CacheAxes();

            double delta = e.Delta / (double)SystemInformation.MouseWheelScrollDelta;

            double zoomFactor = Math.Pow(sensitivity_, delta);

            PointD pMin = new PointD((double)ps.PhysicalXAxis1Cache.PhysicalMin.X, (double)ps.PhysicalYAxis1Cache.PhysicalMin.Y);
            PointD pMax = new PointD((double)ps.PhysicalXAxis1Cache.PhysicalMax.X, (double)ps.PhysicalYAxis1Cache.PhysicalMax.Y);

            PointD pMinRelative = new PointD(pMin.X - e.X, pMin.Y - e.Y);
            PointD pMaxRelative = new PointD(pMax.X - e.X, pMax.Y - e.Y);

            Point pMinZoomed = new Point((int)Math.Round((pMinRelative.X * zoomFactor) + e.X, 0), (int)Math.Round((pMinRelative.Y * zoomFactor) + e.Y, 0));
            Point pMaxZoomed = new Point((int)Math.Round((pMaxRelative.X * zoomFactor) + e.X, 0), (int)Math.Round((pMaxRelative.Y * zoomFactor) + e.Y, 0));

            ps.XAxis1.WorldMin = ps.PhysicalXAxis1Cache.PhysicalToWorld(pMinZoomed, false);
            ps.XAxis1.WorldMax = ps.PhysicalXAxis1Cache.PhysicalToWorld(pMaxZoomed, false);
            ps.YAxis1.WorldMin = ps.PhysicalYAxis1Cache.PhysicalToWorld(pMinZoomed, false);
            ps.YAxis1.WorldMax = ps.PhysicalYAxis1Cache.PhysicalToWorld(pMaxZoomed, false);

            return true;
        }

 public Effect(Bitmap image, PointD worldorpod, ImagePasteMode imagepastemode, EffectDock effectdock, Rectangle region = default(Rectangle))
     : base(null, image, default(Point), imagepastemode, region)
 {
     if (effectdock == EffectDock.Screen) throw new ArgumentException("Can't handle this parameter : effectdock");
     LOC = worldorpod;
     EFFECT_DOCK = effectdock;
 }

 public static PointD normalized2Pixels(PointD normalized)
 {
     double posX = normalized.X * (double)(Screen.PrimaryScreen.Bounds.Size.Width + Screen.PrimaryScreen.Bounds.X);
     double posY = normalized.Y * (double)(Screen.PrimaryScreen.Bounds.Size.Height + Screen.PrimaryScreen.Bounds.Y);
     PointD posicionMousePx = new PointD(posX, posY);
     return posicionMousePx;
 }

        public override string ActivateScript(CandleChartControl chart, PointD worldCoords)
        {
            if (!AccountStatus.Instance.isAuthorized)
            {
                MessageBox.Show("Не авторизован");
                return "Не авторизован";
            }

            var accountId = AccountStatus.Instance.accountID;
            var numStepsMax = (VolumeMax - VolumeMin) / VolumeStep;
            var rand = new Random();
            var sb = new StringBuilder();

            // закрытые сделки
            var closedOrders = MakeClosedOrders(chart, accountId, rand, numStepsMax);

            // SQL по закрытым сделкам
            MakeClosedOrdersSQL(closedOrders, accountId, sb);

            // найти все отметки на графике
            // и по ним сбацать "сделки"
            var positions = MakeMarketOrders(chart, accountId, rand, numStepsMax);

            // слепить SQL по открытым позам
            MakeMarketOrdersSQL(positions, accountId, sb);

            if (sb.Length > 0)
                Clipboard.SetText(sb.ToString());
            return (positions.Count + closedOrders.Count) + " сделок скопировано в буфер обмена";
        }

        public Line(DataRecordRow row)
            : this()
        {
            ID = LoadAttributeID( row.Fields, DirectoryDataType.LINE );
            PolygonIDLeft = LoadAttributeID( row.Fields, DirectoryDataType.PIDL );
            PolygonIDRight = LoadAttributeID( row.Fields, DirectoryDataType.PIDR );
            StartNodeID = LoadAttributeID( row.Fields, DirectoryDataType.SNID );
            EndNodeID = LoadAttributeID( row.Fields, DirectoryDataType.ENID );

            AttributeIDs = new List<KeyValuePair<string, int>>();
            var attr = row.Fields.Where( field => field.FieldDefinition.Directory.Tag == DirectoryDataType.ATID );
            if( attr.Any() )
            {
                for( int i = 0; i < attr.Count(); i += 2 )
                    AttributeIDs.Add( new KeyValuePair<string,int>(attr.ElementAt( i ).AsString, attr.ElementAt( i + 1 ).AsInt) );
            }

            var firstX = row.Fields.First( field => field.FieldDefinition.Name == "X" );
            var startIndex = row.Fields.IndexOf( firstX );
            for( int i = startIndex; i < row.Fields.Count; i += 2 )
            {
                var point = new PointD { X = row.Fields[ i ].AsInt / 100.0, Y = row.Fields[ i + 1 ].AsInt / 100.0 };
                Points.Add( point );
            }

            DataRow = row;
        }

 /// <summary>Returns a new BoundingBox bounding a single point.</summary>
 public static BoundingBoxD FromPoint(ref PointD pt)
 {
     BoundingBoxD box = new BoundingBoxD();
     box.Xmin = box.Xmax = pt.X;
     box.Ymin = box.Ymax = pt.Y;
     return box;
 }

        /// <summary>
        /// Vector with new start point
        /// with the length scaled by specified double factor.
        /// </summary>
        /// <param name="coefficient">Should be from 0 to 1.</param>
        /// <param name="newStartPoint">New start point.</param>
        public VectorD VectorScaledNewStartPoint(double coefficient, PointD newStartPoint)
        {
            double newX = this.X * coefficient;
            double newY = this.Y * coefficient;

            return new VectorD(newStartPoint, new PointD(newStartPoint.X + newX, newStartPoint.Y + newY));
        }

 public Point toPoint(PointD pD)
 {
     Point p = new Point(0, 0);
     p.X = Convert.ToInt32(pD.X + 0.5);
     p.Y = Convert.ToInt32(pD.Y + 0.5);
     return p;
 }