protected override void OnHidden() { base.OnHidden(); var temp = Owner; Owner = null; moveButton = 0; if (temp != null) { if (temp is ToolWindow) { if (!byDeactivate) { ((ToolWindow)temp).byDeactivate = true; } } // temp.Visible = true; } if (timerHide.Enabled) { timerHide.Stop(); } byDeactivate = false; }
private void HandleButtonDown(Entity mouseHit, ref InputSystemState state, PointerButton button) { var buttonState = ButtonStates[(int)button]; buttonState.Pressed = true; buttonState.PressPosition = PointerFrameData[0].Position; buttonState.PressEntity = mouseHit; if (button == PointerButton.Left) { if (mouseHit != state.SelectedEntity) { //TODO: Selection event if (state.SelectedEntity != default) { CreateEvent(state.SelectedEntity, PointerEventType.Deselected, true, PointerButton.Left); } if (mouseHit != default) { CreateEvent(mouseHit, PointerEventType.Selected, true, PointerButton.Left); } state.SelectedEntity = mouseHit; } } if (mouseHit != default) { CreateEvent(mouseHit, PointerEventType.Down, true, button); } ButtonStates[(int)button] = buttonState; }
public void ButtonReleased(PointerButton button) { var ph = pointerHandler; if(ph != null) { ph.ButtonReleased((int)button); } }
protected void OnContentMouseDown(object sender, ButtonEventArgs e) { if (e.Button == PointerButton.Left) { movePoint = Desktop.MouseLocation; moveButton = e.Button; bar.Cursor = CursorType.Move; } }
public void ButtonReleased(PointerButton button) { var ph = pointerHandler; if (ph != null) { ph.ButtonReleased((int)button); } }
/// <summary> /// Creates a new pointer event. For runtime use only. /// </summary> /// <param name="screenPos">Screen position where the input event occurred.</param> /// <param name="delta">Change in movement since last sent event.</param> /// <param name="button">Button that triggered the pointer event. Might be irrelevant depending on event type. /// (for example move events don't correspond to a button.</param> /// <param name="shift">Is shift button on the keyboard being held down.</param> /// <param name="control">Is control button on the keyboard being held down.</param> /// <param name="alt">Is alt button on the keyboard being held down.</param> /// <param name="mouseWheelScrollAmount">If mouse wheel is being scrolled, what is the amount. Only relevant for /// move events.</param> internal PointerEvent(Vector2I screenPos, Vector2I delta, PointerButton button, bool shift, bool control, bool alt, float mouseWheelScrollAmount) { _screenPos = screenPos; _delta = delta; _button = button; _shift = shift; _control = control; _alt = alt; _mouseWheelScrollAmount = mouseWheelScrollAmount; }
/// <summary> /// Creates a new pointer event. For runtime use only. /// </summary> /// <param name="screenPos">Screen position where the input event occurred.</param> /// <param name="delta">Change in movement since last sent event.</param> /// <param name="button">Button that triggered the pointer event. Might be irrelevant depending on event type. /// (for example move events don't correspond to a button.</param> /// <param name="shift">Is shift button on the keyboard being held down.</param> /// <param name="control">Is control button on the keyboard being held down.</param> /// <param name="alt">Is alt button on the keyboard being held down.</param> /// <param name="mouseWheelScrollAmount">If mouse wheel is being scrolled, what is the amount. Only relevant for /// move events.</param> /// <param name="isUsed">Set to true if the event was handled previously by some internal system (like GUI).</param> internal PointerEvent(Vector2I screenPos, Vector2I delta, PointerButton button, bool shift, bool control, bool alt, float mouseWheelScrollAmount, bool isUsed) { this.screenPos = screenPos; this.delta = delta; this.button = button; this.shift = shift; this.control = control; this.alt = alt; this.mouseWheelScrollAmount = mouseWheelScrollAmount; this.isUsed = isUsed; }
private MouseButton ToMouseButton(PointerButton button) { switch(button) { case PointerButton.Left: return MouseButton.Left; case PointerButton.Right: return MouseButton.Right; case PointerButton.Middle: return MouseButton.Middle; } return MouseButton.Extra; }
private MouseButton ToMouseButton(PointerButton button) { switch (button) { case PointerButton.Left: return(MouseButton.Left); case PointerButton.Right: return(MouseButton.Right); case PointerButton.Middle: return(MouseButton.Middle); } return(MouseButton.Extra); }
public static MouseButton ToWpfButton(this PointerButton value) { switch (value) { case PointerButton.Left: return(MouseButton.Left); case PointerButton.Middle: return(MouseButton.Middle); case PointerButton.Right: return(MouseButton.Right); case PointerButton.ExtendedButton1: return(MouseButton.XButton1); case PointerButton.ExtendedButton2: return(MouseButton.XButton2); default: throw new ArgumentException(); } }
/// <summary> /// Handles input. Should be called by the owning window whenever a pointer is double-clicked. /// </summary> /// <param name="panelPos">Position of the pointer relative to the panel parent to this element.</param> /// <param name="button">Pointer button involved in the event.</param> internal void OnPointerDoubleClicked(Vector2I panelPos, PointerButton button) { Rect2I canvasBounds = canvas.Bounds; if (!canvasBounds.Contains(panelPos)) { return; } Vector2I canvasPos = panelPos - new Vector2I(canvasBounds.x, canvasBounds.y); int keyIdx; if (FindKey(canvasPos, out keyIdx)) { ColorPicker.Show(keys[keyIdx].color, false, (b, color) => { if (b) { ColorGradientKey key = keys[keyIdx]; key.color = color; keys[keyIdx] = key; OnGradientModified?.Invoke(new ColorGradient(keys.ToArray())); Rebuild(); } }); } else { float time = PixelToTime(canvasPos.x); if (time >= 0.0f && time <= 1.0f) { keys.Add(new ColorGradientKey(Color.Black, time)); keys.Sort((lhs, rhs) => lhs.time.CompareTo(rhs.time)); OnGradientModified?.Invoke(new ColorGradient(keys.ToArray())); } Rebuild(); } }
static OxyMouseButton ToOxyMouseButton(this PointerButton button) { switch (button) { case PointerButton.Left: return(OxyMouseButton.Left); case PointerButton.Middle: return(OxyMouseButton.Middle); case PointerButton.Right: return(OxyMouseButton.Right); case PointerButton.ExtendedButton1: return(OxyMouseButton.XButton1); case PointerButton.ExtendedButton2: return(OxyMouseButton.XButton2); } return(OxyMouseButton.Left); }
/// <summary> /// Handles input. Should be called by the owning window whenever a pointer is pressed. /// </summary> /// <param name="panelPos">Position of the pointer relative to the panel parent to this element.</param> /// <param name="button">Pointer button involved in the event.</param> internal void OnPointerPressed(Vector2I panelPos, PointerButton button) { Rect2I canvasBounds = canvas.Bounds; Vector2I canvasPos = panelPos - new Vector2I(canvasBounds.x, canvasBounds.y); if (button == PointerButton.Left) { int keyIdx; if (FindKey(canvasPos, out keyIdx)) { selectedIdx = keyIdx; isMousePressedOverKey = true; dragStart = canvasPos; } else { selectedIdx = -1; } Rebuild(); } }
public void ButtonPressed(PointerButton button) { var ph = pointerHandler; if(ph != null) { if(status == Status.NotGrabbed && button == PointerButton.Left) { var gc = GrabConfirm; if(gc != null && !gc()) { return; } source.DetachHandler(); source = new X11EventSource(widget); source.AttachHandler(this); status = Status.Grabbed; return; } ph.ButtonPressed((int)button); } }
/// <summary> /// Handles input. Should be called by the owning window whenever a pointer is moved. /// </summary> /// <param name="panelPos">Position of the pointer relative to the panel parent to this element.</param> /// <param name="button">Pointer button involved in the event.</param> internal void OnPointerMoved(Vector2I panelPos, PointerButton button) { if (button != PointerButton.Left) { return; } if (isMousePressedOverKey) { Rect2I canvasBounds = canvas.Bounds; Vector2I canvasPos = panelPos - new Vector2I(canvasBounds.x, canvasBounds.y); if (!isDragInProgress) { int distance = Vector2I.Distance(canvasPos, dragStart); if (distance >= DRAG_START_DISTANCE) { isDragInProgress = true; } } if (isDragInProgress) { float time = PixelToTime(canvasPos.x); if (time >= 0.0f && time <= 1.0f) { ColorGradientKey key = keys[selectedIdx]; key.time = time; keys[selectedIdx] = key; OnGradientModified?.Invoke(new ColorGradient(keys.ToArray())); } Rebuild(); } } }
private void HandleButtonUp(Entity mouseHit, ref InputSystemState state, PointerButton button) { var buttonState = ButtonStates[(int)button]; buttonState.Pressed = false; if (buttonState.PressEntity != default) { CreateEvent(buttonState.PressEntity, PointerEventType.Up, true, button); } if (buttonState.IsDragging) { CreateEvent(buttonState.PressEntity, PointerEventType.EndDrag, true, button); if (mouseHit != buttonState.PressEntity) { if (mouseHit != default) { CreateEvent(mouseHit, PointerEventType.Drop, true, button); } } } if (button == PointerButton.Left) { if (mouseHit == buttonState.PressEntity) { CreateEvent(buttonState.PressEntity, PointerEventType.Click, true, button); } } buttonState.IsDragging = false; buttonState.PressEntity = default; ButtonStates[(int)button] = buttonState; }
public static MouseActionButtons ToLmk(this PointerButton button) { if (button == PointerButton.Left) { return(MouseActionButtons.Left); } if (button == PointerButton.Middle) { return(MouseActionButtons.Middle); } if (button == PointerButton.Right) { return(MouseActionButtons.Right); } if (button == PointerButton.ExtendedButton1) { return(MouseActionButtons.XButton1); } if (button == PointerButton.ExtendedButton2) { return(MouseActionButtons.XButton2); } return(MouseActionButtons.None); }
public void ButtonPressed(PointerButton button) { var ph = pointerHandler; if (ph != null) { if (status == Status.NotGrabbed && button == PointerButton.Left) { var gc = GrabConfirm; if (gc != null && !gc()) { return; } source.DetachHandler(); source = new X11EventSource(widget); source.AttachHandler(this); status = Status.Grabbed; return; } ph.ButtonPressed((int)button); } }
/// <summary> /// Creates a pointer up action. /// </summary> /// <param name="button">The button of the pointer that should be released.</param> /// <returns>The action representing the pointer up gesture.</returns> public Interaction CreatePointerUp(PointerButton button) { return(CreatePointerUp((MouseButton)button)); }
public PointerButtonEventArgs(PointerButton button, InputAction action, KeyModifiers modifiers) { Action = action; Button = button; Modifiers = modifiers; }
public void RegisterMouseMotionTracker(PointerButton releaseButton, Action<double, double> callback) { textArea.RegisterMouseMotionTracker(releaseButton, callback); }
protected void OnContentMouseUp(object sender, ButtonEventArgs e) { moveButton = 0; moveBounds = Location; bar.Cursor = CursorType.Arrow; }
/// <summary> /// Query if the provided pointer button is currently being being pressed (only true for one frame). /// </summary> /// <param name="code">Code of the button to query.</param> /// <returns>True if the button is being pressed.</returns> public static bool IsPointerButtonDown(PointerButton code) { return(Internal_IsPointerButtonDown(code)); }
/// <summary> /// Triggers when some pointing device (mouse cursor, touch) button is released. /// </summary> /// <param name="screenPos">Screen position where the input event occurred.</param> /// <param name="delta">Change in movement since last sent event.</param> /// <param name="button">Button that triggered the pointer event. Might be irrelevant depending on event type. /// (e.g. move events don't correspond to a button.</param> /// <param name="shift">Is shift button on the keyboard being held down.</param> /// <param name="ctrl">Is control button on the keyboard being held down.</param> /// <param name="alt">Is alt button on the keyboard being held down.</param> /// <param name="scrollAmount">If mouse wheel is being scrolled, what is the amount. Only relevant for /// move events.</param> private static void Internal_TriggerPointerReleased(Vector2I screenPos, Vector2I delta, PointerButton button, bool shift, bool ctrl, bool alt, float scrollAmount) { PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount); if (OnPointerReleased != null) { OnPointerReleased(ev); } }
private static extern bool Internal_IsPointerButtonDown(PointerButton keyCode);
/// <summary> /// Triggers when some pointing device (mouse cursor, touch) button is double clicked. /// </summary> /// <param name="screenPos">Screen position where the input event occurred.</param> /// <param name="delta">Change in movement since last sent event.</param> /// <param name="button">Button that triggered the pointer event. Might be irrelevant depending on event type. /// (for example move events don't correspond to a button.</param> /// <param name="shift">Is shift button on the keyboard being held down.</param> /// <param name="ctrl">Is control button on the keyboard being held down.</param> /// <param name="alt">Is alt button on the keyboard being held down.</param> /// <param name="scrollAmount">If mouse wheel is being scrolled, what is the amount. Only relevant for /// move events.</param> /// <param name="isUsed">Set to true if the event was handled previously by some internal system (like GUI).</param> private static void Internal_TriggerPointerDoubleClick(Vector2I screenPos, Vector2I delta, PointerButton button, bool shift, bool ctrl, bool alt, float scrollAmount, bool isUsed) { PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount, isUsed); if (OnPointerDoubleClick != null) OnPointerDoubleClick(ev); }
/// <summary> /// Creates a pointer up action. /// </summary> /// <param name="button">The button of the pointer that should be released.</param> /// <param name="pointerExtraAttributes">Additional pointer attributes.</param> /// <returns>The action representing the pointer up gesture.</returns> public Interaction CreatePointerUp(PointerButton button, IInteractionInfo pointerExtraAttributes) { return(new ExtendedPointerInteraction(CreatePointerUp((MouseButton)button), pointerExtraAttributes)); }
public bool WasButtonDown(PointerButton button) { return(_mouseState.WasButtonDown((MouseButton)button)); }
internal void RegisterMouseMotionTracker(PointerButton releaseButton, Action<double, double> callback) { mouseMotionTrackers.Add(Tuple.Create(releaseButton, callback)); }
/// <summary> /// Query if the provided pointer button is currently being being released (only true for one frame). /// </summary> /// <param name="code">Code of the button to query.</param> /// <returns>True if the button is being released.</returns> public static bool IsPointerButtonUp(PointerButton code) { return Internal_IsPointerButtonUp(code); }
/// <summary> /// Triggers when some pointing device (mouse cursor, touch) button is released. /// </summary> /// <param name="screenPos">Screen position where the input event occurred.</param> /// <param name="delta">Change in movement since last sent event.</param> /// <param name="button">Button that triggered the pointer event. Might be irrelevant depending on event type. /// (for example move events don't correspond to a button.</param> /// <param name="shift">Is shift button on the keyboard being held down.</param> /// <param name="ctrl">Is control button on the keyboard being held down.</param> /// <param name="alt">Is alt button on the keyboard being held down.</param> /// <param name="scrollAmount">If mouse wheel is being scrolled, what is the amount. Only relevant for /// move events.</param> private static void Internal_TriggerPointerReleased(Vector2I screenPos, Vector2I delta, PointerButton button, bool shift, bool ctrl, bool alt, float scrollAmount) { PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount); if (OnPointerReleased != null) OnPointerReleased(ev); }
private void CreateEvent(Entity target, PointerEventType type, bool propagateParent, PointerButton button) { if (ReceiverFromEntity.Exists(target) && (ReceiverFromEntity[target].ListenerTypes & type) == type) { PointerEventData eventData = new PointerEventData() { Button = button, ClickCount = -1, ClickTime = 0.0f, Delta = PointerFrameData[0].Delta, PointerId = -1, Position = PointerFrameData[0].Position, ScrollDelta = float2.zero, UseDragThreshold = false, }; if (button != PointerButton.Invalid) { eventData.IsDragging = ButtonStates[(int)button].IsDragging; eventData.PressPosition = ButtonStates[(int)button].PressPosition; eventData.PressEntity = ButtonStates[(int)button].PressEntity; } TargetToEvent.Add(target, new PointerInputBuffer() { EventId = m_EventIdCounter++, EventType = type, EventData = eventData }); } if (!propagateParent || IsConsumableType(type)) { return; } Entity parent = GetParent(target); while (parent != default) { if (!ReceiverFromEntity.Exists(parent)) { parent = GetParent(parent); } else { if (IsConsumableType(type)) { var receiver = ReceiverFromEntity[parent]; if ((receiver.ListenerTypes & type) == type) { propagateParent = false; } } CreateEvent(parent, type, propagateParent, button); break; } } }
private static extern bool Internal_IsPointerButtonUp(PointerButton keyCode);
public void RegisterMouseMotionTracker(PointerButton releaseButton, Action <double, double> callback) { textArea.RegisterMouseMotionTracker(releaseButton, callback); }
internal void RegisterMouseMotionTracker(PointerButton releaseButton, Action <double, double> callback) { mouseMotionTrackers.Add(Tuple.Create(releaseButton, callback)); }
public bool this[PointerButton button] => _mouseState[(MouseButton)button];
/// <summary> /// Triggers when some pointing device (mouse cursor, touch) button is double clicked. /// </summary> /// <param name="screenPos">Screen position where the input event occurred.</param> /// <param name="delta">Change in movement since last sent event.</param> /// <param name="button">Button that triggered the pointer event. Might be irrelevant depending on event type. /// (for example move events don't correspond to a button.</param> /// <param name="shift">Is shift button on the keyboard being held down.</param> /// <param name="ctrl">Is control button on the keyboard being held down.</param> /// <param name="alt">Is alt button on the keyboard being held down.</param> /// <param name="scrollAmount">If mouse wheel is being scrolled, what is the amount. Only relevant for /// move events.</param> /// <param name="isUsed">Set to true if the event was handled previously by some internal system (like GUI).</param> private static void Internal_TriggerPointerDoubleClick(Vector2I screenPos, Vector2I delta, PointerButton button, bool shift, bool ctrl, bool alt, float scrollAmount, bool isUsed) { PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount, isUsed); if (OnPointerDoubleClick != null) { OnPointerDoubleClick(ev); } }
internal NotificationIconInvokedEventArgs(PointerButton pointerButton) => PointerButton = pointerButton;