private void ExtendedGMapControl_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                isMouseDown = false;

                if (this.PolygonsEnabled && _allowDrawPolygon)
                {
                    #region OnDrop vertice
                    if (selectedVertice != null)
                    {
                        //until the poligon is complete, make auxiliary lines joining the vertices
                        if (!polygonIsComplete && OverlayPolygon_Vertices.Markers.Count > 1)
                        {
                            int            verticeIndex = OverlayPolygon_Vertices.Markers.IndexOf(selectedVertice);
                            Pen            pen          = new Pen(Brushes.DarkGray, 3);
                            GMapMarkerLine auxLine      = new GMapMarkerLine(selectedVertice.Position, OverlayPolygon_Vertices.Markers[verticeIndex - 1].Position, pen);
                            OverlayPolygon_Auxiliary.Markers.Add(auxLine);
                        }


                        if (isDraggingVertice)
                        {
                            isDraggingVertice = false;

                            if (polygonIsComplete)
                            {
                                _polygon.Points.Clear();
                                _polygon.Points.AddRange(OverlayPolygon_Vertices.Markers.Select(m => m.Position));
                                this.UpdatePolygonLocalPosition(_polygon);

                                //rearrangement intermediate points
                                int selectedIndex = OverlayPolygon_Vertices.Markers.IndexOf(selectedVertice);
                                //previous point
                                if (selectedIndex == 0)
                                {
                                    GMapMarker intermediatePoint = OverlayPolygon_Auxiliary.Markers.Last();
                                    intermediatePoint.Position = CalculateMiddlePoint(OverlayPolygon_Vertices.Markers[OverlayPolygon_Vertices.Markers.Count - 2], OverlayPolygon_Vertices.Markers[selectedIndex]);
                                }
                                else
                                {
                                    OverlayPolygon_Auxiliary.Markers[selectedIndex - 1].Position = CalculateMiddlePoint(OverlayPolygon_Vertices.Markers[selectedIndex - 1], OverlayPolygon_Vertices.Markers[selectedIndex]);
                                }
                                //next point
                                OverlayPolygon_Auxiliary.Markers[selectedIndex].Position = CalculateMiddlePoint(OverlayPolygon_Vertices.Markers[selectedIndex], OverlayPolygon_Vertices.Markers[selectedIndex + 1]);
                            }
                        }

                        selectedVertice = null;
                    }
                    #endregion
                    #region OnDrop intermediate point
                    //if dragging intermediate point dragging is finish
                    if (selectedIntermediatePoint != null)
                    {
                        if (isDraggingIntermediatePoint)
                        {
                            isDraggingIntermediatePoint = false;
                            //make a new vertice
                            GMapMarkerRedCircle newVertice = new GMapMarkerRedCircle(selectedIntermediatePoint.Position);
                            //remove the old intermediate point
                            int selectedIndex = OverlayPolygon_Auxiliary.Markers.IndexOf(selectedIntermediatePoint);
                            OverlayPolygon_Auxiliary.Markers.Remove(selectedIntermediatePoint);

                            //add the new vertice, in the correct position of the vertices collection
                            int newVerticeIndex = selectedIndex + 1;

                            OverlayPolygon_Vertices.Markers.Insert(newVerticeIndex, newVertice);

                            //update polygon
                            _polygon.Points.Clear();
                            _polygon.Points.AddRange(OverlayPolygon_Vertices.Markers.Select(m => m.Position));
                            this.UpdatePolygonLocalPosition(_polygon);

                            //make and add new intermediate points
                            PointLatLng          intermediatePosition1 = CalculateMiddlePoint(OverlayPolygon_Vertices.Markers[newVerticeIndex - 1], OverlayPolygon_Vertices.Markers[newVerticeIndex]);
                            GMapMarkerGraySquare intermediatePoint1    = new GMapMarkerGraySquare(intermediatePosition1);

                            PointLatLng          intermediatePosition2 = CalculateMiddlePoint(OverlayPolygon_Vertices.Markers[newVerticeIndex], OverlayPolygon_Vertices.Markers[newVerticeIndex + 1]);
                            GMapMarkerGraySquare intermediatePoint2    = new GMapMarkerGraySquare(intermediatePosition2);

                            OverlayPolygon_Auxiliary.Markers.Insert(selectedIndex, intermediatePoint1);
                            OverlayPolygon_Auxiliary.Markers.Insert(selectedIndex + 1, intermediatePoint2);
                        }

                        selectedIntermediatePoint = null;
                    }
                    #endregion
                }
            }
        }
Пример #2
0
        private KeyValuePair <double, string> AddRoute_ByService_Company(PointLatLng start, PointLatLng end, Color color)
        {
            try
            {
                float fromLat, fromLng, toLat, toLng = 0;
                float.TryParse(start.Lat.ToString(), out fromLat);
                float.TryParse(start.Lng.ToString(), out fromLng);
                float.TryParse(end.Lat.ToString(), out toLat);
                float.TryParse(end.Lng.ToString(), out toLng);

                Taxi.Services.WCFServiceGEO.PriceResponse itemReturn = Service_Common.GetPrice(fromLat, fromLng, toLat, toLng, Config_Common.DTV_ROUTE_SERVICE, G_CarType);
                if (itemReturn != null && itemReturn.Price > 0)
                {
                    if (color.Name == lbl_KM1.ForeColor.Name)
                    {
                        if (MainMap.Overlays[1].Markers != null && MainMap.Overlays[1].Markers.Count > 0)
                        {
                            MainMap.Overlays[1].Markers.Clear();
                        }
                    }
                    else if (color.Name == lbl_KM2.ForeColor.Name)
                    {
                        if (MainMap.Overlays[2].Markers != null && MainMap.Overlays[2].Markers.Count > 0)
                        {
                            MainMap.Overlays[2].Markers.Clear();
                        }
                    }
                    else if (color.Name == lbl_KM3.ForeColor.Name)
                    {
                        if (MainMap.Overlays[3].Markers != null && MainMap.Overlays[3].Markers.Count > 0)
                        {
                            MainMap.Overlays[3].Markers.Clear();
                        }
                    }
                    var lstCoordinate = MapHelper.PolylineAlgorithmDecode(itemReturn.Polyline);

                    PointLatLng itemStart = new PointLatLng();
                    PointLatLng itemEnd   = new PointLatLng();
                    Pen         pen       = new Pen(color, 3);
                    for (int i = 1; i < lstCoordinate.Count(); i++)
                    {
                        Coordinate itemCoor1 = lstCoordinate.ElementAt(i - 1);
                        Coordinate itemCoor2 = lstCoordinate.ElementAt(i);

                        itemStart = new PointLatLng(itemCoor1.Latitude, itemCoor1.Longitude);
                        itemEnd   = new PointLatLng(itemCoor2.Latitude, itemCoor2.Longitude);
                        GMapMarkerLine auxLine = new GMapMarkerLine(itemStart, itemEnd, pen);
                        if (color.Name == lbl_KM1.ForeColor.Name)
                        {
                            MainMap.Overlays[1].Markers.Add(auxLine);
                        }
                        else if (color.Name == lbl_KM2.ForeColor.Name)
                        {
                            MainMap.Overlays[2].Markers.Add(auxLine);
                        }
                        else if (color.Name == lbl_KM3.ForeColor.Name)
                        {
                            MainMap.Overlays[3].Markers.Add(auxLine);
                        }
                    }
                }
                return(new KeyValuePair <double, string>(Math.Round((double)itemReturn.Distance / 1000, 1), color.Name));
            }
            catch (Exception)
            {
                return(new KeyValuePair <double, string>(0, ""));
            }
        }