I'm making a 2D game engine called Clixel over on GitHub. The problem I have relates to two classes, ClxMouse and ClxButton. In it I have a mouse class - the code for that can be viewed here.

ClxMouse

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace org.clixel
{
    public class ClxMouse : ClxSprite
    {
        private MouseState _curmouse, _lastmouse;
        public int Sensitivity = 3;
        public bool Lock = true;

        public Vector2 Change
        {
            get
            {
                return new Vector2(_curmouse.X - _lastmouse.X, _curmouse.Y - _lastmouse.Y);
            }
        }

        private int _scrollwheel;

        public int ScrollWheel
        {
            get
            {
                return _scrollwheel;
            }
        }

        public bool LeftDown
        {
            get
            {
                if (_curmouse.LeftButton == ButtonState.Pressed)
                    return true;
                else
                    return false;
            }
        }

        public bool RightDown
        {
            get
            {
                if (_curmouse.RightButton == ButtonState.Pressed)
                    return true;
                else
                    return false;
            }
        }

        public bool MiddleDown
        {
            get
            {
                if (_curmouse.MiddleButton == ButtonState.Pressed)
                    return true;
                else
                    return false;
            }
        }

        public bool LeftPressed
        {
            get
            {
                if (_curmouse.LeftButton == ButtonState.Pressed && _lastmouse.LeftButton == ButtonState.Released)
                    return true;
                else
                    return false;
            }
        }

        public bool RightPressed
        {
            get
            {
                if (_curmouse.RightButton == ButtonState.Pressed && _lastmouse.RightButton == ButtonState.Released)
                    return true;
                else
                    return false;
            }
        }

        public bool MiddlePressed
        {
            get
            {
                if (_curmouse.MiddleButton == ButtonState.Pressed && _lastmouse.MiddleButton == ButtonState.Released)
                    return true;
                else
                    return false;
            }
        }

        public bool LeftReleased
        {
            get
            {
                if (_curmouse.LeftButton == ButtonState.Released && _lastmouse.LeftButton == ButtonState.Pressed)
                    return true;
                else
                    return false;
            }
        }

        public bool RightReleased
        {
            get
            {
                if (_curmouse.RightButton == ButtonState.Released && _lastmouse.RightButton == ButtonState.Pressed)
                    return true;
                else
                    return false;
            }
        }

        public bool MiddleReleased
        {
            get
            {
                if (_curmouse.MiddleButton == ButtonState.Released && _lastmouse.MiddleButton == ButtonState.Pressed)
                    return true;
                else
                    return false;
            }
        }

        public MouseState CurMouse
        {
            get
            {
                return _curmouse;
            }
        }

        public MouseState LastMouse
        {
            get
            {
                return _lastmouse;
            }
        }

        public ClxMouse()
            : base(ClxG.Textures.Default.Cursor)
        {
            _curmouse = Mouse.GetState();
            _lastmouse = _curmouse;
            CollisionBox = new Rectangle(ClxG.Screen.Center.X, ClxG.Screen.Center.Y, Texture.Width, Texture.Height);
            this.Solid = false;
            DefaultPosition = new Vector2(CollisionBox.X, CollisionBox.Y);
            Mouse.SetPosition(CollisionBox.X, CollisionBox.Y);
        }

        public ClxMouse(Texture2D _texture)
            : base(_texture)
        {
            _curmouse = Mouse.GetState();
            _lastmouse = _curmouse;
            CollisionBox = new Rectangle(ClxG.Screen.Center.X, ClxG.Screen.Center.Y, Texture.Width, Texture.Height);
            DefaultPosition = new Vector2(CollisionBox.X, CollisionBox.Y);
        }

        public override void Update()
        {
            _lastmouse = _curmouse;
            _curmouse = Mouse.GetState();
            if (_curmouse != _lastmouse)
            {
                if (ClxG.Game.IsActive)
                {
                    _scrollwheel = _curmouse.ScrollWheelValue;
                    Velocity = new Vector2(Change.X / Sensitivity, Change.Y / Sensitivity);
                    if (Lock)
                        Mouse.SetPosition(ClxG.Screen.Center.X, ClxG.Screen.Center.Y);
                    _curmouse = Mouse.GetState();
                }

                base.Update();
            }
        }

        public override void Draw(SpriteBatch _sb)
        {
            base.Draw(_sb);
        }
    }
}

