public GameButton(Buttons buttonCode)
 {
     this.keyCode = Keys.None;
     this.mouseCode = MouseButtons.None;
     this.buttonCode = buttonCode;
     this.inputType = InputType.Button;
 }

 public override void MouseMove(IPosition p, MouseButtons b)
 {
     if (b == MouseButtons.Left)
     {
         RectUpdate(p);
     }
 }

		public override void HandleMouseDown(Point mousePos, MouseButtons mouseButtons)
		{
			int clickedVisibleLine = (mousePos.Y + textArea.VirtualTop.Y) / textArea.TextView.FontHeight;
			int lineNumber = textArea.Document.GetFirstLogicalLine(clickedVisibleLine);
			
			if ((mouseButtons & MouseButtons.Right) == MouseButtons.Right) {
				if (textArea.Caret.Line != lineNumber) {
					textArea.Caret.Line = lineNumber;
				}
			}
			
			IList<Bookmark> marks = textArea.Document.BookmarkManager.Marks;
			List<Bookmark> marksInLine = new List<Bookmark>();
			int oldCount = marks.Count;
			foreach (Bookmark mark in marks) {
				if (mark.LineNumber == lineNumber) {
					marksInLine.Add(mark);
				}
			}
			for (int i = marksInLine.Count - 1; i >= 0; i--) {
				Bookmark mark = marksInLine[i];
				if (mark.Click(textArea, new MouseEventArgs(mouseButtons, 1, mousePos.X, mousePos.Y, 0))) {
					if (oldCount != marks.Count) {
						textArea.UpdateLine(lineNumber);
					}
					return;
				}
			}
			base.HandleMouseDown(mousePos, mouseButtons);
		}

		public LinkLabelLinkClickedEventArgs (LinkLabel.Link link)
		{
#if NET_2_0
			this.button = MouseButtons.Left;
#endif
			this.link = link;
		}

        // TODO:
        //public void SimulateScroll(int x, int y, int screenWidth, int screenHeight, scrollAmount)
        //public void SimulateScroll(scrollAmount)
        // TODO: Simulation which strips the ABSOLUTE factor from the mouse events, making the mouse NOT MOVE, for the click click.
        //public static void SimulateClick(MouseButtons mouseButton, int holdClickTime = 10)
        /// <summary>Simulates a mouse click at the specified location.</summary>
        /// <param name="x">The horizontal pixel coordinate to place the mouse cursor at.</param>
        /// <param name="y">The vertical pixel coordinate to place the mouse cursor at.</param>
        /// <param name="screenWidth">The current screen width (needed to scale the mouse cursor into position).</param>
        /// <param name="screenHeight">The current screen height (needed to scale the mouse cursor into position).</param>
        /// <param name="mouseButton">Which mouse button to simulate a click for.</param>
        /// <param name="holdClickTime">How long to simulate holding the mouse button down, in milliseconds.</param>
        /// <remarks>Basically this is just a pair of simulated mouse "down" and mouse "up" simulations in sequence.</remarks>
        public static void SimulateClick(int x, int y, int screenWidth, int screenHeight, MouseButtons mouseButton, int holdClickTime = 10)
        {
            VirtualMouseAction mouseDownOption, mouseUpOption;
            switch (mouseButton)
            {
                case MouseButtons.Left:
                    mouseDownOption = VirtualMouseAction.LeftButtonDown;
                    mouseUpOption = VirtualMouseAction.LeftButtonUp;
                    break;
                case MouseButtons.Middle:
                    mouseDownOption = VirtualMouseAction.MiddleButtonDown;
                    mouseUpOption = VirtualMouseAction.MiddleButtonUp;
                    break;
                case MouseButtons.Right:
                    mouseDownOption = VirtualMouseAction.RightButtonDown;
                    mouseUpOption = VirtualMouseAction.RightButtonUp;
                    break;
                default:
                    // TODO: Implement and test XButton1 and XButton2 with a fancy mouse.
                    throw new NotSupportedException("The selected mouse button is not yet supported: " + mouseButton.ToString());
            }

            Simulate(x, y, screenWidth, screenHeight, mouseDownOption);
            Thread.Sleep(holdClickTime);
            Simulate(x, y, screenWidth, screenHeight, mouseUpOption);
        }

        public void UpdateButtonState(MouseButtons button, ButtonState state)
        {
            if (button == MouseButtons.None || ButtonStates[button] == state && !_alwaysNotify) return;

            ButtonStates[button] = state;
            _doNotify = true;
        }

		public MouseEventArgs(MouseButtons button, int clicks, int x, int y, int delta) {
			this.buttons=button;
			this.clicks=clicks;
			this.delta=delta;
			this.x=x;
			this.y=y;
		}

        private bool OnMouseUp(MouseButtons mouseButton,int shift,int x,int y)
        {
            if (this.TETool != null)
                this.TETool.OnMouseUp((int)System.Windows.Forms.MouseButtons.Right, shift, x,y);

            return true;
        }

 public ClickPacket(Point point, MouseButtons buttons, PressEvent pressEvent)
     : base(0x14)
 {
     Point = point;
     Buttons = buttons;
     PressEvent = pressEvent;
 }

        public override void HandleMouseDown(Point mousepos, MouseButtons mouseButtons)
        {
            try
            {
                bool showFolding = textArea.Document.TextEditorProperties.EnableFolding;
                int physicalLine = +(int)((mousepos.Y + textArea.VirtualTop.Y) / textArea.TextView.FontHeight);
                int realline = textArea.Document.GetFirstLogicalLine(physicalLine);

                // focus the textarea if the user clicks on the line number view
                textArea.Focus();

                if (!showFolding || realline < 0 || realline + 1 >= textArea.Document.TotalNumberOfLines)
                {
                    return;
                }

                List<FoldMarker> foldMarkers = textArea.Document.FoldingManager.GetFoldingsWithStart(realline);
                foreach (FoldMarker fm in foldMarkers)
                {
                    fm.IsFolded = !fm.IsFolded;
                }
                textArea.Document.FoldingManager.NotifyFoldingsChanged(EventArgs.Empty);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine("in FoldMargin " + ex.Message);
            }
        }

	// Constructor.
	public StatusBarPanelClickEventArgs
				(StatusBarPanel statusBarPanel, MouseButtons button,
				 int clicks, int x, int y)
			: base(button, clicks, x, y, 0)
			{
				this.statusBarPanel = statusBarPanel;
			}

 protected internal override void OnMouseMove(int X, int Y, MouseButtons mb)
 {
     if (Gumps.Capture == this)
     {
         Point point = ((Gump) this.m_Target).PointToScreen(new Point(0, this.m_Target.Height));
         Point point2 = base.PointToScreen(new Point(X, Y));
         int minWidth = ((point2.X - point.X) + 6) - this.m_xOffset;
         if (minWidth < this.m_Target.MinWidth)
         {
             minWidth = this.m_Target.MinWidth;
         }
         else if (minWidth > this.m_Target.MaxWidth)
         {
             minWidth = this.m_Target.MaxWidth;
         }
         bool flag = false;
         int num2 = point.Y - (point2.Y - this.m_yOffset);
         if (num2 < this.m_Target.MinHeight)
         {
             flag = true;
         }
         else if (num2 > this.m_Target.MaxHeight)
         {
             flag = true;
         }
         if (!flag)
         {
             this.m_Target.Height = num2;
             ((Gump) this.m_Target).Y = point2.Y - this.m_yOffset;
         }
         this.m_Target.Width = minWidth;
         Engine.Redraw();
     }
 }

        public DigitalButton Assign(MouseButtons button)
        {
            // Should it replace the assignment?
            this.mappingButtons.Add(button);

            return this;
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="source">The source data list for the drag and drop operation</param>
 /// <param name="start">The selection start</param>
 /// <param name="end">The selection end</param>
 /// <param name="mouseButtons">The mouse button used</param>
 public DataListBeginDragEventArgs(DataList source, int start, int end, MouseButtons mouseButtons)
 {
     this.Source = source;
     this.SelectionStart = start;
     this.SelectionEnd = end;
     this.Button = mouseButtons;
 }

 void mouseLeftButton_MouseFirstPressed(MouseButtons mouseButton, MouseState mouseState, GameTime gameTime)
 {
     if (Rec.Contains(UI.GameEngine.Controller.mousePositionPoint))
     {
         _prevSpeedFactor = Context.Map.SpeedFactor;
     }
 }

        public bool IsButtonDown(MouseButtons button)
        {
            if (button == MouseButtons.None)
                return false;

            return (_states[button] == ButtonState.Pressed);
        }

 /// <summary>Called when a mouse button has been pressed down</summary>
 /// <param name="button">Index of the button that has been pressed</param>
 protected override void OnMousePressed(MouseButtons button) {
   if(this.Enabled) {
     if(button == MouseButtons.Left) {
       this.pressedDownByMouse = true;
     }
   }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="MouseEventExtArgs"/> class. 
 /// </summary>
 /// <param name="buttons">One of the MouseButtons values indicating which mouse button was pressed.</param>
 /// <param name="clicks">The number of times a mouse button was pressed.</param>
 /// <param name="point">The x and y -coordinate of a mouse click, in pixels.</param>
 /// <param name="delta">A signed count of the number of detents the wheel has rotated.</param>
 /// <param name="timestamp">The system tick count when the event occurred.</param>
 /// <param name="isMouseKeyDown">True if event signals mouse button down.</param>
 /// <param name="isMouseKeyUp">True if event signals mouse button up.</param>
 internal MouseEventExtArgs(MouseButtons buttons, int clicks, Point point, int delta, int timestamp,  bool isMouseKeyDown, bool isMouseKeyUp)
     : base(buttons, clicks, point.X, point.Y, delta)
 {
     IsMouseKeyDown = isMouseKeyDown;
     IsMouseKeyUp = isMouseKeyUp;
     Timestamp = timestamp;
 }

 public void ButtonClick(MouseButtons Button)
 {
     //Check if it is a html link
     if(m_oAppDir[0] == (char)0x7F)
     {
         System.Diagnostics.Process.Start(m_oAppDir.Remove(0, 1));
     }
     else
     {
         try
         {
             if(Button == System.Windows.Forms.MouseButtons.Left)
             {
                 //This needs to be in a try catch in case the user cancels the process starting
                 System.Diagnostics.Process.Start(m_oAppDir + m_oAppName);
             }
             else if(Button == System.Windows.Forms.MouseButtons.Right)
             {
                 System.Diagnostics.Process.Start("explorer.exe", "/select, \"" + m_oAppDir + m_oAppName + "\"");
             }
         }
         catch
         {
         }
     }
 }

 protected internal override void OnMouseUp(int x, int y, MouseButtons mb)
 {
     if ((mb & MouseButtons.Right) != MouseButtons.None)
     {
         Gumps.Destroy(this);
     }
 }