Example #1
0
        public static void ProcessMouseEvent(SDL_Event ev)
        {
            switch (ev.type)
            {
            case SDL_EventType.SDL_MOUSEBUTTONDOWN:
                SetMouseButtonState(ev.button.button, true);
                if (OnMouseDown != null)
                {
                    var button = TranslatePlatformMouseButton(ev.button.button);
                    OnMouseDown.Invoke(button);
                }
                break;

            case SDL_EventType.SDL_MOUSEBUTTONUP:
                SetMouseButtonState(ev.button.button, false);
                if (OnMouseUp != null)
                {
                    var button = TranslatePlatformMouseButton(ev.button.button);
                    OnMouseUp.Invoke(button);
                }
                break;

            case SDL_EventType.SDL_MOUSEMOTION:
                OnMouseMove?.Invoke();
                break;
            }
        }
Example #2
0
        private void RaiseOnMouseUp(InputEventArgs e)
        {
            if (OnMouseUp == null)
            {
                return;
            }
            try
            {
                if (Element == null)
                {
                    Element = AutomationHelper.GetFromPoint(e.X, e.Y);
                }
            }
            catch (Exception)
            {
            }

            try
            {
                e.Element = Element;
                if (e.Element != null)
                {
                    e.Element.Refresh();
                }
                // if (e.Element != null && e.Element.ProcessId == currentprocessid) return;
                OnMouseUp?.Invoke(e);
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
            }
        }
Example #3
0
        public Window(WindowConfig config)
        {
            _config = config;

            var opts = WindowOptions.DefaultVulkan;

            opts.WindowBorder = WindowBorder.Resizable;
            opts.Size         = new Silk.NET.Maths.Vector2D <int>((int)config.Width, (int)config.Height);
            opts.Title        = config.Title;
            opts.WindowState  = config.Fullscreen ? WindowState.Fullscreen : WindowState.Normal;

            _window         = Silk.NET.Windowing.Window.Create(opts);
            _window.Render += (time) => DrawFrame?.Invoke(time);

            _window.Initialize();

            _input = _window.CreateInput();
            var primaryKeyboard = _input.Keyboards.FirstOrDefault();

            if (primaryKeyboard != null)
            {
                primaryKeyboard.KeyDown += (keyboard, key, code) => OnKeyDown?.Invoke(key);
                primaryKeyboard.KeyUp   += (keyboard, key, code) => OnKeyUp?.Invoke(key);
            }
            for (int i = 0; i < _input.Mice.Count; i++)
            {
                _input.Mice[i].Cursor.CursorMode = config.CursorDisabled ? CursorMode.Disabled : CursorMode.Normal;
                _input.Mice[i].MouseMove        += (mouse, pos) => OnCursorPosition?.Invoke(pos.X, pos.Y);
                _input.Mice[i].Scroll           += (mouse, wheel) => OnScroll?.Invoke(wheel.X, wheel.Y);
                _input.Mice[i].MouseDown        += (mouse, button) => OnMouseDown?.Invoke(button);
                _input.Mice[i].MouseUp          += (mouse, button) => OnMouseUp?.Invoke(button);
            }
        }
Example #4
0
        private void Poll()
        {
            while (true)
            {
                VREvent_t evt  = new VREvent_t();
                var       size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t));

                if (!OpenVR.Overlay.PollNextOverlayEvent(overlayHandle, ref evt, size))
                {
                    Thread.Sleep(PollingRate);
                    continue;
                }
                ;

                switch ((EVREventType)evt.eventType)
                {
                case EVREventType.VREvent_MouseMove:
                    OnMouseMove?.Invoke(this, evt);
                    break;

                case EVREventType.VREvent_MouseButtonDown:
                    OnMouseDown?.Invoke(this, evt);
                    break;

                case EVREventType.VREvent_MouseButtonUp:
                    OnMouseUp?.Invoke(this, evt);
                    break;
                }
            }
        }
