Map Events Sample

A sample about ASP.NET Google Map Control map events and how to handle them on the client or server.

The map fire next events: bounds changed, center changed, click, double click, drag, drag end, drag start, heading changed, idle, map type changed, mouse move, mouse out, mouse over, projection changed, resize, right click, tiles loaded, tilt changed, zoom changed.

Use the event options bellow to set handlers for different map events and test them.
The event fired by the map will be listed in the info list bellow (most recent first).

Be careful when adding server side handlers to BoundsChanged, HeadingChanged, ProjectionChanged and TilesLoaded.
Those events are fired on map loaded and adding them always will cause an infinite post-back loop, like in the sample here.

Thank you for using the Development Build of ASP.NET Google Map Control to build Google Maps faster.
Purchase the Commercial Build now to get access to all product updates and the ASP.NET Google Map Control expert support.

Events (most recent first):

Events

Here is the list of map events you can handle client and server side.

  • Click - This event is fired when the user clicks on the map (but not when they click on a marker or infowindow).
    • Client Side Handler
    • Server Side Handler
  • DoubleClick - This event is fired when the user double-clicks on the map. Note that the click event will also fire, right before this one.
    • Client Side Handler
    • Server Side Handler
  • RightClick - This event is fired when the DOM contextmenu event is fired on the map container.
    • Client Side Handler
    • Server Side Handler
  • BoundsChanged - This event is fired when the viewport bounds have changed.
    • Client Side Handler
    • Server Side Handler
  • CenterChanged - This event is fired when the map center property changes.
    • Client Side Handler
    • Server Side Handler
  • Drag
    • Client Side Handler
    • Server Side Handler
  • DragStart
    • Client Side Handler
    • Server Side Handler
  • DragEnd
    • Client Side Handler
    • Server Side Handler
  • HeadingChanged
    • Client Side Handler
    • Server Side Handler
  • Idle
    • Client Side Handler
    • Server Side Handler
  • MapTypeChanged
    • Client Side Handler
    • Server Side Handler
  • MouseMove
    • Client Side Handler
    • Server Side Handler
  • MouseOut
    • Client Side Handler
    • Server Side Handler
  • MouseOver
    • Client Side Handler
    • Server Side Handler
  • ProjectionChanged
    • Client Side Handler
    • Server Side Handler
  • Resize
    • Client Side Handler
    • Server Side Handler
  • TilesLoaded
    • Client Side Handler
    • Server Side Handler
  • TiltChanged
    • Client Side Handler
    • Server Side Handler
  • ZoomChanged
    • Client Side Handler
    • Server Side Handler

Source

Markup

<%@ Page Language="C#" MasterPageFile="../Maps.master" CodeBehind="Default.aspx.cs" Inherits="GoogleMaps.Samples.Maps.Events.Default" %>

