public MouseButtonEventArgs(MouseButton button, bool pressed, int x, int y)
{
this.button = button;
this.pressed = pressed;
this.x = x;
this.y = y;
}
public static void SimulateMouseEvent(MouseButton button, MouseButtonState state)
{
uint x = 0;
uint y = 0;
switch (button)
{
case MouseButton.Left:
if (state == MouseButtonState.Pressed)
mouse_event(MOUSEEVENTF_LEFTDOWN, x, y, 0, 0);
else
mouse_event(MOUSEEVENTF_LEFTUP, x, y, 0, 0);
break;
case MouseButton.Middle:
if (state == MouseButtonState.Pressed)
mouse_event(MOUSEEVENTF_MIDDLEDOWN, x, y, 0, 0);
else
mouse_event(MOUSEEVENTF_MIDDLEUP, x, y, 0, 0);
break;
case MouseButton.Right:
if (state == MouseButtonState.Pressed)
mouse_event(MOUSEEVENTF_RIGHTDOWN, x, y, 0, 0);
else
mouse_event(MOUSEEVENTF_RIGHTUP, x, y, 0, 0);
break;
}
}
public bool IsButtonClicked(MouseButton button)
{
ButtonState lastBtnStat = ButtonState.Released;
ButtonState curBtnStat = ButtonState.Released;
switch (button)
{
case MouseButton.Left:
lastBtnStat = lastMouseState.LeftButton;
curBtnStat = curMouseState.LeftButton;
break;
case MouseButton.Right:
lastBtnStat = lastMouseState.RightButton;
curBtnStat = curMouseState.RightButton;
break;
case MouseButton.Middle:
lastBtnStat = lastMouseState.MiddleButton;
curBtnStat = curMouseState.MiddleButton;
break;
case MouseButton.X1:
lastBtnStat = lastMouseState.XButton1;
curBtnStat = curMouseState.XButton2;
break;
case MouseButton.X2:
lastBtnStat = lastMouseState.XButton2;
curBtnStat = curMouseState.XButton2;
break;
}
if (lastBtnStat == ButtonState.Pressed &&
curBtnStat == ButtonState.Released)
return true;
return false;
}
/// <summary>
/// Gets the current state of the specified button from the device from either the underlying system or the StylusDevice
/// </summary>
/// <param name="mouseButton">
/// The mouse button to get the state of
/// </param>
/// <returns>
/// The state of the specified mouse button
/// </returns>
protected MouseButtonState GetButtonState(MouseButton mouseButton)
{
if ( _stylusDevice != null )
return _stylusDevice.GetMouseButtonState(mouseButton, this);
else
return GetButtonStateFromSystem(mouseButton);
}
public override void OnMouseDrag(float x, float y, float dx, float dy, MouseButton button, List<ModifierKey> modifiers)
{
if (HasFocus)
Focus.OnMouseDrag(x, y, dx, dy, button, modifiers);
else
base.OnMouseDrag(x, y, dx, dy, button, modifiers);
}
public MouseEventArgs(int button, Vector2 location, int clicks)
{
this.Button = (MouseButton)button;
this.Clicks = clicks;
this.Location = new Point(location);
this.Delta = 0;
}
public PlainSurfaceItem(int maxWidth, int maxHeight, int widthRequest = 0, int heightRequest = 0, string label = null)
{
//Console.WriteLine ("PlainSurfaceItem");
_label = label;
this._evtBox = new EventBox ();
this._draw = new global::Gtk.DrawingArea ();
if(widthRequest > 0) {
_draw.WidthRequest = widthRequest;
}
if(heightRequest > 0) {
_draw.HeightRequest = heightRequest;
}
this._evtBox.Add (this._draw);
maxWidth = Math.Max (maxWidth, widthRequest);
maxHeight = Math.Max (maxHeight, heightRequest);
this._height = Math.Max(_draw.Allocation.Height, heightRequest);
this._width = Math.Max(_draw.Allocation.Width, widthRequest);
this._mode = DisplayMode.Snapshot;
this._surface = new ImageSurface(Format.Argb32, maxWidth, maxHeight);
this._button = MouseButton.None;
this._background = new Color (1.0, 1.0, 1.0);
_draw.ExposeEvent += DrawExpose;
_evtBox.ButtonPressEvent += DrawButtonPressEvent;
_evtBox.ButtonReleaseEvent += DrawButtonReleaseEvent;
_evtBox.MotionNotifyEvent += DrawMotionNotifyEvent;
}
public override void MouseClick(MouseButton button)
{
if (button == MouseButton.Left)
{
//switch (mainMenu.SelectedOption)
//{
// case MainMenuFunction.NewGame:
// Game.NewGame();
// break;
// case MainMenuFunction.LoadGame:
// Game.StartTransition(GameState.LoadGame);
// break;
// case MainMenuFunction.Help:
// Game.StartTransition(GameState.Help);
// break;
// case MainMenuFunction.Exit:
// //Exit();
// break;
// case MainMenuFunction.GameStats:
// Game.StartTransition(GameState.GameStatsHelp);
// break;
// default:
// break;
//}
}
}
public InputAxisMap(MouseButton button)
{
TriggerType = AxisType.Mouse;
Trigger = button;
SecondTriggerType = AxisType.None;
}
private void CheckButtonPressed(Func<MouseState, ButtonState> getButtonState, MouseButton button)
{
if (getButtonState(_currentState) == ButtonState.Pressed &&
getButtonState(_previousState) == ButtonState.Released)
{
var args = new MouseEventArgs(_gameTime.TotalGameTime, _previousState, _currentState, button);
MouseDown.Raise(this, args);
_mouseDownArgs = args;
if (_previousClickArgs != null)
{
// If the last click was recent
var clickMilliseconds = (args.Time - _previousClickArgs.Time).TotalMilliseconds;
if (clickMilliseconds <= DoubleClickMilliseconds)
{
MouseDoubleClicked.Raise(this, args);
_hasDoubleClicked = true;
}
_previousClickArgs = null;
}
}
}
private void CheckButtonReleased(Func<MouseState, ButtonState> getButtonState, MouseButton button)
{
if (getButtonState(_currentState) == ButtonState.Released &&
getButtonState(_previousState) == ButtonState.Pressed)
{
var args = new MouseEventArgs(_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.Raise(this, args);
}
else // If the mouse has moved between mouse down and mouse up
{
MouseDragged.Raise(this, args);
}
}
MouseUp.Raise(this, args);
_hasDoubleClicked = false;
_previousClickArgs = args;
}
}
public MouseClickEntityEventArgs(int x, int y, MouseButton mouseButton, bool justClicked, bool doubleClicked)
: base(x, y)
{
MouseButton = mouseButton;
JustClicked = justClicked;
DoubleClicked = doubleClicked;
}
internal override MouseButtonState GetButtonStateFromSystem(MouseButton mouseButton)
{
MouseButtonState mouseButtonState = MouseButtonState.Released;
// Security Mitigation: do not give out input state if the device is not active.
if(IsActive)
{
int virtualKeyCode = 0;
switch( mouseButton )
{
case MouseButton.Left:
virtualKeyCode = NativeMethods.VK_LBUTTON;
break;
case MouseButton.Right:
virtualKeyCode = NativeMethods.VK_RBUTTON;
break;
case MouseButton.Middle:
virtualKeyCode = NativeMethods.VK_MBUTTON;
break;
case MouseButton.XButton1:
virtualKeyCode = NativeMethods.VK_XBUTTON1;
break;
case MouseButton.XButton2:
virtualKeyCode = NativeMethods.VK_XBUTTON2;
break;
}
mouseButtonState = ( UnsafeNativeMethods.GetKeyState(virtualKeyCode) & 0x8000 ) != 0 ? MouseButtonState.Pressed : MouseButtonState.Released;
}
return mouseButtonState;
}
public CodeBoundMouse(Action a, MouseButton button, bool pressing = true, bool constant = false)
{
Lambda = a;
BoundMouseButton = button;
Press = pressing;
Constant = (pressing) && constant;
}
private void ProcessMouseButton(MouseButton mouseButton)
{
if(_actionEvaluator.ShouldButtonActionBeFired(mouseButton))
{
FireMouseAction(mouseButton);
}
}
protected void ntfyMouseDown(MouseButton btn, int x, int y)
{
if (onMouseDown != null)
{
onMouseDown.Invoke(btn, x, y);
}
}
protected void ntfyMouseMove(MouseButton btn, int x, int y)
{
if (onMouseMove != null)
{
onMouseMove.Invoke(btn, x, y);
}
}
/// <summary>
/// Handles the <see cref="Mouse.PreviewMouseDownEvent"/>.
/// </summary>
private static void HandlePreviewMouseDown(DependencyObject element, MouseDevice device, MouseButton button, ref RoutedEventData data)
{
if (button == MouseButton.Left)
{
((SliderBase)element).Focus();
}
}
public override void Reset()
{
button = MouseButton.Left;
sendEvent = null;
storeResult = null;
inUpdateOnly = true;
}
internal static bool TryClickOnBoundingRectangleCenter(
MouseButton button,
CruciatusElement element,
bool doubleClick)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
Point point;
if (!AutomationElementHelper.TryGetBoundingRectangleCenter(element.Instance, out point))
{
Logger.Debug("Element '{0}' have empty BoundingRectangle", element);
return false;
}
if (doubleClick)
{
CruciatusFactory.Mouse.DoubleClick(button, point.X, point.Y);
}
else
{
CruciatusFactory.Mouse.Click(button, point.X, point.Y);
}
Logger.Info(
"{0} on '{1}' element at ({2}, {3}) BoundingRectangle center",
doubleClick ? "DoubleClick" : "Click",
element,
point.X,
point.Y);
return true;
}
public GenericSelectTarget(IEnumerable<Actor> subjects, string order, string cursor, MouseButton button)
{
this.subjects = subjects;
this.order = order;
this.cursor = cursor;
expectedButton = button;
}
// eliminar esto
public void RaiseButtonClickEvent(Control source, MouseButton button, int index)
{
if (this.ButtonClick != null)
{
this.ButtonClick(source, new ToolClickEventArgs(button, this, index));
}
}
public GenericSelectTarget(IEnumerable<Actor> subjects, string order, string cursor, MouseButton button)
{
Subjects = subjects;
OrderName = order;
Cursor = cursor;
ExpectedButton = button;
}
public MouseHoldTrigger(Rectangle holdArea, float holdTime = DefaultHoldTime,
MouseButton button = MouseButton.Left)
{
HoldArea = holdArea;
HoldTime = holdTime;
Button = button;
}
public bool IsMouseButtonPressed(Player player, MouseButton button)
{
if (player.InputType != InputType.Mouse)
return false;
return Sources[player].IsMouseButtonPressed(button);
}
private void SetButtonStateTo(MouseButton button, SharpDX.Toolkit.Input.ButtonState state)
{
switch (button)
{
case MouseButton.None:
break;
case MouseButton.Left:
left = state;
break;
case MouseButton.Middle:
middle = state;
break;
case MouseButton.Right:
right = state;
break;
case MouseButton.XButton1:
xButton1 = state;
break;
case MouseButton.XButton2:
xButton2 = state;
break;
default:
throw new ArgumentOutOfRangeException("button");
}
}
// Event raised on mouse down in the ZoomAndPanControl
public static void MouseDown(object sender, MouseButtonEventArgs e,Panel p, ZoomAndPanControl z)
{
p.Focus();
Keyboard.Focus(p);
mouseButtonDown = e.ChangedButton;
origZoomAndPanControlMouseDownPoint = e.GetPosition(z);
origContentMouseDownPoint = e.GetPosition(p);
if ((Keyboard.Modifiers & ModifierKeys.Shift) != 0 &&
(e.ChangedButton == MouseButton.Left ||
e.ChangedButton == MouseButton.Right))
{
// Shift + left- or right-down initiates zooming mode.
mouseHandlingMode = MouseHandlingMode.Zooming;
}
else if (mouseButtonDown == MouseButton.Left)
{
// Just a plain old left-down initiates panning mode.
mouseHandlingMode = MouseHandlingMode.Panning;
}
if (mouseHandlingMode != MouseHandlingMode.None)
{
// Capture the mouse so that we eventually receive the mouse up event.
z.CaptureMouse();
e.Handled = true;
}
}
public MouseButtonEventArgs(RoutedEvent routedEvent, object originalSource, MouseDevice mouseDevice, int timestamp, Point absolutePosition, MouseButton changedButton, MouseButtonState buttonState, int clickCount)
: base(routedEvent, originalSource, mouseDevice, timestamp, absolutePosition)
{
this.ChangedButton = changedButton;
this.ButtonState = buttonState;
this.ClickCount = clickCount;
}
public override void MouseDown(MouseButton button, Vec2 pos)
{
base.MouseDown(button, pos);
foreach (var b in buttons)
if (b.Selected)
b.Action.Apply();
}
public override void OnMouseButtonPressed(MouseButton button, float x, float y)
{
var node = World.Find ("Sender");
if (node != null) {
node.GetComponent<MySender> ().Address = address;
}
}
/// <summary>
/// Get if mouse button was pressed on this frame.
/// </summary>
/// <param name="button">Mouse button to test.</param>
/// <returns>If mouse button was pressed this frame.</returns>
public bool MousePressed(MouseButton button = MouseButton.Left)
{
return(_input.MouseButtonPressed((UI.MouseButton)button));
}
/// <summary>
/// Creates new mouse button event data.
/// </summary>
/// <param name="x">The X coordinate for the event.</param>
/// <param name="y">The Y coordinate for the event.</param>
/// <param name="button">The mouse button for the event.</param>
/// <param name="isPressed">Whether the button was pressed or released.</param>
public MouseButtonEventArgs(int x, int y, MouseButton button, bool isPressed)
: base(x, y)
{
Button = button;
IsPressed = isPressed;
}
/// <summary>
/// Assign a mouse button to a Game key.
/// </summary>
/// <param name="mouseButton">Mouse button.</param>
/// <param name="gameKey">Game key.</param>
public void AssignMouseButtonToGameKey(MouseButton mouseButton, GameKeys gameKey)
{
_mouseKeysMap[mouseButton] = gameKey;
}
private void RaisePressedEvent(ListBox listBox, ListBoxItem item, MouseButton mouseButton)
{
_mouse.Click(listBox, item, mouseButton);
}
/// <summary>
/// Get if mouse button is currently down.
/// </summary>
/// <param name="button">Mouse button to test.</param>
/// <returns>If mouse button is down.</returns>
public bool IsMouseButtonDown(MouseButton button = MouseButton.Left)
{
return(_input.MouseButtonDown((UI.MouseButton)button));
}
static void widget_EventMouseButtonPressed(Widget _sender, int _left, int _top, MouseButton _id)
{
Gui.Instance.Log("TestApp", LogLevel.Info, "EventMouseButtonPressed _left=" + _left.ToString() + " _top=" + _top.ToString() + " _id=" + _id.ToString());
}
public void MouseDown(MouseButton button) => SetInputState(new InputEventArgs()
{
Type = InputEventType.MouseDown, Button = button
});
public void Use(MouseButton button, Action <MouseButton> onButtonUp)
{
m_buttonUpListeners[(int)button] = onButtonUp;
}
/// <summary> /// Gets the current state of the specified button /// </summary> /// <param name="mouseButton"> /// The mouse button to get the state of /// </param> /// <param name="mouseDevice"> /// The MouseDevice that is making the request /// </param> /// <returns> /// The state of the specified mouse button /// </returns> /// <remarks> /// This is the hook where the Input system (via the MouseDevice) can call back into /// the Stylus system when we are processing Stylus events instead of Mouse events /// </remarks> internal abstract MouseButtonState GetMouseButtonState(MouseButton mouseButton, MouseDevice mouseDevice);
public Clicked(Event e, MouseButton mouseButton)
{
this.e = e;
this.mouseButton = mouseButton;
}
public static bool GetMouseButton(GlfwWindowPtr window, MouseButton button)
{
return(GlfwDelegates.glfwGetMouseButton(window, button) != 0);
}
private void On_Dblclick_Backpack(AControl control, int x, int y, MouseButton button)
{
Container backpack = ((Mobile)m_sourceEntity).Backpack;
m_World.Interaction.DoubleClick(backpack);
}
protected MouseButtonEventManager(MouseButton button)
{
Button = button;
}
internal void MouseUp(MouseButton button)
{
leftDown = button.HasFlag(MouseButton.Left);
rightDown = button.HasFlag(MouseButton.Right);
}
private void HandleMessage(string message)
{
var msg = JSONNode.Parse(message);
switch ((string)msg["type"])
{
case "mouseDown":
case "mouseUp": {
int button = msg["button"];
MouseButton flag = 0;
if (button == 0)
{
flag = MouseButton.Left;
}
else if (button == 1)
{
flag = MouseButton.Right;
}
else if (button == 2)
{
flag = MouseButton.Middle;
}
if (msg["type"] == "mouseDown")
{
MouseButtons |= flag;
}
else
{
MouseButtons &= ~flag;
}
break;
}
case "mouseMove": {
var screenPos = new Vector2(msg["x"], msg["y"]);
screenPos.x = screenPos.x / browser.Size.x;
screenPos.y = screenPos.y / browser.Size.y;
MousePosition = screenPos;
//Debug.Log("mouse now at " + screenPos);
break;
}
case "mouseFocus":
MouseHasFocus = msg["focus"];
break;
case "keyboardFocus":
KeyboardHasFocus = msg["focus"];
break;
case "mouseScroll": {
const float mult = 1 / 3f;
MouseScroll += new Vector2(msg["x"], msg["y"]) * mult;
break;
}
case "keyDown":
case "keyUp": {
var ev = new Event();
ev.type = msg["type"] == "keyDown" ? EventType.KeyDown : EventType.KeyUp;
ev.character = (char)0;
ev.keyCode = KeyMappings.GetUnityKeyCode(msg["code"]);
SetMods(ev);
//Debug.Log("Convert wkc " + (int)msg["code"] + " to ukc " + ev.keyCode);
KeyEvents.Add(ev);
break;
}
case "keyPress": {
string characters = msg["characters"];
foreach (char c in characters)
{
var ev = new Event();
ev.type = EventType.KeyDown;
SetMods(ev);
ev.character = c;
ev.keyCode = 0;
KeyEvents.Add(ev);
}
break;
}
case "resize":
//on OS X (editor at least), resizing hangs the update loop, so we suddenly end up with a bajillion resize
//messages we were unable to process. Just record it here and when we've processed everything we'll resize
delayedResize.x = msg["w"];
delayedResize.y = msg["h"];
break;
case "close":
Destroy(gameObject);
break;
default:
Debug.LogWarning("Unknown window event: " + msg.AsJSON);
break;
}
}
public bool IsButtonUp(MouseButton button)
{
return(!IsButtonDown(button));
}
public void NotifyListItemClicked(NavigateMenuItem item, MouseButton mouseButton)
{
if (mouseButton == MouseButton.Left && Mouse.Captured != this)
{
Mouse.Capture(this, CaptureMode.SubTree);
//base.SetInitialMousePosition();
}
if (!item.IsSelected)
{
item.SetCurrentValue(Selector.IsSelectedProperty, true);
}
else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
{
item.SetCurrentValue(Selector.IsSelectedProperty, false);
}
//this.UpdateAnchorAndActionItem(base.ItemInfoFromContainer(item));
return;
//switch (this.SelectionMode)
//{
// case SelectionMode.Single:
// if (!item.IsSelected)
// {
// item.SetCurrentValue(Selector.IsSelectedProperty, true);
// }
// else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
// {
// item.SetCurrentValue(Selector.IsSelectedProperty, false);
// }
// //this.UpdateAnchorAndActionItem(base.ItemInfoFromContainer(item));
// return;
//case SelectionMode.Multiple:
// this.MakeToggleSelection(item);
// return;
//case SelectionMode.Extended:
// if (mouseButton != MouseButton.Left)
// {
// if (mouseButton == MouseButton.Right && (Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == ModifierKeys.None)
// {
// if (item.IsSelected)
// {
// this.UpdateAnchorAndActionItem(base.ItemInfoFromContainer(item));
// return;
// }
// this.MakeSingleSelection(item);
// }
// return;
// }
// if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == (ModifierKeys.Control | ModifierKeys.Shift))
// {
// this.MakeAnchorSelection(item, false);
// return;
// }
// if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
// {
// this.MakeToggleSelection(item);
// return;
// }
// if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
// {
// this.MakeAnchorSelection(item, true);
// return;
// }
// this.MakeSingleSelection(item);
// return;
//default:
// return;
//}
}
public GuardOrderGenerator(IEnumerable <Actor> subjects, string order, string cursor, MouseButton button)
: base(subjects, order, cursor, button)
{
}
public virtual bool HandlesMouseUp(int mouseX, int mouseY, MouseButton button)
{
return(false);
}
public static void Click(MouseButton button)
{
Down(button);
Up(button);
}
public bool IsButtonDown(MouseButton button)
{
return(mouseButtons[(int)button]);
}