ClxButton

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace org.clixel
{
    public class ClxButton : ClxSprite
    {
        /// <summary>
        /// The color when the mouse is over the button
        /// </summary>
        public Color HoverColor;

        /// <summary>
        /// The color when the color is being clicked
        /// </summary>
        public Color ClickColor;

        /// <summary>
        /// The color when the button is inactive
        /// </summary>
        public Color InactiveColor;

        /// <summary>
        /// The color when the button is active
        /// </summary>
        public Color ActiveColor;

        /// <summary>
        /// The color after the button has been clicked.
        /// </summary>
        public Color ClickedColor;

        /// <summary>
        /// The text to be displayed on the button, set to "" if no text is needed.
        /// </summary>
        public string Text;

        /// <summary>
        /// The ClxText object to be displayed.
        /// </summary>
        public ClxText TextRender;

        /// <summary>
        /// The ClxState that should be ResetAndShow() when the button is clicked.
        /// </summary>
        public ClxState ClickState;

        /// <summary>
        /// Collision check to make sure onCollide() only runs once per frame,
        /// since only the mouse needs to be collision checked.
        /// </summary>
        private bool _runonce = false;

        /// <summary>
        /// Gets a value indicating whether this instance is colliding.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is colliding; otherwise, <c>false</c>.
        /// </value>
        public bool IsColliding
        {
            get
            {
                return _runonce;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ClxButton"/> class.
        /// </summary>
        public ClxButton()
            : base(ClxG.Textures.Default.Button)
        {
            HoverColor = Color.Red;
            ClickColor = Color.Blue;
            InactiveColor = Color.Gray;
            ActiveColor = Color.White;
            ClickedColor = Color.Yellow;

            Text = Name + ID + " Unset!";
            TextRender = new ClxText();
            TextRender.Text = Text;
            TextRender.TextPadding = new Vector2(5, 5);

            ClickState = null;
            CollideObjects(ClxG.Mouse);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ClxButton"/> class.
        /// </summary>
        /// <param name="_texture">The button texture.</param>
        public ClxButton(Texture2D _texture)
            : base(_texture)
        {
            HoverColor = Color.Red;
            ClickColor = Color.Blue;
            InactiveColor = Color.Gray;
            ActiveColor = Color.White;
            ClickedColor = Color.Yellow;
            Texture = _texture;

            Text = Name + ID;
            TextRender = new ClxText();
            TextRender.Name = this.Name + ".TextRender";
            TextRender.Text = Text;
            TextRender.TextPadding = new Vector2(5, 5);
            TextRender.Reset();

            ClickState = null;

            CollideObjects(ClxG.Mouse);
        }

        /// <summary>
        /// Draws the debug information, run from ClxG.DrawDebug unless manual control is assumed.
        /// </summary>
        /// <param name="_sb">SpriteBatch used for drawing.</param>
        public override void DrawDebug(SpriteBatch _sb)
        {
            _runonce = false;
            TextRender.DrawDebug(_sb);
            _sb.Draw(Texture, ActualRectangle, new Rectangle(0, 0, Texture.Width, Texture.Height), DebugColor, Rotation, Origin, Flip, Layer);
            _sb.Draw(ClxG.Textures.Default.DebugBG, new Rectangle(ActualRectangle.X - DebugLineWidth, ActualRectangle.Y - DebugLineWidth, ActualRectangle.Width + DebugLineWidth * 2, ActualRectangle.Height + DebugLineWidth * 2), new Rectangle(0, 0, ClxG.Textures.Default.DebugBG.Width, ClxG.Textures.Default.DebugBG.Height), DebugOutline, Rotation, Origin, Flip, Layer - 0.1f);
            _sb.Draw(ClxG.Textures.Default.DebugBG, ActualRectangle, new Rectangle(0, 0, ClxG.Textures.Default.DebugBG.Width, ClxG.Textures.Default.DebugBG.Height), DebugBGColor, Rotation, Origin, Flip, Layer - 0.01f);
        }

        /// <summary>
        /// Draws using the SpriteBatch, run from ClxG.Draw unless manual control is assumed.
        /// </summary>
        /// <param name="_sb">SpriteBatch used for drawing.</param>
        public override void Draw(SpriteBatch _sb)
        {
            _runonce = false;
            TextRender.Draw(_sb);
            if (Visible)
                if (Debug)
                {
                    DrawDebug(_sb);
                }
                else
                    _sb.Draw(Texture, ActualRectangle, new Rectangle(0, 0, Texture.Width, Texture.Height), Color, Rotation, Origin, Flip, Layer);
        }

        /// <summary>
        /// Updates this instance.
        /// </summary>
        public override void Update()
        {
            if (this.Color != ActiveColor)
                this.Color = ActiveColor;

            TextRender.Layer = this.Layer + 0.03f;
            TextRender.Text = Text;
            TextRender.Scale = .5f;
            TextRender.Name = this.Name + ".TextRender";
            TextRender.Origin = new Vector2(TextRender.CollisionBox.Center.X, TextRender.CollisionBox.Center.Y);
            TextRender.Center(this);

            TextRender.Update();

            this.CollisionBox.Width = (int)(TextRender.CollisionBox.Width * TextRender.Scale) + (int)(TextRender.TextPadding.X * 2);
            this.CollisionBox.Height = (int)(TextRender.CollisionBox.Height * TextRender.Scale) + (int)(TextRender.TextPadding.Y * 2);
            base.Update();
        }

        /// <summary>
        /// Collide event, takes the colliding object to call it's proper collision code.
        /// You'd want to use something like if(typeof(collider) == typeof(ClxObject)
        /// </summary>
        /// <param name="collider">The colliding object.</param>
        public override void onCollide(ClxObject collider)
        {
            if (!_runonce)
            {
                _runonce = true;
                UpdateEvents();
                base.onCollide(collider);
            }
        }

        /// <summary>
        /// Updates the mouse based events.
        /// </summary>
        public void UpdateEvents()
        {
            onHover();

            if (ClxG.Mouse.LeftReleased)
            {
                onLeftReleased();
                return;
            }

            if (ClxG.Mouse.RightReleased)
            {
                onRightReleased();
                return;
            }

            if (ClxG.Mouse.MiddleReleased)
            {
                onMiddleReleased();
                return;
            }

            if (ClxG.Mouse.LeftPressed)
            {
                onLeftClicked();
                return;
            }

            if (ClxG.Mouse.RightPressed)
            {
                onRightClicked();
                return;
            }

            if (ClxG.Mouse.MiddlePressed)
            {
                onMiddleClicked();
                return;
            }

            if (ClxG.Mouse.LeftDown)
            {
                onLeftClick();
                return;
            }

            if (ClxG.Mouse.RightDown)
            {
                onRightClick();
                return;
            }

            if (ClxG.Mouse.MiddleDown)
            {
                onMiddleClick();
                return;
            }
        }

        /// <summary>
        /// Shows the state of the click.
        /// </summary>
        public void ShowClickState()
        {
            if (ClickState != null)
            {
                ClickState.ResetAndShow();
            }
        }

        /// <summary>
        /// Hover event
        /// </summary>
        virtual public void onHover()
        {
            this.Color = HoverColor;
        }

        /// <summary>
        /// Left click event
        /// </summary>
        virtual public void onLeftClick()
        {
            this.Color = ClickColor;
        }

        /// <summary>
        /// Right click event
        /// </summary>
        virtual public void onRightClick()
        {
        }

        /// <summary>
        /// Middle click event
        /// </summary>
        virtual public void onMiddleClick()
        {
        }

        /// <summary>
        /// Left click event, called once per click
        /// </summary>
        virtual public void onLeftClicked()
        {
            ShowClickState();
        }

        /// <summary>
        /// Right click event, called once per click
        /// </summary>
        virtual public void onRightClicked()
        {
            this.Reset();
        }

        /// <summary>
        /// Middle click event, called once per click
        /// </summary>
        virtual public void onMiddleClicked()
        {
        }

        /// <summary>
        /// Ons the left released.
        /// </summary>
        virtual public void onLeftReleased()
        {
            this.Color = ClickedColor;
        }

        virtual public void onRightReleased()
        {
        }

        virtual public void onMiddleReleased()
        {
        }
    }
}

The issue I have is that I have all these have event styled methods, especially in ClxButton with all the onLeftClick, onRightClick, etc, etc.

Is there a better way for me to handle these events to be a lot more easier for a programmer to use? I was looking at normal events on some other sites, (I'd post them but I need more rep.) and didn't really see a good way to implement delegate events into my framework. I'm not really sure how these events work, could someone possibly lay out how these events are processed for me?

TL:DR * Is there a better way to handle events like this? * Are events a viable solution to this problem?

Thanks in advance for any help.