<asp:Content runat="server" ID="mainContent" ContentPlaceHolderID="MainContent">
    <div class="jumbotron">
        <h2>Map Events Sample</h2>
        <p>
            A sample about ASP.NET Google Map Control map events and how to handle them on the client or server.
        </p>
    </div>
    <p>
        The map fire next events: bounds changed, center changed, click, double click, drag,
        drag end, drag start, heading changed, idle, map type changed, mouse move, mouse
        out, mouse over, projection changed, resize, right click, tiles loaded, tilt changed,
        zoom changed.
    </p>
    <p>
        Use the event options bellow to set handlers for different map events and test them.<br />
        The event fired by the map will be listed in the info list bellow (most recent first).
    </p>
    <p>
        Be careful when adding server side handlers to BoundsChanged, HeadingChanged, ProjectionChanged and TilesLoaded.<br />
        Those events are fired on map loaded and adding them always will cause an infinite post-back loop, like in the sample here.
    </p>
    <div class="map-wrap">
        <map:GoogleMap ID="GoogleMap1" runat="server" Zoom="6" CssClass="map" DefaultAddress="Hjo, Sweden"
            Width="100%" Height="600px" FullscreenControl="true">
        </map:GoogleMap>
    </div>
    <p>
        Events (most recent first):
        <input type="button" value="Clear" onclick="handleClearClick()" class="btn btn-basic" />
    </p>
    <asp:ListBox ID="lbEventsList" runat="server" Width="100%" Rows="10" ClientIDMode="Static"></asp:ListBox>
    <asp:FormView ID="fvEvents" runat="server" DefaultMode="Edit" ItemType="GoogleMaps.Samples.Maps.Events.MapEventsModel" SelectMethod="GetMapEventsModel" UpdateMethod="UpdateMapEventsModel" Width="100%">
        <EditItemTemplate>
            <h3>Events</h3>
            <p>
                Here is the list of map events you can handle client and server side.
            </p>
            <ul>
                <li>Click - This event is fired when the user clicks on the map (but not when they click on a marker or infowindow).
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleClickOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleClickOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>DoubleClick - This event is fired when the user double-clicks on the map. Note that the click event will also fire, right before this one.
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleDoubleClickOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleDoubleClickOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>RightClick - This event is fired when the DOM contextmenu event is fired on the map container.
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleRightClickOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleRightClickOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>BoundsChanged - This event is fired when the viewport bounds have changed.
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleBoundsChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleBoundsChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>CenterChanged - This event is fired when the map center property changes.
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleCenterChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleCenterChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>Drag
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleDragOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleDragOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>DragStart
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleDragStartOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleDragStartOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>DragEnd
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleDragEndOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleDragEndOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>HeadingChanged
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleHeadingChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleHeadingChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>Idle
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleIdleOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleIdleOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>MapTypeChanged
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleMapTypeChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleMapTypeChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>MouseMove
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleMouseMoveOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleMouseMoveOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>MouseOut
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleMouseOutOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleMouseOutOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>MouseOver
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleMouseOverOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleMouseOverOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>ProjectionChanged
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleProjectionChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleProjectionChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>Resize
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleResizeOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleResizeOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>TilesLoaded
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleTilesLoadedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleTilesLoadedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
                <li>TiltChanged
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleTiltChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleTiltChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>

                <li>ZoomChanged
                    <ul>
                        <li>
                            <asp:DynamicControl DataField="HandleZoomChangedOnClient" Mode="Edit" runat="server" />
                            Client Side Handler
                        </li>
                        <li>
                            <asp:DynamicControl DataField="HandleZoomChangedOnServer" Mode="Edit" runat="server" />
                            Server Side Handler
                        </li>
                    </ul>
                </li>
            </ul>
            <div style="text-align: center">
                <asp:Button runat="server" Text="Apply" CommandName="Update" CssClass="btn btn-primary" />
            </div>
        </EditItemTemplate>
    </asp:FormView>
    <script type="text/javascript">
        "use strict";

        var list = document.getElementById("lbEventsList");

        function handleClearClick() {
            $("#lbEventsList").empty();
        }

        function handleBoundsChanged(sender, e) {
            debugger;
            printEvent("Bounds Changed", sender, e);
        }
        function handleCenterChanged(sender, e) {
            debugger;
            printEvent("Center Changed", sender, e);
        }
        function handleClick(sender, e) {
            debugger;
            printEvent("Click", sender, e);
        }
        function handleDoubleClick(sender, e) {
            debugger;
            printEvent("Double Click", sender, e);
        }
        function handleDrag(sender, e) {
            debugger;
            printEvent("Drag", sender, e);
        }
        function handleDragEnd(sender, e) {
            debugger;
            printEvent("Drag End", sender, e);
        }
        function handleDragStart(sender, e) {
            debugger;
            printEvent("Drag Start", sender, e);
        }
        function handleHeadingChanged(sender, e) {
            debugger;
            printEvent("Heading Changed", sender, e);
        }
        function handleMapTypeChanged(sender, e) {
            debugger;
            printEvent("Map Type Changed", sender, e);
        }
        function handleMouseMove(sender, e) {
            debugger;
            printEvent("Mouse Move", sender, e);
        }
        function handleMouseOut(sender, e) {
            debugger;
            printEvent("Mouse Out", sender, e);
        }
        function handleMouseOver(sender, e) {
            debugger;
            printEvent("Mouse Over", sender, e);
        }
        function handleProjectionChanged(sender, e) {
            debugger;
            printEvent("Projection Changed", sender, e);
        }
        function handleResize(sender, e) {
            debugger;
            printEvent("Resize", sender, e);
        }
        function handleRightClick(sender, e) {
            debugger;
            printEvent("Right Click", sender, e);
        }
        function handleTilesLoaded(sender, e) {
            debugger;
            printEvent("Tiles Loaded", sender, e);
        }
        function handleTiltChanged(sender, e) {
            debugger;
            printEvent("Tilt Changed", sender, e);
        }
        function handleZoomChanged(sender, e) {
            debugger;
            printEvent("Zoom Changed", sender, e);
        }

        function printEvent(name, sender, e) {

            var buffer = [];
            buffer.push("[Client] ");
            buffer.push(name);
            buffer.push(" was fired");
            if (e) {
                if (e.latLng) {
                    buffer.push(" at position [lat: ");
                    buffer.push(e.latLng.lat());
                    buffer.push(", lng: ");
                    buffer.push(e.latLng.lng());
                    buffer.push("]");
                }
            }
            buffer.push(".");

            var option = document.createElement("option");
            option.text = buffer.join('');

            if (list.childNodes.length > 0) {
                list.insertBefore(option, list.childNodes[0]);
            }
            else {
                list.appendChild(option);
            }
        }
    </script>
    
