/// <summary> /// Constructor /// </summary> public BuzzInputReport() { // Create the button states Buttons = new ButtonStates[NumHandsets]; for (var i = 0; i < NumHandsets; i++) Buttons[i] = new ButtonStates(); }
/// <summary> /// Creates a new instance of SquareButton /// </summary> public SquareButton() { _colorUpDark = SystemColors.ControlDark; _colorUpLit = SystemColors.Control; _colorDownDark = SystemColors.ControlDark; _colorDownLit = SystemColors.ControlDark; _state = ButtonStates.None; }
void Start() { buttons = new List<GameObject>(); panelImageScript = panel.GetComponent<Image>(); biographyImageScript = GameObject.Find("Biography").GetComponent<Image>(); triggerSquareBoundary = 5; changeInventoryIcons = false; inventoryDisplayStates = InventoryDisplayStates.NoInventory; buttonStates = ButtonStates.Create; torsoItems = new string[] { "Blouse", "Jacket", "Shirt", "Tank" }; legsItems = new string[] { "Miniskirt", "Shorts", "Pants", "Dress" }; }
/// <summary> /// At the end of every frame, we change our button's state if needed /// </summary> protected virtual void LateUpdate() { if (CurrentState == ButtonStates.ButtonUp) { _lastStateChangeAt = Time.time; _fromColor = PressedColor; _toColor = _initialColor; CurrentState = ButtonStates.Off; } if (CurrentState == ButtonStates.ButtonDown) { _lastStateChangeAt = Time.time; _fromColor = _initialColor; _toColor = PressedColor; CurrentState = ButtonStates.ButtonPressed; } }
protected override void OnMouseDown(MouseEventArgs e) { MouseArgs = e; if (e.Button == MouseButtons.Left) { _ButtonState = ButtonStates.Pressed; RedrawButton(); if (!ClickOnMouseUp && Enabled) { base.OnClick(e); base.OnMouseClick(e); } } }
ButtonStates ReadStates() { ButtonStates bs = ButtonStates.None; byte[] buttonData = buttonMem.Read(); int bitMask = 1; foreach (byte butState in buttonData) { if (butState != 0) { bs |= (ButtonStates)bitMask; } bitMask = bitMask << 1; } return(bs); }
/// <summary> /// Triggers the bound pointer down action /// </summary> public virtual void OnPointerDown(PointerEventData data) { if (CurrentState != ButtonStates.Off) { return; } CurrentState = ButtonStates.ButtonDown; if (_canvasGroup != null) { _canvasGroup.alpha = PressedOpacity; } if (AxisPressedFirstTime != null) { AxisPressedFirstTime.Invoke(); } }
/// <summary> /// Triggers the bound pointer up action /// </summary> public virtual void OnPointerUp(PointerEventData data) { if (CurrentState != ButtonStates.ButtonPressed && CurrentState != ButtonStates.ButtonDown) { return; } CurrentState = ButtonStates.ButtonUp; if ((Time.timeScale != 0) && (ReleasedDelay > 0)) { Invoke("InvokeReleased", ReleasedDelay); } else { ButtonReleased.Invoke(); } }
public KeyboardKeyInput FromTwoStates(int count) { var state1 = new ButtonStates <Key>(); var state2 = new ButtonStates <Key>(); for (int i = 0; i < count; i++) { state1.SetPressed((Key)i, true); } for (int i = count; i < 2 * count; i++) { state2.SetPressed((Key)i, true); } return(new KeyboardKeyInput(state1, state2)); }
public int EnumerateBothDifferences(int count) { var state1 = new ButtonStates <Key>(); var state2 = new ButtonStates <Key>(); for (int i = 0; i < count; i++) { state1.SetPressed((Key)i, true); } for (int i = count; i < 2 * count; i++) { state2.SetPressed((Key)i, true); } return(state1.EnumerateDifference(state2).Pressed.Length); }
// Method for when mouse is moved (check if it is over) private void OnMouseMoved(Point mousePosition) { if (InputHelper.MouseIsOver(area)) { if (state != ButtonStates.Hover) { state = ButtonStates.Hover; area.Y += 10; area.Height -= 10; // #DIRTY AssignDrawPositions(); } } else if (!(state == ButtonStates.None)) { state = ButtonStates.None; area.Y -= 10; area.Height += 10; // #DIRTY AssignDrawPositions(); } }
public void Toggle() { switch (ButtonState) { case ButtonStates.Off: ButtonState = ButtonType == ButtonTypes.TwoState ? ButtonStates.On : ButtonStates.Dim; break; case ButtonStates.On: ButtonState = ButtonStates.Off; break; case ButtonStates.Dim: ButtonState = ButtonStates.On; break; } UpdateButton(); }
private void Update() { if (_btn.buttonState != btnStates) { btnStates = _btn.buttonState; OnStateChanged.TryInvoke(btnStates); } if (_btn.interactable && !interact) { interact = true; OnInteractChange(); } else if (!_btn.interactable && interact) { interact = false; OnInteractChange(); } }
/// <summary> /// Triggers the bound pointer up action /// </summary> public virtual void OnPointerUp(PointerEventData data) { if (CurrentState != ButtonStates.ButtonPressed && CurrentState != ButtonStates.ButtonDown) { return; } CurrentState = ButtonStates.ButtonUp; if (_canvasGroup != null) { _canvasGroup.alpha = _initialOpacity; } if (AxisReleased != null) { AxisReleased.Invoke(); } AxisPressed.Invoke(0); }
public void DeHighlight() { if (_state == ButtonStates.Enabled || _state == ButtonStates.HighlightEnabled) { _state = ButtonStates.Enabled; _animator.SetNewAnimation((int)ButtonStates.Enabled); } else if (_state == ButtonStates.Disabled || _state == ButtonStates.HighlightDisabled) { _state = ButtonStates.Disabled; _animator.SetNewAnimation((int)ButtonStates.Disabled); } else if (_state == ButtonStates.Selected || _state == ButtonStates.HighlightSelected) { _state = ButtonStates.Selected; _animator.SetNewAnimation((int)ButtonStates.Selected); } }
public void SelectNoEvent() { if (_state != ButtonStates.Selected && _state != ButtonStates.Enabled) { return; } if (_state == ButtonStates.Selected) { _animator.SetNewAnimation((int)ButtonStates.Deselect); _state = ButtonStates.Deselect; } else { _animator.SetNewAnimation((int)ButtonStates.Select); _state = ButtonStates.Select; } }
void _formChrome_NonClientMouseDown(object sender, NonClientMouseEventArgs e) { var state = new ButtonStates(this); if (state.OverButton != ChromeButton.None || state.OverExtraButton != null) { _formChrome.BeginUpdate(); SetOverButton(ChromeButton.None); SetOverButton(null); SetDownButton(state.OverButton); SetDownButton(state.OverExtraButton); CaptureStart = e.Location; Form.Capture = true; _formChrome.EndUpdate(); } }
void Update() { transform.position = _controller.Position; transform.rotation = _controller.Orientation; if (BtnState == ButtonStates.JustReleased) { BtnState = ButtonStates.Normal; } if (_controller.TriggerValue == 0.0f) // When the trigger ISN'T pressed... { foreach (Transform child in transform) // Grab all children of the object this script is attached to (the controller, usually) { child.transform.parent = null; // Make all childs have no parent. _drag = false; } } }
internal void ChangeTakeO2State(ButtonStates state) { QuickLogger.Debug($"Changing Button State for {nameof(ChangeTakeO2State)}"); switch (state) { case ButtonStates.Enabled: _buttonLbl.text = OxStationBuildable.TakeOxygen(); _giveOIntBtn.OnEnable(); break; case ButtonStates.Disabled: _buttonLbl.text = OxStationBuildable.Damaged(); _giveOIntBtn.OnDisable(); break; default: throw new ArgumentOutOfRangeException(nameof(state), state, null); } }
protected void OnTitlebarButtonReleaseEvent(object o, ButtonReleaseEventArgs args) { _titleBarMouseDown = args.Event.Button == 1 && args.Event.Type == EventType.ButtonPress; ButtonStates tempCloseState = _closeState; ButtonStates tempMinimizeState = _minimizeState; this.RedrawControls(GetState(args.Event.X, args.Event.Y, _closeStart, _titleBarMouseDown, _closeState), GetState(args.Event.X, args.Event.Y, _minimizeStart, _titleBarMouseDown, _minimizeState), false); if (tempCloseState == ButtonStates.DownInside && !_titleBarMouseDown) { this.CloseApp(); } else if (tempMinimizeState == ButtonStates.DownInside && !_titleBarMouseDown) { this.MinimizeApp(); } }
public void ButtonPush(Button b) { switch (b.Action) { case ButtonAction.Quit: this.ButtonState = ButtonStates.Quit; break; case ButtonAction.Other: this.ButtonState = ButtonStates.Pressed; this.pressedButtonName = b.text; break; case ButtonAction.Close: this.ButtonState = ButtonStates.Close; break; case ButtonAction.Play: this.ButtonState = ButtonStates.Play; break; } }
//******************************************************************************************* /// <summary> /// /// </summary> /// <param name="e"></param> //******************************************************************************************* protected override void OnMouseMove(MouseEventArgs e) { if (m_fMouseButtonDown && !m_fButtonLockedDown) { ButtonStates nTmpPaintState = ButtonStates.Flat; if (m_rect.Contains(e.X, e.Y)) { nTmpPaintState = ButtonStates.Down; } if (nTmpPaintState != m_PaintState) { m_PaintState = nTmpPaintState; Invalidate(); } } base.OnMouseMove(e); }
protected virtual void cc_hover(bool hovering) { if (!enabled) { return; } if (hovering) { if (state != ButtonStates.PRESSING) { state = ButtonStates.HOVERING; Color = hoverColor; } } else if (state != ButtonStates.PRESSING) { state = ButtonStates.NORMAL; Color = defaultColor; } }
public AnimatedButton(Renderer2D r2D, Rectangle bounds, int[] framesPerState, bool[] loopStates) : base(r2D, bounds) { if (framesPerState.Length != loopStates.Length) { throw new ArgumentException("framesPerState necessita ter o mesmo número de elementos que loopStates"); } this.framesPerState = framesPerState; this.loopStates = loopStates; int totalFrames = 0; foreach (int frames in framesPerState) { totalFrames += frames; } textures = new Texture2D[totalFrames]; lastState = State; }
public void SelectButton() { if (_state == ButtonStates.Disabled || _state == ButtonStates.FadeIn || _state == ButtonStates.FadeOut) { return; } if (_state == ButtonStates.Selected) { _animator.SetNewAnimation((int)ButtonStates.Deselect); _state = ButtonStates.Deselect; } else { _animator.SetNewAnimation((int)ButtonStates.Select); _state = ButtonStates.Select; } OnSelected(_args); }
public void UpdateOwnLogic() { if (_animator.AnimationFinished) { if (_state == ButtonStates.Disabled || _state == ButtonStates.Enabled || _state == ButtonStates.Selected || _state == ButtonStates.HighlightDisabled || _state == ButtonStates.HighlightEnabled || _state == ButtonStates.HighlightSelected) { _animator.AdvanceAnimationReplay(); return; } if (_state == ButtonStates.Select) { if (_type == ButtonType.Standard) { _state = ButtonStates.Enabled; _animator.SetNewAnimation((int)ButtonStates.Enabled); } else { _state = ButtonStates.Selected; _animator.SetNewAnimation((int)ButtonStates.Selected); } } if (_state == ButtonStates.Deselect || _state == ButtonStates.FadeIn) { _state = ButtonStates.Enabled; _animator.SetNewAnimation((int)ButtonStates.Enabled); } if (_state == ButtonStates.FadeOut) { _state = ButtonStates.Hidden; } } else { _animator.AdvanceAnimation(); } }
void Update() { if (changeInventoryIcons && inventoryDisplayStates == InventoryDisplayStates.InventoryLegsSpawning) { for (int i = 0; i < buttons.Count; i++) { buttons[i].GetComponent<Image>().sprite = Resources.Load<Sprite>("Sprites/LegsItems/" + legsItems[i]); } inventoryDisplayStates = InventoryDisplayStates.InventoryLegsSpawningDone; changeInventoryIcons = false; } if (buttonStates == ButtonStates.Delete) { biographyImageScript.color = Color.clear; panelImageScript.color = Color.clear; changeInventoryIcons = false; inventoryDisplayStates = InventoryDisplayStates.NoInventory; buttonStates = ButtonStates.Create; DestroyButtons(); } }
/// <summary> /// Updates the mouse location and return true if the state had to change. /// </summary> /// <param name="mouseLocation">Updates this button appropriately based on the specified mouse location.</param> /// <returns>Boolean, true if a change was made.</returns> public bool UpdateLight(Point mouseLocation) { PointF pt = new PointF(mouseLocation.X, mouseLocation.Y); if (Bounds.Contains(pt)) { if (_state.IsLit() == false) { _state = _state.Lit(); return true; } } else { if (_state.IsLit()) { _state = _state.Darkened(); return true; } } return false; }
/// <summary> /// Triggers the bound pointer up action /// </summary> public virtual void OnPointerUp(PointerEventData data) { if (!Interactable) { return; } if (CurrentState != ButtonStates.ButtonPressed && CurrentState != ButtonStates.ButtonDown) { return; } CurrentState = ButtonStates.ButtonUp; ButtonStateChange?.Invoke(PointerEventData.FramePressState.Released, data); if ((Time.timeScale != 0) && (ReleasedDelay > 0)) { Invoke("InvokeReleased", ReleasedDelay); } else { ButtonReleased.Invoke(); } }
/// <summary> /// Triggers the bound pointer down action /// </summary> public virtual void OnPointerDown(PointerEventData data) { if (Time.time - _lastClickTimestamp < BufferDuration) { return; } if (CurrentState != ButtonStates.Off) { return; } CurrentState = ButtonStates.ButtonDown; _lastClickTimestamp = Time.time; if ((Time.timeScale != 0) && (PressedFirstTimeDelay > 0)) { Invoke("InvokePressedFirstTime", PressedFirstTimeDelay); } else { ButtonPressedFirstTime.Invoke(); } }
private void Awake() { if (!Application.isEditor) { Destroy(gameObject); return; } manualController = GetComponent <CustomInputControl>(); currentButtonStates = new ButtonStates(); currentlyVisible = false; visibilityChanged = false; controllerId = (uint)Random.value; InteractionInputSource inputSource = FindObjectOfType <InteractionInputSource>(); if (inputSource != null) { isNavigatorUsingRails = inputSource.UseRailsNavigation; } }
public void BtnRB() { menuState = buttons.GetMenuState(); switch (menuState) { case ButtonStates.DEFAULT: buttons.SetMenu(ButtonStates.DEV_TOOLS); break; case ButtonStates.ATTACK: buttons.SetMenu(ButtonStates.DEFAULT); break; case ButtonStates.ITEM: buttons.SetMenu(ButtonStates.DEFAULT); break; case ButtonStates.DEV_TOOLS: buttons.SetMenu(ButtonStates.DEFAULT); break; } }
//******************************************************************************************* /// <summary> /// Press or release the button. If the button does not toggle, this method does nothing. /// </summary> /// <param name="fPressed">True if button should be shown pressed.</param> //******************************************************************************************* public void PressButton(bool fPressed) { CheckDisposed(); if (m_fButtonToggles && m_fButtonLockedDown != fPressed) { m_fButtonLockedDown = fPressed; if (m_fButtonLockedDown) { m_PaintState = ButtonStates.Down; } else if (ButtonStyle == ButtonStyles.Popup) { m_PaintState = ButtonStates.Flat; } else { m_PaintState = ButtonStates.Up; } this.Invalidate(); } }
public void Handler(ButtonStates state) { if (!graphic) { graphic = GetComponent <Image>(); normal = graphic.sprite; } switch (state) { case ButtonStates.Normal: graphic.sprite = normal; break; case ButtonStates.HightLighted: if (spriteState.highlightedSprite) { graphic.sprite = spriteState.highlightedSprite; } break; case ButtonStates.Pressed: if (spriteState.pressedSprite) { graphic.sprite = spriteState.pressedSprite; } break; case ButtonStates.Disabled: if (spriteState.disabledSprite) { graphic.sprite = spriteState.disabledSprite; } break; default: break; } }
/// <summary> /// Update the button /// </summary> /// <param name="panelRect">The rectangle the button resides in</param> public override void Update(Rect panelRect) { int mouseX = Globals.mouseX; int mouseY = Globals.mouseY; var events = Globals.eventQueue; double _mouseX = (mouseX - panelRect.X) / (double)panelRect.W; double _mouseY = (mouseY - panelRect.Y) / (double)panelRect.H; bool hovering = false; bool mouseUp = (events.Any(e => e.type == SDL.SDL_EventType.SDL_MOUSEBUTTONUP)); bool mouseDown = (events.Any(e => e.type == SDL.SDL_EventType.SDL_MOUSEBUTTONDOWN)); if (_mouseX > x && _mouseX < x + w && _mouseY > y && _mouseY < y + h) { hovering = true; } if (!hovering) { State = ButtonStates.Mouseable; } if (State == ButtonStates.Mouseable && hovering) { State = ButtonStates.Moused; } if (State == ButtonStates.Moused && mouseDown) { State = ButtonStates.Pressed; } if (State == ButtonStates.Pressed && mouseUp) { action(); State = ButtonStates.Moused; } }
private void ProcessMouseUp() { switch (_downButton) { case ChromeButton.Minimize: Form.WindowState = FormWindowState.Minimized; break; case ChromeButton.MaximizeRestore: Form.WindowState = Form.WindowState == FormWindowState.Maximized ? FormWindowState.Normal : FormWindowState.Maximized; break; case ChromeButton.Close: Form.Close(); break; } if (_downExtraButton != null) _downExtraButton.OnClick(EventArgs.Empty); Form.Capture = false; CaptureStart = null; var state = new ButtonStates(this); _formChrome.BeginUpdate(); SetOverButton(state.OverButton); SetDownButton(state.DownButton); SetOverButton(state.OverExtraButton); SetDownButton(state.DownExtraButton); _formChrome.EndUpdate(); }
void _formChrome_NonClientAreaPaint(object sender, NonClientPaintEventArgs e) { var border = _formChrome.AdjustedResizeBorderThickness; if (border != _lastBorder) { _lastBorder = border; _dropShadowManager.Synchronize(); } UpdateBorderColor(); e.Graphics.Clear(SystemColors.Control); var state = new ButtonStates(this); if (state.Close.Draw) DrawButton(e.Graphics, state.Close, e.IsMaximized); if (state.MaximizeRestore.Draw) DrawButton(e.Graphics, state.MaximizeRestore, e.IsMaximized); if (state.Minimize.Draw) DrawButton(e.Graphics, state.Minimize, e.IsMaximized); foreach (var extraButton in state.ExtraButtons) { DrawButton(e.Graphics, extraButton); } int leftOffset = IconOffset.X + border.Left; if (state.DrawIcon) { e.Graphics.DrawImage( GetFormIcon(), leftOffset, IconOffset.Y + border.Top ); leftOffset += IconSize.Width; } leftOffset += TextOffset.X; var textBounds = new Rectangle( leftOffset, TextOffset.Y + border.Top, state.RightOffset - leftOffset, int.MaxValue ); TextRenderer.DrawText( e.Graphics, Form.Text, SystemFonts.MessageBoxFont, textBounds, SystemColors.ControlDarkDark, SystemColors.Control, TextFormatFlags.NoPrefix | TextFormatFlags.SingleLine | TextFormatFlags.EndEllipsis ); }
//void OnTriggerExit(Collider other) //{ // if (other.tag == "models") // { // biographyImageScript.color = Color.clear; // panelImageScript.color = Color.clear; // changeInventoryIcons = false; // inventoryDisplayStates = InventoryDisplayStates.NoInventory; // buttonStates = ButtonStates.Create; // DestroyButtons(); // } //} public void clearDisplay() { biographyImageScript.color = Color.clear; panelImageScript.color = Color.clear; changeInventoryIcons = false; inventoryDisplayStates = InventoryDisplayStates.NoInventory; buttonStates = ButtonStates.Create; DestroyButtons(); }
/// <summary> /// Updates the depressed nature of the button based on a mouse click in the specified location /// </summary> /// <param name="mouseLocation"></param> /// <returns></returns> public bool UpdatePressed(System.Drawing.Point mouseLocation) { PointF pt = new PointF((float)mouseLocation.X, (float)mouseLocation.Y); if (Bounds.Contains(pt)) { bool test = _state.IsPressed(); _state = _state.InverseDepression(); bool test2 = _state.IsPressed(); return true; } return false; }
void _formChrome_NonClientMouseDown(object sender, NonClientMouseEventArgs e) { var state = new ButtonStates(this); if (state.OverButton != ChromeButton.None) { SetOverButton(ChromeButton.None); SetDownButton(state.OverButton); CaptureStart = e.Location; Form.Capture = true; FormChrome.PaintNonClientArea(); } }
void SendInput(ControllerInfo info, string inputName, ButtonStates state) { foreach (IInputListener listener in info.GetListeners()) { listener.OnButtonInput(new ButtonInput(info.Name, inputName, state)); } }
public ButtonInput(string controllerName, string inputName, ButtonStates state) { this.controllerName = controllerName; this.inputName = inputName; this.state = state; }
public void SetState(ButtonStates newState) { this.currentState = newState; SetColor(); }
//******************************************************************************************* /// <summary> /// Press or release the button. If the button does not toggle, this method does nothing. /// </summary> /// <param name="fPressed">True if button should be shown pressed.</param> //******************************************************************************************* public void PressButton(bool fPressed) { CheckDisposed(); if (m_fButtonToggles && m_fButtonLockedDown != fPressed) { m_fButtonLockedDown = fPressed; if (m_fButtonLockedDown) m_PaintState = ButtonStates.Down; else if (ButtonStyle == ButtonStyles.Popup) m_PaintState = ButtonStates.Flat; else m_PaintState = ButtonStates.Up; this.Invalidate(); } }
public void SendButtonInput(string inputName, ButtonStates state) { for (int i = 0; i < _listeners.Count; i++) _listeners[i].OnButtonInput(new ButtonInput(Name, inputName, state)); }
// Update is called once per frame void Update () { axis = Input.GetAxisRaw("Vertical"); if (axis != 0) { if (axisInUse == false) { if( axis > 0) { if (currentState == ButtonStates.PLAY) { currentState = ButtonStates.CREDITS; } else currentState--; } else if( axis < 0) { if (currentState == ButtonStates.CREDITS) { currentState = ButtonStates.PLAY; } else currentState++; } axisInUse = true; } } if (Input.GetAxisRaw("Vertical") == 0) { axisInUse = false; } if (Input.GetAxisRaw("Fire1") != 0) { if(currentState == ButtonStates.PLAY) { SceneManager.LoadScene("SceneProg"); } if(currentState == ButtonStates.QUIT) { Application.Quit(); } if (currentState == ButtonStates.CREDITS) { inCredits = true; } } if (inCredits) { if(!creditsCamInUse) { mainCam.transform.position = new Vector3(41.3f,0, -6.23f); creditsCamInUse = true; } CreditsText.transform.Translate(0, 0.1f, 0); if(CreditsText.transform.position.y > 55) { SceneManager.LoadScene(SceneManager.GetActiveScene().name); } } SetColor(); }
// Use this for initialization void Start () { currentState = ButtonStates.PLAY; mainCam = GameObject.Find("Main Camera"); }
//******************************************************************************************* /// <summary> /// /// </summary> /// <param name="e"></param> //******************************************************************************************* protected override void OnMouseEnter(EventArgs e) { m_PaintState = (m_fButtonLockedDown || m_fMouseButtonDown ? ButtonStates.Down : ButtonStates.Up); Invalidate(); base.OnMouseEnter(e); }
private void ProcessMouseMove() { var state = new ButtonStates(this); _formChrome.BeginUpdate(); SetOverButton(state.OverButton); SetOverButton(state.OverExtraButton); SetDownButton(state.DownButton); SetDownButton(state.DownExtraButton); _formChrome.EndUpdate(); }
private void ProcessMouseUp() { switch (_downButton) { case ChromeButton.Minimize: Form.WindowState = FormWindowState.Minimized; break; case ChromeButton.MaximizeRestore: Form.WindowState = Form.WindowState == FormWindowState.Maximized ? FormWindowState.Normal : FormWindowState.Maximized; break; case ChromeButton.Close: Form.Close(); break; } Form.Capture = false; CaptureStart = null; var state = new ButtonStates(this); SetOverButton(state.OverButton); SetDownButton(state.DownButton); }
protected virtual void ChangeState(ButtonStates newState) { CurrentState = newState; UpdateMaterial((int)newState); }
private void ProcessMouseMove() { var state = new ButtonStates(this); SetOverButton(state.OverButton); SetDownButton(state.DownButton); }
public void SimulateButtonInput(ControllerInfo info, string inputName, ButtonStates state) { SendInput(info, inputName, state); }
//******************************************************************************************* /// <summary> /// /// </summary> /// <param name="e"></param> //******************************************************************************************* protected override void OnMouseDown(MouseEventArgs e) { if (e.Button == MouseButtons.Left) { m_fMouseButtonDown = true; m_PaintState = ButtonStates.Down; Invalidate(); } base.OnMouseDown(e); }
//******************************************************************************************* /// <summary> /// /// </summary> /// <param name="e"></param> //******************************************************************************************* protected override void OnMouseLeave(EventArgs e) { m_PaintState = (m_fButtonLockedDown ? ButtonStates.Down : ButtonStates.Flat); Invalidate(); base.OnMouseLeave(e); }
/// <summary> /// Updates the depressed nature of the button based on a mouse click in the specified location /// </summary> /// <param name="mouseLocation"></param> /// <returns></returns> public bool UpdatePressed(Point mouseLocation) { PointF pt = new PointF(mouseLocation.X, mouseLocation.Y); if (Bounds.Contains(pt)) { _state = _state.InverseDepression(); return true; } return false; }
//******************************************************************************************* /// <summary> /// /// </summary> /// <param name="e"></param> //******************************************************************************************* protected override void OnMouseMove(MouseEventArgs e) { if (m_fMouseButtonDown && !m_fButtonLockedDown) { ButtonStates nTmpPaintState = ButtonStates.Flat; if (m_rect.Contains(e.X, e.Y)) nTmpPaintState = ButtonStates.Down; if (nTmpPaintState != m_PaintState) { m_PaintState = nTmpPaintState; Invalidate(); } } base.OnMouseMove(e); }
//******************************************************************************************* /// <summary> /// /// </summary> /// <param name="e"></param> //******************************************************************************************* protected override void OnMouseUp(MouseEventArgs e) { if (e.Button == MouseButtons.Left) { m_fMouseButtonDown = false; if (!m_fButtonToggles) { m_fButtonLockedDown = false; m_PaintState = ButtonStates.Flat; Invalidate(); } else { // Only do the following block of code when the button's state is not already // pushed in or it's not part of a group of option buttons. if (!m_behaveLikeOptionButton || !m_fButtonLockedDown) { // If the mouse pointer is still over the button when the user lifts // the mouse button, toggle the buttons state. Otherwise, ignore the // fact that the user ever pressed the mouse button in the first place. if (m_rect.Contains(e.X, e.Y)) PressButton(!m_fButtonLockedDown); else { m_PaintState = (m_fButtonLockedDown ? ButtonStates.Down : ButtonStates.Flat); Invalidate(); } } } } base.OnMouseUp(e); }