private void ExtendedGMapControl_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                if (OverlayPolygon_Vertices == null)
                {
                    OverlayPolygon_Vertices = new GMapOverlay("vertices");
                    this.Overlays.Add(OverlayPolygon_Vertices);
                }
                isMouseDown = true;

                if (this.PolygonsEnabled && _allowDrawPolygon)
                {
                    //if the polygon is incomplete, click will be create new vertices
                    if (!polygonIsComplete)
                    {
                        if (selectedVertice == null)
                        {
                            GMapMarkerRedCircle marker = new GMapMarkerRedCircle(this.FromLocalToLatLng(e.X, e.Y));
                            OverlayPolygon_Vertices.Markers.Add(marker);
                            this.selectedVertice = marker;
                        }
                    }
                }
                else
                {
                    //if (OverlayCustom != null && OverlayCustom.Markers.Count < 1)
                    //{
                    //    OverlayCustom.Markers.Clear();
                    //    GMapMarkerRedCircle marker = new GMapMarkerRedCircle(this.FromLocalToLatLng(e.X, e.Y));
                    //    OverlayCustom.Markers.Add(marker);
                    //}
                }
            }
        }
        public void AddMarker(double Lat, double Lng, string tooltip)
        {
            OverlayCustom = new GMapOverlay("custom");
            this.Overlays.Add(OverlayCustom);
            GMapMarkerRedCircle marker = new GMapMarkerRedCircle(new PointLatLng(Lat, Lng));

            OverlayCustom.Markers.Add(marker);
        }
        public GMapMarkerRedCircle AddMarkerRed(PointLatLng point)
        {
            OverlayCustom = new GMapOverlay("custom");
            this.Overlays.Add(OverlayCustom);
            GMapMarkerRedCircle marker = new GMapMarkerRedCircle(point);

            OverlayCustom.Markers.Add(marker);
            return(marker);
        }
        public void AddMarkerRedCircle(double Lat, double Lng, string tooltip)
        {
            OverlayBackground = this.Overlays[0];
            GMapMarkerRedCircle marker = new GMapMarkerRedCircle(new PointLatLng(Lat, Lng));

            marker.ToolTipText = tooltip;
            if (marker.ToolTip != null)
            {
                marker.ToolTip.Stroke.Color = Color.Red;
                marker.ToolTip.Stroke.Width = 2;
            }
            marker.IsVisible   = true;
            marker.ToolTipMode = MarkerTooltipMode.OnMouseOver;
            OverlayBackground.Markers.Add(marker);
        }
        public void SetDrawingPolygonCustom(CustomPolygon polygon)
        {
            ClearDrawingPolygon();
            OverlayFirst = this.Overlays[0];
            _polygon     = polygon;
            {
                OverlayPolygon_Auxiliary = new GMapOverlay("auxiliary");
                this.Overlays.Add(OverlayPolygon_Auxiliary);
                OverlayPolygon_Vertices = new GMapOverlay("vertices");
                this.Overlays.Add(OverlayPolygon_Vertices);
            }
            //draw the polygon
            if (polygon.Points.Count > 2)
            {
                for (int i = 0; i < polygon.Points.Count; i++)
                {
                    GMapMarkerRedCircle vertice = null;
                    if (i == polygon.Points.Count - 1)
                    {
                        vertice = (GMapMarkerRedCircle)OverlayPolygon_Vertices.Markers[0];
                    }
                    else
                    {
                        vertice = new GMapMarkerRedCircle(polygon.Points[i]);
                    }

                    OverlayPolygon_Vertices.Markers.Add(vertice);
                    if (i > 0)
                    {
                        PointLatLng          intermedium       = CalculateMiddlePoint(OverlayPolygon_Vertices.Markers[i - 1], OverlayPolygon_Vertices.Markers[i]);
                        GMapMarkerGraySquare intermediatePoint = new GMapMarkerGraySquare(intermedium);
                        OverlayPolygon_Auxiliary.Markers.Add(intermediatePoint);
                    }
                }
                polygonIsComplete = true;
            }

            if (!OverlayFirst.Polygons.Contains(_polygon))
            {
                OverlayFirst.Polygons.Add(_polygon);
            }
        }
예제 #6
0
 private void txtSearch_Properties_ButtonClick(object sender, ButtonPressedEventArgs e)
 {
     if (!string.IsNullOrEmpty(txtSearch.Text))
     {
         var txt = TaxiReturn_Process.Search(txtSearch.Text);
         if (txt != null)
         {
             MainMap.Position = new PointLatLng(txt.Value.Key, txt.Value.Value);
             if (AddMarkerRed == null)
             {
                 AddMarkerRed = MainMap.AddMarkerRed(MainMap.Position);
             }
             else
             {
                 AddMarkerRed.Position = MainMap.Position;
             }
             MainMap.Zoom = 16;
         }
         else
         {
             new MessageBox.MessageBoxBA().Show("Không tìm thấy địa chỉ");
         }
     }
 }
예제 #7
0
 private void txtSearch_KeyDown(object sender, KeyEventArgs e)
 {
     if (e.KeyData == Keys.Enter)
     {
         var txt = TaxiReturn_Process.Search(txtSearch.Text);
         if (txt != null)
         {
             MainMap.Position = new PointLatLng(txt.Value.Key, txt.Value.Value);
             if (AddMarkerRed == null)
             {
                 AddMarkerRed = MainMap.AddMarkerRed(MainMap.Position);
             }
             else
             {
                 AddMarkerRed.Position = MainMap.Position;
             }
             MainMap.Zoom = 16;
         }
         else
         {
             new MessageBox.MessageBoxBA().Show("Không tìm thấy địa chỉ");
         }
     }
 }
        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
                }
            }
        }