</asp:Content>

Code Behind

using System;

namespace GoogleMaps.Samples.Maps.Events
{
    public partial class Default : System.Web.UI.Page
    {
        private MapEventsModel _model;

        public MapEventsModel GetMapEventsModel()
        {
            return _model ?? new MapEventsModel();
        }

        public void UpdateMapEventsModel(MapEventsModel model)
        {
            _model = model;
            SetMapEvents();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            _model = ViewState["model"] as MapEventsModel;

            if (_model != null)
            {
                SetMapEvents();
            }
        }

        protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);
            if (_model != null)
            {
                ViewState.Add("model", _model);
            }
        }

        private void PrintMouseEvent(string name, MouseEventArgs e)
        {
            lbEventsList.Items.Add($"[Server] {name} was fired at position [lat: {e.Position.Latitude} , lng: {e.Position.Longitude} ]");
        }

        private void PrintMapEvent(string name, MapEventArgs e)
        {
            lbEventsList.Items.Add($"[Server] {name} was fired with map settings [bounds: {e.Bounds} , center: {e.Center}, mapType: {e.MapType}, zoom: {e.Zoom} ]");
        }

        private void PrintEvent(string name, EventArgs e)
        {
            lbEventsList.Items.Add($"[Server] {name} was fired.");
        }

        private void SetMapEvents()
        {
            if (_model.HandleBoundsChangedOnClient)
            {
                GoogleMap1.OnClientBoundsChanged = "handleBoundsChanged";
            }
            if (_model.HandleBoundsChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.BoundsChanged += (s, e) => PrintMapEvent(nameof(GoogleMap1.BoundsChanged), e);
            }

            if (_model.HandleCenterChangedOnClient)
            {
                GoogleMap1.OnClientCenterChanged = "handleCenterChanged";
            }
            if (_model.HandleCenterChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.CenterChanged += (s, e) => PrintMapEvent(nameof(GoogleMap1.CenterChanged), e);
            }

            if (_model.HandleClickOnClient)
            {
                GoogleMap1.OnClientClick = "handleClick";
            }
            if (_model.HandleClickOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.Click += (s, e) => PrintMouseEvent(nameof(GoogleMap1.Click), e);
            }

            if (_model.HandleDoubleClickOnClient)
            {
                GoogleMap1.OnClientDoubleClick = "handleDoubleClick";
            }
            if (_model.HandleDoubleClickOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.DoubleClick += (s, e) => PrintMouseEvent(nameof(GoogleMap1.DoubleClick), e);
            }

            if (_model.HandleDragOnClient)
            {
                GoogleMap1.OnClientDrag = "handleDrag";
            }
            if (_model.HandleDragOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.Drag += (s, e) => PrintMapEvent(nameof(GoogleMap1.Drag), e);
            }

            if (_model.HandleDragEndOnClient)
            {
                GoogleMap1.OnClientDragEnd = "handleDragEnd";
            }
            if (_model.HandleDragEndOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.DragEnd += (s, e) => PrintMapEvent(nameof(GoogleMap1.DragEnd), e);
            }

            if (_model.HandleDragStartOnClient)
            {
                GoogleMap1.OnClientDragStart = "handleDragStart";
            }
            if (_model.HandleDragStartOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.DragStart += (s, e) => PrintMapEvent(nameof(GoogleMap1.DragStart), e);
            }

            if (_model.HandleHeadingChangedOnClient)
            {
                GoogleMap1.OnClientHeadingChanged = "handleHeadingChanged";
            }
            if (_model.HandleHeadingChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.HeadingChanged += (s, e) => PrintEvent(nameof(GoogleMap1.HeadingChanged), e);
            }

            if (_model.HandleIdleOnClient)
            {
                GoogleMap1.OnClientIdle = "handleIdle";
            }
            if (_model.HandleHeadingChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.Idle += (s, e) => PrintEvent(nameof(GoogleMap1.Idle), e);
            }

            if (_model.HandleMapTypeChangedOnClient)
            {
                GoogleMap1.OnClientMapTypeChanged = "handleMapTypeChanged";
            }
            if (_model.HandleMapTypeChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.MapTypeChanged += (s, e) => PrintMapEvent(nameof(GoogleMap1.MapTypeChanged), e);
            }

            if (_model.HandleMouseMoveOnClient)
            {
                GoogleMap1.OnClientMouseMove = "handleMouseMove";
            }
            if (_model.HandleMouseMoveOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.MouseMove += (s, e) => PrintMouseEvent(nameof(GoogleMap1.MouseMove), e);
            }

            if (_model.HandleMouseOutOnClient)
            {
                GoogleMap1.OnClientMouseOut = "handleMouseOut";
            }
            if (_model.HandleMouseOutOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.MouseOut += (s, e) => PrintMouseEvent(nameof(GoogleMap1.MouseOut), e);
            }

            if (_model.HandleMouseOverOnClient)
            {
                GoogleMap1.OnClientMouseOver = "handleMouseOver";
            }
            if (_model.HandleMouseOverOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.MouseOver += (s, e) => PrintMouseEvent(nameof(GoogleMap1.MouseOver), e);
            }

            if (_model.HandleProjectionChangedOnClient)
            {
                GoogleMap1.OnClientProjectionChanged = "handleProjectionChanged";
            }
            if (_model.HandleProjectionChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.ProjectionChanged += (s, e) => PrintEvent(nameof(GoogleMap1.ProjectionChanged), e);
            }

            if (_model.HandleResizeOnClient)
            {
                GoogleMap1.OnClientResize = "handleResize";
            }
            if (_model.HandleResizeOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.Resize += (s, e) => PrintMapEvent(nameof(GoogleMap1.Resize), e);
            }

            if (_model.HandleRightClickOnClient)
            {
                GoogleMap1.OnClientRightClick = "handleRightClick";
            }
            if (_model.HandleRightClickOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.RightClick += (s, e) => PrintMouseEvent(nameof(GoogleMap1.RightClick), e);
            }

            if (_model.HandleTilesLoadedOnClient)
            {
                GoogleMap1.OnClientTilesLoaded = "handleTilesLoaded";
            }
            if (_model.HandleTilesLoadedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.TilesLoaded += (s, e) => PrintEvent(nameof(GoogleMap1.TilesLoaded), e);
            }

            if (_model.HandleTiltChangedOnClient)
            {
                GoogleMap1.OnClientTiltChanged = "handleTiltChanged";
            }
            if (_model.HandleTiltChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.TiltChanged += (s, e) => PrintEvent(nameof(GoogleMap1.TiltChanged), e);
            }

            if (_model.HandleZoomChangedOnClient)
            {
                GoogleMap1.OnClientZoomChanged = "handleZoomChanged";
            }
            if (_model.HandleZoomChangedOnServer)
            {
                // we just adding a lambda event handler here, but you can specify any method with the proper signature
                GoogleMap1.ZoomChanged += (s, e) => PrintMapEvent(nameof(GoogleMap1.ZoomChanged), e);
            }
        }
    }
}