Example #5
0
 public override void resetProperty()
 {
     base.resetProperty();
     // 重置所有成员变量
     mObjectID            = -1;
     mPhysicsAcceleration = Vector3.zero;
     mLastPhysicsSpeed    = Vector3.zero;
     mPhysicsSpeed        = Vector3.zero;
     mLastPhysicsPosition = Vector3.zero;
     mCurFramePosition    = Vector3.zero;
     mLastPosition        = Vector3.zero;
     mMouseDownPosition   = Vector3.zero;
     mLastSpeed           = Vector3.zero;
     mMoveSpeed           = Vector3.zero;
     mObject           = null;
     mTransform        = null;
     mAudioSource      = null;
     mOnMouseEnter     = null;
     mOnMouseLeave     = null;
     mOnMouseDown      = null;
     mOnMouseUp        = null;
     mOnMouseMove      = null;
     mClickCallback    = null;
     mHoverCallback    = null;
     mPressCallback    = null;
     mMovedDuringFrame = false;
     mHasLastPosition  = false;
     mDestroyObject    = true;
     mDestroied        = false;
     mMouseHovered     = false;
     mHandleInput      = true;
     mPassRay          = false;
 }
Example #6
0
 static public void InvokeOnMouseUp(OpenTK.Input.MouseButtonEventArgs e)
 {
     if (OnMouseUp != null)
     {
         OnMouseUp.Invoke(null, e);
     }
 }
Example #7
0
 internal virtual void DoMouseUp(MouseButton button)
 {
     if (MouseEnabled)
     {
         OnMouseUp?.Invoke(button);
     }
 }
Example #8
0
        // Update Method
        public override void Update(GameTime gameTime)
        {
            previousMouse = currentMouse;                                                   // Current and previous state
            currentMouse  = Mouse.GetState();                                               // functions to recieve only one mouse click at a time

            Rectangle mouseRectangle = new Rectangle(currentMouse.X, currentMouse.Y, 1, 1); // Rectangle of the mouse

            isHovering = false;

            if (mouseRectangle.Intersects(Rectangle))
            {
                isHovering = true;

                if (currentMouse.LeftButton == ButtonState.Pressed) // Conditions for the mouse being down
                {
                    OnMouseDown?.Invoke(this, new EventArgs());
                }
                if (currentMouse.LeftButton == ButtonState.Released && previousMouse.LeftButton == ButtonState.Pressed) // Conditions for the mouse being clicked
                {
                    Click?.Invoke(this, new EventArgs());
                }
            }
            if (currentMouse.LeftButton == ButtonState.Released) // Conditions for the mouse being released
            {
                OnMouseUp?.Invoke(this, new EventArgs());
            }
        }
Example #9
0
 public void MouseUp(int screenX, int screenY, MouseButton button)
 {
     mouseX        = screenX;
     mouseY        = screenY;
     mouseButtons &= ~button;
     OnMouseUp?.Invoke(this, CreateMouseEventArgs(screenX, screenY, button));
 }
Example #10
0
        IntPtr HookProcFunction(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode == 0)
            {
                MSLLHOOKSTRUCT mhs      = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
                var            inwindow = Owner.MouseInWindow(mhs.pt.X, mhs.pt.Y);
                switch ((WM)wParam.ToInt32())
                {
                case WM.MOUSEMOVE:
                    if (inwindow)
                    {
                        OnMouseMove?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, Owner.GetMouseButtonConsole());
                    }
                    OnGlobalMouseMove?.Invoke(mhs.pt.X, mhs.pt.Y, Owner.GetMouseButtonScreen());
                    break;

                case WM.LBUTTONDOWN:
                    OnMouseDown?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.Left);
                    break;

                case WM.MBUTTONDOWN:
                    OnMouseDown?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.Center);
                    break;

                case WM.RBUTTONDOWN:
                    OnMouseDown?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.Right);
                    break;

                case WM.XBUTTONDOWN:
                    OnMouseDown?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.XBUTTON1 | MButton.XBUTTON2);
                    break;

                case WM.LBUTTONUP:
                    OnMouseUp?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.Left);
                    break;

                case WM.MBUTTONUP:
                    OnMouseUp?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.Center);
                    break;

                case WM.RBUTTONUP:
                    OnMouseUp?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.Right);
                    break;

                case WM.XBUTTONUP:
                    OnMouseUp?.Invoke(Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).X, Owner.ToConsoleCoord(mhs.pt.X, mhs.pt.Y).Y, mhs.pt.X, mhs.pt.Y, inwindow, MButton.XBUTTON1 | MButton.XBUTTON2);
                    break;

                case WM.MOUSEWHEEL:
                    OnMouseWheel?.Invoke(GetWheelStateByData(mhs.mouseData), mhs.mouseData, mhs.pt.X, mhs.pt.Y, Owner.GetMouseButtonScreen());
                    break;

                default:

                    break;
                }
            }

            return(WinApi.CallNextHookEx(hHook, nCode, wParam, lParam));
        }
