private void mouseClick(object sender, MouseEventArgs e)
{
if (_selection.Selecting)
{
return;
}
var hitInfo = CalcHitInfo(e.Location);
if (e.Button == MouseButtons.Left)
{
if (hitInfo.IsSearchButton)
{
handleSearchClick(hitInfo);
}
else if (hitInfo.IsSortButton)
{
handleSortClick(hitInfo);
}
else if (hitInfo.AlignButtonDirection.HasValue)
{
handleAlignClick(hitInfo);
}
}
MouseClicked?.Invoke(this, hitInfo, e);
}
/// <summary>
/// Apply box action when it clicked.
/// </summary>
/// <param name="i_Sender">Sender.</param>
/// <param name="i_EventArgs">Mouse event args.</param>
internal virtual void FBBox_MouseClick(object i_Sender, MouseEventArgs i_EventArgs)
{
if (MouseClicked != null)
{
MouseClicked.Invoke(Index);
}
}
private void ProcessEvents(Event e)
{
switch (e.type)
{
case EventType.MouseDown:
if (e.button == 1)
{
if (MouseClicked != null)
{
MouseClicked.Invoke(e.mousePosition);
}
}
break;
case EventType.MouseDrag:
if (e.button == 0)
{
if (Drag != null)
{
Drag.Invoke(e.delta);
}
GUI.changed = true;
}
break;
}
}
/// <summary>
/// Apply box action when it clicked.
/// </summary>
/// <param name="i_Index">Box index.</param>
private void m_instance_MouseClicked(int i_Index)
{
if (MouseClicked != null)
{
MouseClicked.Invoke(i_Index);
}
}
private void CheckButtonReleased(Func <MouseState, ButtonState> getButtonState, MouseButton button)
{
if ((getButtonState(_currentState) == ButtonState.Released) &&
(getButtonState(_previousState) == ButtonState.Pressed))
{
var args = new MouseEventArgs(ViewportAdapter, _gameTime.TotalGameTime, _previousState, _currentState, button);
if (_mouseDownArgs.Button == args.Button)
{
var clickMovement = DistanceBetween(args.Position, _mouseDownArgs.Position);
// If the mouse hasn't moved much between mouse down and mouse up
if (clickMovement < DragThreshold)
{
if (!_hasDoubleClicked)
{
MouseClicked?.Invoke(this, args);
}
}
else // If the mouse has moved between mouse down and mouse up
{
MouseDragEnd?.Invoke(this, args);
_dragging = false;
}
}
MouseUp?.Invoke(this, args);
_hasDoubleClicked = false;
_previousClickArgs = args;
}
}
/// <summary>
/// Checks for collision with cursor and invokes events based on user actions.
/// </summary>
public virtual void Update()
{
Container.SetPosition(new Vector2(CollRectangle.X, CollRectangle.Y));
Container.Color = CurrentColor;
Rectangle mouse = InputSystem.GetMouseInUi();
if (mouse.Intersects(CollRectangle))
{
MouseHover?.Invoke();
if (InputSystem.IsLeftMousePressed())
{
_wasPressed = true;
_wasReleased = false;
}
if (InputSystem.IsLeftMouseReleased() && _wasPressed)
{
_wasReleased = true;
}
if (_wasPressed && _wasReleased)
{
MouseClicked?.Invoke(this);
_wasReleased = false;
_wasPressed = false;
}
}
else
{
MouseOut?.Invoke();
}
}
private void Body_PreviewMouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
if (readyToReactionOnMouseDown)
{
this.GetComponent <Hit>().IsHited = true;
MouseClicked?.Invoke();
}
}
private void _mouseListener_MouseClicked(object sender, MouseEventArgs e)
{
_scene?.FireMouseClick(e);
MouseClicked?.Invoke(sender, e);
#if DEBUG
Logger.Log("Mouse clicked.");
#endif
}
public virtual void Handle(MouseClicked @event)
{
if (Shape?.GetGlobalBounds().Contains(@event.Mouse.X, @event.Mouse.Y) ?? false)
{
SetFocus(true);
OnMouseClick(@event.Mouse);
}
}
public void MouseClickRelease(Vector2 position)
{
if (DateTime.Now - SecondMouseDownTime < TimeSpan.FromMilliseconds(150))
{
MouseDoubleClicked?.Invoke(this, position);
}
else if (DateTime.Now - FirstMouseDownTime < TimeSpan.FromMilliseconds(150))
{
MouseClicked?.Invoke(this, position);
}
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
if (MouseClicked != null)
{
MouseClicked.Invoke(this, new InterceptMouseEventArgs((MouseMessages)wParam, new Point(hookStruct.pt.x, hookStruct.pt.y)));
}
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
public override void Dispose()
{
_aggregator.Unsubscribe(Entity);
MouseEnter?.Dispose();
MouseLeave?.Dispose();
MouseMove?.Dispose();
MouseClicked?.Dispose();
MouseDoubleClicked?.Dispose();
MouseDown?.Dispose();
MouseUp?.Dispose();
LostFocus?.Dispose();
base.Dispose();
}
public bool ProcessEvents(Event e)
{
switch (e.type)
{
case EventType.MouseDown:
if (e.button == 0)
{
if (BRect.Contains(e.mousePosition))
{
_isDragged = true;
_isSelected = true;
GUI.changed = true;
}
else
{
_isSelected = false;
GUI.changed = true;
}
}
if (e.button == 1 && _isSelected && BRect.Contains(e.mousePosition))
{
if (MouseClicked != null)
{
MouseClicked.Invoke(e.mousePosition);
}
e.Use();
}
break;
case EventType.MouseUp:
_isDragged = false;
break;
case EventType.MouseDrag:
if (e.button == 0 && _isDragged)
{
Drag(e.delta);
e.Use();
return(true);
}
break;
}
return(false);
}
public LineView()
{
InitializeComponent();
lineClicked = new MouseClicked(this, Clicked);
//toggleClicked = new MouseClicked(ToggleLine, ClickToggleLine);
dragLine = new DragUiElement(
LineControl,
(o, e) => ViewModel?.LineControl.MouseMove(false, e),
e => ViewModel?.LineControl.MouseDown(e),
e => ViewModel?.LineControl.MouseUp(e));
dragLineControlPoints = new DragUiElement(
LinePoints,
(o, e) => ViewModel?.LineControl.MouseMove(true, e),
e => ViewModel?.LineControl.MouseDown(e),
e => ViewModel?.LineControl.MouseUp(e));
}
public NodeControlView()
{
InitializeComponent();
mouseClicked = new MouseClicked(ControlCenter, Clicked);
points = new Dictionary <string, NodeControl>
{
{ ControlCenter.Name, NodeControl.Center },
{ ControlLeftTop.Name, NodeControl.LeftTop },
{ ControlLeftBottom.Name, NodeControl.LeftBottom },
{ ControlRightTop.Name, NodeControl.RightTop },
{ ControlRightBottom.Name, NodeControl.RightBottom },
{ ControlTop.Name, NodeControl.Top },
{ ControlLeft.Name, NodeControl.Left },
{ ControlRight.Name, NodeControl.Right },
{ ControlBottom.Name, NodeControl.Bottom }
};
}
private static void CheckForClick()
{
if (_lastMouseState.LeftButton != _currentMouseState.LeftButton)
{
if (_currentMouseState.LeftButton == ButtonState.Pressed)
{
_waitingForMouseRelease = true;
MouseLastClickLocation = new Point(_currentMouseState.X, _currentMouseState.Y);
return;
}
}
if (!_waitingForMouseRelease || _currentMouseState.LeftButton != ButtonState.Released)
{
return;
}
_waitingForMouseRelease = false;
var releaseMouseLocation = new Point(_currentMouseState.X, _currentMouseState.Y);
MouseClicked?.Invoke(new MouseClickEventArguments(MouseLastClickLocation, releaseMouseLocation));
}
private void drain_MouseUp(object sender, MouseButtonEventArgs e)
{
Animate(path14.Fill, MouseEnterBrush, path14);
if (!Mute)
{
Animate(path16.Fill, MouseEnterBrush, path16);
Animate(path18.Fill, MouseEnterBrush, path18);
Animate(path20.Fill, MouseEnterBrush, path20);
}
else
{
Animate(Cross.Fill, MouseEnterBrush, Cross);
}
if (mf)
{
mf = false;
MouseClicked?.Invoke(this, e);
}
}
private void Pb_MouseDown(object sender, MouseEventArgs e)
{
if (!tsbttnSpectrum.Checked)
{
Point loc = TranslateZoomMousePosition(e.Location, pb.Image);
Point cur = new Point(imageStartIndex.X + loc.X, imageStartIndex.Y + loc.Y);
if (e.Button == MouseButtons.Left)
{
MouseClicked?.Invoke(this, new Tuple <int, int, int>(cur.X, cur.Y, gimda.Ncols));
}
if (e.Button == MouseButtons.Right)
{
MouseClicked?.Invoke(this, new Tuple <int, int, int>(cur.X, cur.Y, -gimda.Ncols));
}
startx = e.X;
starty = e.Y;
drawRectangleBool = true;
}
else // if spectrum button is checked
{
Point loc = TranslateZoomMousePosition(e.Location, pb.Image);
Point cur = new Point(imageStartIndex.X + loc.X, imageStartIndex.Y + loc.Y);
if (((cur.X < 0) || (cur.Y < 0)) || ((cur.X > gimda.Ncols - 1) || (cur.Y > gimda.Nrows - 1)))
{
return;
}
Int32 bytePos = width * cur.Y + cur.X;
spec = new Point[gimda.Nbands];
createSpectrum(bytePos);
spectrum.displaySpectrum(spec, gimda.Wavelength);
if (e.Button == MouseButtons.Left)
{
spectrum.showSpectrumAsTable(spec, gimda.Wavelength);
}
this.Focus();
drawRectangleBool = false;
}
}
public void OnPointerClick(PointerEventData eventData)
{
//Debug.Log("Click");
MouseClicked?.Invoke();
}
private void OnMouseClick(List <Sprite> sprites, Controler controler, Vector2 clickPosition)
{
MouseClicked?.Invoke(this, controler.MousePointer, controler, clickPosition);
}
protected virtual void OnMouseClicked(MouseEventArgs e)
{
MouseClicked?.Invoke(this, e);
}
public void Update(double delta)
{
// Truncate mouse position to screen dimensions
Point position = _form.PointToClient(Cursor.Position);
_mousePosition = new Vector2I(position.X, position.Y);
MouseMoved.Raise(_mousePosition);
MouseButtons buttons = Control.MouseButtons;
bool leftMouseButtonPressed = (buttons == MouseButtons.Left);
if (leftMouseButtonPressed && !_previousMouseButtons[0])
{
MouseClicked.Raise(_mousePosition, 0);
}
else if (_previousMouseButtons[0] && !leftMouseButtonPressed)
{
MouseReleased.Raise(_mousePosition, 0);
}
_previousMouseButtons[0] = leftMouseButtonPressed;
bool rightMouseButtonPressed = (buttons == MouseButtons.Right);
if (rightMouseButtonPressed && !_previousMouseButtons[1])
{
MouseClicked.Raise(_mousePosition, 1);
}
else if (_previousMouseButtons[1] && !rightMouseButtonPressed)
{
MouseReleased.Raise(_mousePosition, 1);
}
_previousMouseButtons[1] = rightMouseButtonPressed;
foreach (Key key in _keys.Cast <Key>().Where(key => key != Key.None))
{
if (Keyboard.IsKeyDown(key))
{
if (_pressedKeys.ContainsKey(key))
{
_pressedKeys[key] += delta;
if (_pressedKeys[key] > 0.1)
{
_pressedKeys[key] = 0.0;
KeyPressed.Raise(key, InputInterop.GetCharFromKey(key), true);
}
}
else
{
_pressedKeys.Add(key, -0.9);
KeyPressed.Raise(key, InputInterop.GetCharFromKey(key), false);
}
}
else
{
if (_pressedKeys.ContainsKey(key))
{
_pressedKeys.Remove(key);
KeyReleased.Raise(key);
}
}
}
}
public TypeView()
{
InitializeComponent();
mouseClicked = new MouseClicked(this, e => ViewModel?.MouseClicked(e));
}
protected virtual void OnMouseClicked()
{
MouseClicked?.Invoke();
}
public void Click()
{
MouseClicked?.Invoke();
}
public override void Handle(MouseClicked @event) => Bus.Publish(@event, Components);
public void OnPointerClick(PointerEventData eventData)
{
MouseClicked?.Invoke();
}
private async Task handleMouseButton(Stopwatch sw, Stopwatch doubleClickSw, bool wasDown, bool isDown, MouseButton button)
{
bool fireDown = !wasDown && isDown && IsMouseIn;
bool fireDownOutside = !wasDown && isDown && !IsMouseIn && _isFocused;
_isFocused = fireDown;
bool fireUp = wasDown && !isDown;
if (fireDown)
{
sw.Restart();
}
bool fireClick = false;
bool fireDoubleClick = false;
if (fireUp)
{
if (IsMouseIn && sw.ElapsedMilliseconds < 1500 && sw.ElapsedMilliseconds != 0)
{
fireClick = true;
if (doubleClickSw.ElapsedMilliseconds == 0)
{
doubleClickSw.Restart();
}
else
{
if (doubleClickSw.ElapsedMilliseconds < 1500)
{
fireDoubleClick = true;
}
doubleClickSw.Stop();
doubleClickSw.Reset();
}
}
sw.Stop();
sw.Reset();
}
if (fireDown || fireUp || fireClick || fireDownOutside)
{
MouseButtonEventArgs args = new MouseButtonEventArgs(button, _mouseX, _mouseY);
if (fireDown)
{
await MouseDown.InvokeAsync(_entity, args);
}
else if (fireUp)
{
await MouseUp.InvokeAsync(_entity, args);
}
else if (fireDownOutside)
{
await LostFocus.InvokeAsync(_entity, args);
}
if (fireClick)
{
await MouseClicked.InvokeAsync(_entity, args);
}
if (fireDoubleClick)
{
await MouseDoubleClicked.InvokeAsync(_entity, args);
}
}
}
private void Grid_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
MouseClicked?.Invoke(this, null);
}
public void Start()
{
if (isRunning)
{
return;
}
Prepare();
isRunning = true;
IntPtr handleIn = GetStdHandle(STD_INPUT_HANDLE);
thread = new Thread(
() =>
{
while (true)
{
uint numRead = 0;
INPUT_RECORD[] record = new INPUT_RECORD[1];
record[0] = new INPUT_RECORD();
ReadConsoleInput(handleIn, record, 1, ref numRead);
if (isRunning)
{
switch (record[0].EventType)
{
case INPUT_RECORD.MOUSE_EVENT:
var mouseEvent = record[0].MouseEvent;
if (mouseEvent.dwButtonState == dwButtonStates.FROM_LEFT_1ST_BUTTON_PRESSED)
{
MouseClicked?.Invoke(this, CreateEventArgs(mouseEvent));
}
if (mouseEvent.dwEventFlags == dwEventFlags.DOUBLE_CLICK)
{
MouseDoubleClicked?.Invoke(this, CreateEventArgs(mouseEvent));
}
else if (mouseEvent.dwEventFlags == dwEventFlags.MOUSE_MOVED)
{
MouseMoved?.Invoke(this, CreateEventArgs(mouseEvent));
}
else if (mouseEvent.dwEventFlags == dwEventFlags.MOUSE_HWHEELED || mouseEvent.dwEventFlags == dwEventFlags.MOUSE_WHEELED)
{
MouseWheelChanged?.Invoke(this, CreateEventArgs(mouseEvent));
}
break;
case INPUT_RECORD.KEY_EVENT:
var keyEvent = record[0].KeyEvent;
if (keyEvent.bKeyDown)
{
KeyDown?.Invoke(this, CreateEventArgs(keyEvent));
}
break;
case INPUT_RECORD.WINDOW_BUFFER_SIZE_EVENT:
WindowBufferSizeEvent?.Invoke(record[0].WindowBufferSizeEvent);
break;
}
}
else
{
uint numWritten = 0;
WriteConsoleInput(handleIn, record, 1, ref numWritten);
return;
}
}
});
thread.Start();
}
