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;
}
/// <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;
}
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);
}
/// <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;
}
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;