Example #11
0
 private IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam)
 {
     if ((int)wParam == WM_MOUSEMOVE)
     {
         var e  = new InputEventArgs();
         var pt = new POINT();
         GetPhysicalCursorPos(ref pt);
         e.X = pt.x;
         e.Y = pt.y;
         Task.Run(() => OnMouseMove?.Invoke(e));
     }
     else if ((int)wParam == WM_LBUTTONDOWN || (int)wParam == WM_RBUTTONDOWN)
     {
         var e  = new InputEventArgs();
         var pt = new POINT();
         GetPhysicalCursorPos(ref pt);
         e.X = pt.x;
         e.Y = pt.y;
         Task.Run(() => OnMouseDown?.Invoke(e));
     }
     else if ((int)wParam == WM_LBUTTONUP || (int)wParam == WM_RBUTTONUP)
     {
         var e  = new InputEventArgs();
         var pt = new POINT();
         GetPhysicalCursorPos(ref pt);
         e.X = pt.x;
         e.Y = pt.y;
         Task.Run(() => OnMouseUp?.Invoke(e));
     }
     return(CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam));
 }
Example #12
0
        private void Update()
        {
            if (Input.GetMouseButtonDown(0) && Input.mousePosition.x > 150)
            {
                for (int i = lines.Count - 1; i >= 0; i--)
                {
                    Destroy(lines[i].gameObject);
                    lines.RemoveAt(i);
                }

                GameObject lineGO = Instantiate(linePrefab);
                activeLine = lineGO.GetComponent <Line>();
                lines.Add(activeLine);
            }

            if (Input.GetMouseButtonUp(0) && activeLine != null)
            {
                OnMouseUp?.Invoke(activeLine);
                activeLine = null;
            }

            if (activeLine != null)
            {
                if (Input.mousePosition.x > 150)
                {
                    Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);

                    activeLine.UpdateLine(mousePos);
                }
            }
        }
 private void MouseUp()
 {
     firstMouseClick = true;
     OnMouseUp?.Invoke();
     endPress = Input.mousePosition;
     AudioSource.PlayClipAtPoint(jumpSnd, transform.position);
     AddForce();
 }
Example #14
0
        protected async Task OnMouseUpAsync(MouseEventArgs args)
        {
            await ChangeValue();

            if (OnMouseUp.HasDelegate)
            {
                await OnMouseUp.InvokeAsync(args);
            }
        }
Example #15
0
 public override void MouseUp(UIMouseEvent evt)
 {
     if (_isDragging)
     {
         _isDragging = false;
         OnValueChange?.Invoke(Value, this);
     }
     OnMouseUp?.Invoke(evt, this);
 }
Example #16
0
 public virtual void MouseLeftUp(UIMouseEvent e)
 {
     // Main.NewText("抬起");
     MouseDownedLeft = false;
     OnMouseUp?.Invoke(e, this);
     if (PropagationRule.HasFlag(PropagationFlags.MouseLeftUp))
     {
         Parent?.MouseLeftUp(e);
     }
 }
Example #17
0
 private void OnMouse(object sender, ButtonValueChangedArgs bvca)
 {
     if (bvca.Pressed)
     {
         OnMouseDown?.Invoke(this);
     }
     else
     {
         OnMouseUp?.Invoke(this);
     }
 }
Example #18
0
 public AnnotationHelper(
     OnAnnotationChanged onAnnotationChangedCallback = null,
     OnPageChanged onPageChangedCallback             = null,
     OnMouseDown onMouseDownCallback = null,
     OnMouseUp onMouseUpCallback     = null)
 {
     OnAnnotationChangedCallback = onAnnotationChangedCallback ?? (async(W3CWebAnnotationModel[] annotations) => { });
     OnPageChangedCallback       = onPageChangedCallback ?? (async(int newPage) => { });
     OnMouseDownCallback         = onMouseDownCallback ?? (async(double viewportX, double viewportY) => { });
     OnMouseUpCallback           = onMouseUpCallback ?? (async(double viewportX, double viewportY) => { });
 }