Model

using System;

namespace GoogleMaps.Samples.Maps.Events
{
    [Serializable]
    public class MapEventsModel
    {
        public bool HandleBoundsChangedOnClient { get; set; }
        public bool HandleBoundsChangedOnServer { get; set; }

        public bool HandleCenterChangedOnClient { get; set; }
        public bool HandleCenterChangedOnServer { get; set; }

        public bool HandleClickOnClient { get; set; }
        public bool HandleClickOnServer { get; set; }

        public bool HandleDoubleClickOnClient { get; set; }
        public bool HandleDoubleClickOnServer { get; set; }

        public bool HandleDragOnClient { get; set; }
        public bool HandleDragOnServer { get; set; }

        public bool HandleDragEndOnClient { get; set; }
        public bool HandleDragEndOnServer { get; set; }

        public bool HandleDragStartOnClient { get; set; }
        public bool HandleDragStartOnServer { get; set; }

        public bool HandleHeadingChangedOnClient { get; set; }
        public bool HandleHeadingChangedOnServer { get; set; }

        public bool HandleIdleOnClient { get; set; }
        public bool HandleIdleOnServer { get; set; }

        public bool HandleMapTypeChangedOnClient { get; set; }
        public bool HandleMapTypeChangedOnServer { get; set; }

        public bool HandleMouseMoveOnClient { get; set; }
        public bool HandleMouseMoveOnServer { get; set; }

        public bool HandleMouseOutOnClient { get; set; }
        public bool HandleMouseOutOnServer { get; set; }

        public bool HandleMouseOverOnClient { get; set; }
        public bool HandleMouseOverOnServer { get; set; }

        public bool HandleProjectionChangedOnClient { get; set; }
        public bool HandleProjectionChangedOnServer { get; set; }

        public bool HandleResizeOnClient { get; set; }
        public bool HandleResizeOnServer { get; set; }

        public bool HandleRightClickOnClient { get; set; }
        public bool HandleRightClickOnServer { get; set; }

        public bool HandleTilesLoadedOnClient { get; set; }
        public bool HandleTilesLoadedOnServer { get; set; }

        public bool HandleTiltChangedOnClient { get; set; }
        public bool HandleTiltChangedOnServer { get; set; }

        public bool HandleZoomChangedOnClient { get; set; }
        public bool HandleZoomChangedOnServer { get; set; }

        public string EventsList { get; set; }
    }
}