Example #19
0
 void MarkMouseButtonAsPressed(MSLLHOOKSTRUCT hookStruct, MouseEventArgs.Buttons button, bool pressed)
 {
     if (pressed && !_currentlyPressed.Contains((int)button))
     {
         _currentlyPressed.Add((int)button);
         OnMouseDown?.Invoke(this, new MouseEventArgs(button, hookStruct.pt.x, hookStruct.pt.y));
     }
     else if (!pressed && _currentlyPressed.Contains((int)button))
     {
         _currentlyPressed.Remove((int)button);
         OnMouseUp?.Invoke(this, new MouseEventArgs(button, hookStruct.pt.x, hookStruct.pt.y));
     }
 }
Example #20
0
        private static void InputEventHandler(InputEventArgs e)
        {
            switch (e.Type)
            {
            case InputEventType.KeyUp: OnKeyUp.Invoke(e); break;

            case InputEventType.KeyDown: OnKeyDown.Invoke(e); break;

            case InputEventType.MouseUp: OnMouseUp.Invoke(e); break;

            case InputEventType.MouseDown: OnMouseDown.Invoke(e); break;

            case InputEventType.MouseMove: OnMouseMove.Invoke(e); break;
            }
        }
Example #21
0
        public void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                OnMouseDwn?.Invoke();
                isPressed = true;
            }
            if (Input.GetMouseButtonUp(0))
            {
                OnMouseUp?.Invoke();
                isPressed = false;
            }

            if (isPressed)
            {
                OnMouseDrg?.Invoke();
            }
        }
        internal override void GHook_MouseUp(object sender, MouseEventArgs e)
        {
            if (!Loaded)
            {
                return;
            }

            var mx = e.X - Window.X;
            var my = e.Y - Window.Y;

            //if (ScaleMode == DrawingAreaScaleMode.ScaleAll)
            //{
            //    mx = (int)(mx / Scale.X);
            //    my = (int)(my / Scale.Y);
            //}
            DxWindow.OnMouseUp(DxWindow, DxWindow, e, new SharpDX.Point(mx, my));

            OnMouseUp?.Invoke(sender, e);
        }
Example #23
0
        protected async Task OnMouseUpAsync(MouseEventArgs args)
        {
            if (!EqualityComparer <TValue> .Default.Equals(CurrentValue, _inputValue))
            {
                if (!_compositionInputting)
                {
                    CurrentValue = _inputValue;
                    if (OnChange.HasDelegate)
                    {
                        await OnChange.InvokeAsync(Value);
                    }
                }
            }

            if (OnMouseUp.HasDelegate)
            {
                await OnMouseUp.InvokeAsync(args);
            }
        }
Example #24
0
        private bool HasMouseButtonInput(int button)
        {
            if (Input.GetMouseButtonDown(button))
            {
                OnMouseDown?.Invoke(button, Input.mousePosition);
                return(true);
            }
            else if (Input.GetMouseButton(button))
            {
                OnMouseDrag?.Invoke(button, Input.mousePosition, Input.GetAxis(MouseXAxis), Input.GetAxis(MouseYAxis));
                return(true);
            }
            else if (Input.GetMouseButtonUp(button))
            {
                OnMouseUp?.Invoke(button, Input.mousePosition);
                return(true);
            }

            return(false);
        }
Example #25
0
    private void MouseUp(int buttonId, Vector3 mousePosition)
    {
        if (!canInputBeMade)
        {
            return;
        }

        if (!BuilderInWorldUtils.IsPointerOverUIElement() && !BuilderInWorldUtils.IsPointerOverMaskElement(layerToStopClick))
        {
            OnMouseUp?.Invoke(buttonId, mousePosition);
            if (Vector3.Distance(mousePosition, lastMousePosition) >= movementClickThreshold)
            {
                return;
            }
            if (Time.unscaledTime >= lastTimeMouseDown + msClickThreshold / 1000)
            {
                return;
            }
            OnMouseClick?.Invoke(buttonId, mousePosition);
        }
    }
Example #26
0
 public virtual void MouseUp(MouseButton button, Vec2 position)
 {
     foreach (var child in children)
     {
         if (child.Inside(position) || mouseFocus == child)
         {
             child.MouseUp(button, position);
         }
     }
     mouseFocus = null;
     if (Pressed)
     {
         Release();
         if (Inside(position))
         {
             Click();
         }
     }
     Pressed = false;
     OnMouseUp?.Invoke(button, position);
 }
Example #27
0
 private IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam)
 {
     try
     {
         if ((int)wParam == WM_MOUSEMOVE)
         {
             var e  = new InputEventArgs();
             var pt = new POINT();
             GetPhysicalCursorPos(ref pt);
             e.X = pt.x;
             e.Y = pt.y;
             Task.Run(() => OnMouseMove?.Invoke(e));
         }
         else if ((int)wParam == WM_LBUTTONDOWN || (int)wParam == WM_RBUTTONDOWN)
         {
             var e  = new InputEventArgs();
             var pt = new POINT();
             GetPhysicalCursorPos(ref pt);
             e.X = pt.x;
             e.Y = pt.y;
             Task.Run(() => OnMouseDown?.Invoke(e));
         }
         else if ((int)wParam == WM_LBUTTONUP || (int)wParam == WM_RBUTTONUP)
         {
             var e  = new InputEventArgs();
             var pt = new POINT();
             GetPhysicalCursorPos(ref pt);
             e.X = pt.x;
             e.Y = pt.y;
             Task.Run(() => OnMouseUp?.Invoke(e));
         }
         return(CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam));
     }
     catch (Exception ex)
     {
         System.Diagnostics.Trace.WriteLine("LowLevelMouseProc: " + ex.Message);
         return(IntPtr.Zero);
     }
 }
Example #28
0
    // Update is called once per frame
    void Update()
    {
        //We transform the touch position into word space from screen space and store it.
        Vector3   touchPosWorld   = MainCamera.ScreenToWorldPoint(Input.mousePosition);
        Vector2   touchPosWorld2D = new Vector2(touchPosWorld.x, touchPosWorld.y);
        Transform hitTransform    = null;
        //We now raycast with this information. If we have hit something we can process it.
        RaycastHit2D hitInformation = Physics2D.Raycast(touchPosWorld2D, MainCamera.transform.forward);

        if (Physics.Raycast(touchPosWorld, Vector3.forward, out var hitInformation3D))
        {
            hitTransform = hitInformation3D.transform;
        }
        else if (hitInformation.transform)
        {
            hitTransform = hitInformation.transform;
        }

        if (Input.GetMouseButtonDown(0))
        {
            OnMouseDown?.Invoke(touchPosWorld2D, hitTransform);
        }

        if (Input.GetMouseButton(0))
        {
            OnMouseMove?.Invoke(touchPosWorld2D, hitTransform);
        }

        if (Input.GetMouseButtonUp(0))
        {
            OnMouseUp?.Invoke(touchPosWorld2D, hitTransform);
        }

        if (Input.GetKeyDown(KeyCode.Space))
        {
            LevelManager.LoadLevel(0);
        }
    }
    private void MouseUp(int buttonId, Vector3 mousePosition)
    {
        if (!isEditModeActive)
        {
            return;
        }

        if (currentClickIsOnUi)
        {
            OnMouseClickOnUI?.Invoke(buttonId, mousePosition);
            currentClickIsOnUi = false;
            return;
        }

        if (!canInputBeMade)
        {
            return;
        }

        if (!BIWUtils.IsPointerOverUIElement())
        {
            OnMouseUp?.Invoke(buttonId, mousePosition);
            if (Vector3.Distance(mousePosition, lastMousePosition) >= MOVEMENT_CLICK_THRESHOLD)
            {
                return;
            }
            if (Time.unscaledTime >= lastTimeMouseDown + MS_CLICK_THRESHOLD / 1000)
            {
                return;
            }
            OnMouseClick?.Invoke(buttonId, mousePosition);
        }
        else
        {
            OnMouseUpOnUI?.Invoke(buttonId, mousePosition);
        }
    }
        internal void DispatchEvent(Map map, HtmlMarkerJsEventArgs eventArgs)
        {
            if (eventArgs.Options != null)
            {
                var popupOptions = Options.Popup;
                Options       = eventArgs.Options;
                Options.Popup = popupOptions;
            }

            switch (eventArgs.Type)
            {
            case "click":
                OnClick?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "contextmenu":
                OnContextMenu?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "dblclick":
                OnDblClick?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "drag":
                OnDrag?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "dragend":
                OnDragEnd?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "dragstart":
                OnDragStart?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "keydown":
                OnKeyDown?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "keypress":
                OnKeyPress?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "keyup":
                OnKeyUp?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mousedown":
                OnMouseDown?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseenter":
                OnMouseEnter?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseleave":
                OnMouseLeave?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mousemove":
                OnMouseMove?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseout":
                OnMouseOut?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseover":
                OnMouseOver?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseup":
                OnMouseUp?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;
            }
        }