private void inkPanel_MouseUp(object sender, MouseButtonEventArgs e)
{
DrawCommand command = new DrawCommand(currentShape, inkPanel);
undoRedo.InsertComand(command);
if (!btnEraser.IsChecked.Value)
{
draw(e);
}
else if (btnEraser.IsChecked.Value)
{
currentTool = ToolType.Ellipse;
draw(e);
}
if (e.LeftButton == MouseButtonState.Pressed && !btnEraser.IsChecked.Value)
{
inkPanel.Children.Remove(currentShape);
}
/*else if (e.LeftButton == MouseButtonState.Released && previousMouseEvent == MouseButtonState.Pressed)
* {*/
//}
previousMouseEvent = e.LeftButton;
}
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 override void Deserialize(NetworkReader reader)
{
base.Deserialize(reader);
ProcessorObject = reader.ReadUInt32();
TargetVector = reader.ReadVector2();
MouseButtonState = reader.ReadBoolean() ? MouseButtonState.PRESS : MouseButtonState.HOLD;
}
/// <summary>
///
/// </summary>
/// <param name="performer">The gameobject of the player performing the aimed interaction</param>
/// <param name="handObject">Object in the player's active hand. Null if player's hand is empty.</param>
/// <param name="handSlot">slot of the active hand</param>
/// <param name="buttonState">state of the mouse button, indicating whether it is being initiated
/// or ending.</param>
/// <param name="targetVector">vector pointing from shooter to the spot they are targeting - should NOT be normalized. Set to
/// Vector2.zero if aiming at self.</param>
private AimApply(GameObject performer, GameObject handObject, ItemSlot handSlot, MouseButtonState buttonState, Vector2 targetVector, Intent intent) :
base(performer, handObject, intent)
{
this.targetVector = targetVector;
this.handSlot = handSlot;
this.mouseButtonState = buttonState;
}
public static void SimulateMouseDeviceAction(MouseButton button, MouseButtonState state, int x, int y)
{
var inputs = new List <WinAPI.USER32.INPUT>();
if (button == MouseButton.None)
{
inputs.Add(
new WinAPI.USER32.INPUT {
type = WinAPI.USER32.INPUT_TYPE.INPUT_MOUSE,
mi =
{
dx = x,
dy = y,
dwFlags = WinAPI.USER32.MOUSEEVENTF.MOVE_NOCOALESCE
}
}
);
}
else
{
WinAPI.USER32.MOUSEEVENTF buttonFlag;
switch (button)
{
case MouseButton.Left:
buttonFlag = state == MouseButtonState.Down ? WinAPI.USER32.MOUSEEVENTF.LEFTDOWN : WinAPI.USER32.MOUSEEVENTF.LEFTUP;
break;
case MouseButton.Middle:
buttonFlag = state == MouseButtonState.Down ? WinAPI.USER32.MOUSEEVENTF.MIDDLEDOWN : WinAPI.USER32.MOUSEEVENTF.MIDDLEUP;
break;
case MouseButton.Right:
buttonFlag = state == MouseButtonState.Down ? WinAPI.USER32.MOUSEEVENTF.RIGHTDOWN : WinAPI.USER32.MOUSEEVENTF.RIGHTUP;
break;
default:
buttonFlag = 0;
break;
}
inputs.Add(
new WinAPI.USER32.INPUT {
type = WinAPI.USER32.INPUT_TYPE.INPUT_MOUSE,
mi =
{
dx = x,
dy = y,
dwFlags = WinAPI.USER32.MOUSEEVENTF.ABSOLUTE | buttonFlag
}
}
);
}
if (WinAPI.USER32.SendInput((uint)inputs.Count, inputs.ToArray(), WinAPI.USER32.INPUT.Size) == 0)
{
throw new Exception("Failed to emulate mouse event");
}
}
private bool CheckAimApply(MouseButtonState buttonState)
{
ChangeDirection();
//currently there is nothing for ghosts to interact with, they only can change facing
if (PlayerManager.LocalPlayerScript.IsGhost)
{
return(false);
}
//can't do anything if we have no item in hand
var handObj = UIManager.Hands.CurrentSlot.Item;
if (handObj == null)
{
triggeredAimApply = null;
secondsSinceLastAimApplyTrigger = 0;
return(false);
}
var aimApplyInfo = AimApply.ByLocalPlayer(buttonState);
if (buttonState == MouseButtonState.PRESS)
{
//it's being clicked down
triggeredAimApply = null;
//Checks for aim apply interactions which can trigger
foreach (var aimApply in handObj.GetComponents <IInteractable <AimApply> >())
{
var interacted = aimApply.Interact(aimApplyInfo);
if (interacted)
{
triggeredAimApply = aimApply;
secondsSinceLastAimApplyTrigger = 0;
return(true);
}
}
}
else
{
//it's being held
//if we are already triggering an AimApply, keep triggering it based on the AimApplyInterval
if (triggeredAimApply != null)
{
secondsSinceLastAimApplyTrigger += Time.deltaTime;
if (secondsSinceLastAimApplyTrigger > AimApplyInterval)
{
if (triggeredAimApply.Interact(aimApplyInfo))
{
//only reset timer if it was actually triggered
secondsSinceLastAimApplyTrigger = 0;
}
}
//no matter what the result, we keep trying to trigger it until mouse is released.
return(true);
}
}
return(false);
}
public void Update(MouseButtonState buttonState, Vector2 mousePos, PlatformCharacter shooter, List <PlatformObject> allObjects, List <Projectile> projectiles)
{
if (buttonState == null)
{
return;
}
if (buttonState.justPressed)
{
foreach (PlatformObject p in allObjects)
{
if (p is ChemBlock && p.bounds.Contains(mousePos))
{
clicked = (ChemBlock)(p as ChemBlock).GetPrimaryBlock();
clickedOffset = mousePos - clicked.pos;
break;
}
}
}
else if (buttonState.justReleased)
{
clicked = null;
}
if (clicked != null)
{
Vector2 offset = mousePos - (clicked.pos + clickedOffset);
clicked.velocity = offset;
}
}
/// <summary>
/// Creates a move according to button press, and player role
/// </summary>
/// <param name="message"></param>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
protected Move GetMove(string message, MouseButtonState left, MouseButtonState right)
{
if (message == null)
{
return(null);
}
string[] vars = message.Split(';');
Move move = new Move
{
X = Int32.Parse(vars[0]),
Y = Int32.Parse(vars[1])
};
if (left == MouseButtonState.Pressed)
{
//Bomb cant get left clicked again
if (vars.Length > 2)
{
return(null);
}
move.Type = (role == MoveSet.MineSetter) ? MoveType.Set : MoveType.Reveal;
}
else if (right == MouseButtonState.Pressed)
{
move.Type = (role == MoveSet.MineSetter) ? MoveType.Unset : MoveType.Mark;
}
else
{
return(null);
}
return(move);
}
public void Update(MouseButtonState buttonState, Vector2 mousePos, PlatformCharacter shooter, List <PlatformObject> allObjects, List <Projectile> projectiles)
{
if (buttonState != null && buttonState.isDown)
{
shooter.jetting = true;
}
}
public MouseState(Point position, MouseButtonState leftButton, MouseButtonState rightButton, MouseButtonState middleButton, MouseButtonState xButton1Button, MouseButtonState xButton2Button) : this(NoesisGUI_PINVOKE.new_MouseState__SWIG_1(ref position, (int)leftButton, (int)rightButton, (int)middleButton, (int)xButton1Button, (int)xButton2Button), true)
{
if (NoesisGUI_PINVOKE.SWIGPendingException.Pending)
{
throw NoesisGUI_PINVOKE.SWIGPendingException.Retrieve();
}
}
public void Update()
{
// Determine the current mouse state.
var currentMouseState = new MouseButtonState();
// Project the screen location of the mouse to world coordinates
var mouseEvent = new MouseEvent();
var mousePosition2d = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
mouseEvent.GlobalCoordinates = ScreenToGlobal(mousePosition2d);
mouseEvent.ScreenCoordinates = mousePosition2d;
for(int ii = 0; ii < 3; ii++)
{
var curButtonState = currentMouseState.Buttons[ii];
if (previousMouseState != null)
{
var prevButtonState = this.previousMouseState.Buttons[ii];
mouseEvent.MouseButton = (MouseButton)ii;
if (curButtonState == ButtonState.Pressed && prevButtonState == ButtonState.Released)
{
this.mouseHandler.MousePressed(mouseEvent);
}
if (curButtonState == ButtonState.Released && prevButtonState == ButtonState.Pressed)
{
this.mouseHandler.MouseReleased(mouseEvent);
this.mouseHandler.MouseClicked(mouseEvent);
}
}
}
previousMouseState = currentMouseState;
}
public MouseWheelEventArgs(object source, RoutedEvent routedEvent, Point rawPosition,
MouseButtonState leftButton, MouseButtonState middleButton,
MouseButtonState rightButton, int delta)
: base(source, routedEvent, rawPosition, leftButton, middleButton, rightButton)
{
Delta = delta;
}
public void Update(GameTime time)
{
MouseState state = Mouse.GetState();
this.wheelTurns = state.ScrollWheelValue - this.lastState.ScrollWheelValue;
this.wheelTurnedUp = FezButtonStateExtensions.NextState(this.wheelTurnedUp, this.wheelTurns > 0);
this.wheelTurnedDown = FezButtonStateExtensions.NextState(this.wheelTurnedDown, this.wheelTurns < 0);
if (this.renderPanelHandle != this.parentFormHandle)
{
state = Mouse.GetState();
}
this.movement = new Point(state.X - this.position.X, state.Y - this.position.Y);
this.position = new Point(state.X, state.Y);
if (state != this.lastState)
{
bool hasMoved = this.movement.X != 0 || this.movement.Y != 0;
this.leftButton = this.DeduceMouseButtonState(this.leftButton, this.lastState.LeftButton, state.LeftButton, hasMoved);
this.middleButton = this.DeduceMouseButtonState(this.middleButton, this.lastState.MiddleButton, state.MiddleButton, hasMoved);
this.rightButton = this.DeduceMouseButtonState(this.rightButton, this.lastState.RightButton, state.RightButton, hasMoved);
this.lastState = state;
}
else
{
this.ResetButton(ref this.leftButton);
this.ResetButton(ref this.middleButton);
this.ResetButton(ref this.rightButton);
}
}
private void TryProcessDrag(MouseEventArgs e, MouseButtonState state, VimKey vimKey)
{
if (state == MouseButtonState.Pressed)
{
e.Handled = TryProcess(vimKey);
}
}
private bool CheckAimApply(MouseButtonState buttonState)
{
ChangeDirection();
//currently there is nothing for ghosts to interact with, they only can change facing
if (PlayerManager.LocalPlayerScript.IsGhost)
{
return(false);
}
//can't do anything if we have no item in hand
var handObj = UIManager.Hands.CurrentSlot.Item;
if (handObj == null)
{
triggeredAimApply = null;
secondsSinceLastAimApplyTrigger = 0;
return(false);
}
var aimApplyInfo = AimApply.ByLocalPlayer(buttonState);
if (buttonState == MouseButtonState.PRESS)
{
//it's being clicked down
triggeredAimApply = null;
//Checks for aim apply interactions which can trigger
var comps = handObj.GetComponents <IBaseInteractable <AimApply> >()
.Where(mb => mb != null && (mb as MonoBehaviour).enabled);
var triggered = InteractionUtils.ClientCheckAndTrigger(comps, aimApplyInfo);
if (triggered != null)
{
triggeredAimApply = triggered;
secondsSinceLastAimApplyTrigger = 0;
return(true);
}
}
else
{
//it's being held
//if we are already triggering an AimApply, keep triggering it based on the AimApplyInterval
if (triggeredAimApply != null)
{
secondsSinceLastAimApplyTrigger += Time.deltaTime;
if (secondsSinceLastAimApplyTrigger > AimApplyInterval)
{
if (triggeredAimApply.CheckInteract(aimApplyInfo, NetworkSide.Client))
{
//only reset timer if it was actually triggered
secondsSinceLastAimApplyTrigger = 0;
InteractionUtils.RequestInteract(aimApplyInfo, triggeredAimApply);
}
}
//no matter what the result, we keep trying to trigger it until mouse is released.
return(true);
}
}
return(false);
}
private void inkCanvas_MouseMove(Object sender, MouseEventArgs e)
{
tb.Content = (e.GetPosition(null).X - 55) + ";" + (e.GetPosition(null).Y - 18);
if (yeep)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
InkCan.Children.Remove(currentShape);
switch (currentTool)
{
case ToolType.Line:
drawLine(e);
break;
case ToolType.Rect:
drawRect(e);
break;
case ToolType.Ellipse:
drawEllipse(e);
break;
case ToolType.RectSome:
drawRectSome(e);
break;
}
}
previousMouseEvent = e.LeftButton;
mb_save = false;
}
}
public bool OnMouseMove(MouseButtonState leftButton, Point location)
{
if (leftButton == MouseButtonState.Pressed)
{
if (LastDragPoint == InvalidDragPoint)
{
LastDragPoint = location;
}
if (GridManager.HoverInfo.HitTest != GridManagerHitTest.None)
{
DoSizing(location);
}
else if (SelectedArea == CropArea.DragArea)
{
DoDrag(location);
}
else if (SelectedArea != CropArea.None)
{
MakeRotation(location);
}
return(true);
}
else if (GridManager.OnMouseMove(location))
{
SelectedArea = CropArea.None;
UpdateCursor();
return(true);
}
SelectedArea = CalcHitInfo(location);
UpdateCursor();
return(true);
}
internal MouseMoveEventArgs(Vector2 position, Vector2 delta, MouseButtonState buttonState)
{
Position = position;
Delta = delta;
ButtonState = buttonState;
}
private void TryProcessDrag(MouseEventArgs e, MouseButtonState state, VimKey vimKey)
{
if (state == MouseButtonState.Pressed)
{
e.Handled = TryProcess(vimKey);
}
}
void ActionMove(MouseButtonState e, Point position)
{
if (e == MouseButtonState.Pressed)
{
if (movebtn)
{
btnactv.Margin = new Thickness(position.X - btnactv.Width / 2, position.Y - btnactv.Height / 2, 0, 0);
FecharMenu();
}
else
if (desenhando)
{
if (action == Enumaction.quadrado)
{
paintboard.Strokes[paintboard.Strokes.Count - 1] = NewRectangle(initialP.X, initialP.Y, position.X - initialP.X, position.Y - initialP.Y);
}
if (action == Enumaction.circulo)
{
double distancia = Math.Sqrt(Math.Pow(initialP.X - position.X, 2) + Math.Pow(initialP.Y - position.Y, 2));
paintboard.Strokes[paintboard.Strokes.Count - 1] = NewCircle(initialP.X, initialP.Y, distancia);
}
if (action == Enumaction.linha)
{
paintboard.Strokes[paintboard.Strokes.Count - 1] = NewLine(initialP.X, initialP.Y, position.X, position.Y);
}
}
}
}
private void AddShape(MouseButtonState state, Point mousePos)
{
int vertices = shapeDeclaration.VerticesPosition.Count;
if (vertices == 1)
{
shapeDeclaration.VerticesPosition.Add(shapeDeclaration.VerticesPosition[0] + Vector2.One);
}
if (vertices != 0)
{
Shapes.Add(
new FixedBoundsShape(
shapeDeclaration.VerticesPosition,
shapeDeclaration.ViewportOffset.X,
shapeDeclaration.ViewportOffset.Y,
(int)ActualWidth,
(int)ActualHeight,
Color.Black,
graphicsDevice));
ShapeAdded?.Invoke(this, EventArgs.Empty);
}
trackShape = InitializeShape;
processedShape.Reset();
GraphicsControl.Invalidate();
}
public void Reset()
{
State = MouseButtonState.Released;
Flags = DDMouseButtonFlags.None;
TimeStamp = new DateTime();
DragRefPoint = new Point();
}
public override void Deserialize(NetworkReader reader)
{
base.Deserialize(reader);
ComponentType = componentIDToComponentType[reader.ReadUInt16()];
InteractionType = interactionIDToInteractionType[reader.ReadByte()];
ProcessorObject = reader.ReadUInt32();
if (InteractionType == typeof(PositionalHandApply))
{
TargetObject = reader.ReadUInt32();
TargetVector = reader.ReadVector2();
}
else if (InteractionType == typeof(HandApply))
{
TargetObject = reader.ReadUInt32();
TargetBodyPart = (BodyPartType)reader.ReadUInt32();
}
else if (InteractionType == typeof(AimApply))
{
TargetVector = reader.ReadVector2();
MouseButtonState = reader.ReadBoolean() ? MouseButtonState.PRESS : MouseButtonState.HOLD;
}
else if (InteractionType == typeof(MouseDrop))
{
TargetObject = reader.ReadUInt32();
UsedObject = reader.ReadUInt32();
}
else if (InteractionType == typeof(InventoryApply))
{
UsedObject = reader.ReadUInt32();
Storage = reader.ReadUInt32();
SlotIndex = reader.ReadInt32();
NamedSlot = (NamedSlot)reader.ReadInt32();
}
}
protected override bool Process(MouseButton button, MouseButtonState state, MouseInformation info)
{
var inActivationArea = 0 < info.X && info.X < SystemParameters.PrimaryScreenWidth * 0.1;
if (button == MouseButton.Left)
{
if (state == MouseButtonState.Released)
{
isDown = false;
}
if (state == MouseButtonState.Pressed && inActivationArea)
{
isDown = true;
Task.Delay(ACTIVATION_INTERVAL).ContinueWith(async _ =>
{
for (var t = 0; t < 4; t++)
{
if (WasActivated())
{
break;
}
await Task.Delay(ACTIVATION_INTERVAL);
}
});
}
}
return(false);
}
private void Screener_MouseUp(MouseButtonState mouseState)
{
if (mouseState == MouseButtonState.Released && _isMouseDown)
{
WindowState = WindowState.Minimized;
if (_width >= MinImgSize || _height >= MinImgSize)
{
var picture = SearchHelper.CaptureScreen(GetMin(_startX, _curX), GetMin(_startY, _curY), _width, _height, _winHandle);
if (picture != null)
{
Picture = picture;
Rectangle = new Rectangle((int)GetMin(_startX, _curX), (int)GetMin(_startY, _curY), (int)_width, (int)_height);
}
}
else
{
Picture = PixelTraceCapture((int)_curX, (int)_curY);
}
_curX = _curY = _startX = _startY = 0;
_isMouseDown = false;
if (!DialogResult.HasValue)
{
DialogResult = Picture != null;
Close();
}
}
}
private void InImage_MouseMove(object sender, MouseEventArgs e)
{
MouseButtonState mb = e.LeftButton;
MouseButtonState rb = e.RightButton;
if (MouseButtonState.Pressed == mb)
{
Point p = e.GetPosition(InImage);
int posX = (int)p.X;
int posY = (int)p.Y;
if ((posX >= 2) && (posY >= 2) && (posX < inBitmap.Width - 2) && (posY < inBitmap.Height - 2))
{
int skala = (int)inBitmap.Width / szerokosc;
inBitmap.FillRectangle(posX - 2, posY - 2, posX + 2, posY + 2, Color.FromRgb(0, 0, 0));
zapalonePiksele[posX / skala + (posY / skala) * szerokosc] = 1;
}
}
else if (MouseButtonState.Pressed == rb)
{
inBitmap.Clear(Color.FromRgb(255, 255, 255));
Parallel.For(0, wysokosc * szerokosc, i => zapalonePiksele[i] = 0);
}
InImage.Source = inBitmap;
}
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;
}
private void draw(MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
switch (currentTool)
{
case ToolType.Line:
drawLine(e);
break;
case ToolType.Ellipse:
drawEllipse(e, false);
break;
case ToolType.Rectangle:
drawRectangle(e);
break;
case ToolType.Triangle:
drawTriangle(e);
break;
default:
break;
}
}
else if (e.LeftButton == MouseButtonState.Released && previousMouseEvent == MouseButtonState.Pressed)
{
DrawCommand command = new DrawCommand(currentShape, inkPanel);
undoRedo.InsertComand(command);
}
previousMouseEvent = e.LeftButton;
}
public void Paint(MouseButtonState state, Point mousePos)
{
//if (graphicsDevice.Viewport.Bounds.Contains(mousePos))
//{
trackShape(state, mousePos);
//}
}
/// <summary>
/// Get button state.
/// </summary>
/// <param name="mouseButton">The mouse button to check.</param>
/// <returns>MouseButtonState instance.</returns>
private static MouseButtonState GetButtonState(MouseButton mouseButton)
{
MouseButtonState mouseButtonState = MouseButtonState.Released;
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 = (NativeMethods.GetKeyState(virtualKeyCode) & 0x8000) != 0 ? MouseButtonState.Pressed : MouseButtonState.Released;
return(mouseButtonState);
}
public void OnMouseButton(Vector3 mousePosition, StateInformation stateInformation)
{
IPlacedObject selectedObject = stateInformation.selectedObject;
MouseButtonState leftMouseButtonState = leftMouseButton.GetState();
// moving the Object
if (leftMouseButtonState == MouseButtonState.DOWN)
{
selectedObject.SetAllCollidersStatus(false);
}
else if (leftMouseButtonState == MouseButtonState.PRESSED)
{
selectedObject.RemoveWeaponFromPerson();
//selectedObject.SetAllCollidersStatus(false);
objectEditingModule.MoveObject(selectedObject, mousePosition);
}
else if (leftMouseButtonState == MouseButtonState.UP)
{
selectedObject.SetAllCollidersStatus(true);
}
// Giving an Enemy a Weapon
if (leftMouseButtonState == MouseButtonState.UP && lastLeftMouseButtonState == MouseButtonState.PRESSED)
{
IPlacedObject hoveredObject = stateInformation.hoveredObject;
bool objectCanBeGiven = objectInformationModule.CheckIfWeaponCanBeGivenToPerson(selectedObject, hoveredObject);
if (objectCanBeGiven)
{
// give selectedObject to hoveredObject
objectEditingModule.GiveWeaponToPerson(selectedObject, hoveredObject);
}
}
lastLeftMouseButtonState = leftMouseButtonState;
}
private void HandleMouseEvent(
MouseButtonState previousMouseButtonState,
MouseEventFlags eventFlags,
MouseButtonState currentButtonState,
COORD mousePosition)
{
if (eventFlags.HasFlag(MouseEventFlags.MOUSE_MOVED) &&
currentButtonState == MouseButtonState.FROM_LEFT_1ST_BUTTON_PRESSED)
{
var elementHit = _display.HitTest(mousePosition.X, mousePosition.Y);
if (elementHit == _battleField)
{
_battleField.SelectPositionNear(mousePosition.X, mousePosition.Y);
}
}
if (eventFlags.HasFlag(MouseEventFlags.MOUSE_BUTTON_STATE_CHANGED))
{
if (currentButtonState == MouseButtonState.ALL_RELEASED &&
previousMouseButtonState == MouseButtonState.FROM_LEFT_1ST_BUTTON_PRESSED)
{
//left button clicked
var elementHit = _display.HitTest(mousePosition.X, mousePosition.Y);
if (elementHit == _battleField)
{
_battleField.SelectPositionNear(mousePosition.X, mousePosition.Y);
if (_battleField.SelectedPosition != null)
{
ConfirmSelectedPosition();
}
}
}
}
}
/// <summary>
/// Create an AimAPply for the local player aiming at the current mouse position with the item in their
/// active hand slot.
/// </summary>
/// <param name="buttonState">state of mouse (initial click vs. being held after a click)</param>
/// <returns></returns>
public static AimApply ByLocalPlayer(MouseButtonState buttonState)
{
//Check for self aim
if (PLAYER_LAYER_MASK == -1)
{
PLAYER_LAYER_MASK = LayerMask.GetMask("Players");
}
var InternaltargetPosition = MouseUtils.MouseToWorldPos().ToLocal(PlayerManager.LocalPlayer.RegisterTile().Matrix).To2();
//check for self aim if target vector is sufficiently small so we can avoid raycast
var selfAim = false;
var targetVector = (Vector2)MouseUtils.MouseToWorldPos() -
(Vector2)PlayerManager.LocalPlayer.transform.position;
if (targetVector.magnitude < 0.6)
{
selfAim = MouseUtils.GetOrderedObjectsUnderMouse(PLAYER_LAYER_MASK,
go => go == PlayerManager.LocalPlayer).Any();
}
return(new AimApply(PlayerManager.LocalPlayer, PlayerManager.LocalPlayerScript.DynamicItemStorage.GetActiveHandSlot().ItemObject,
PlayerManager.LocalPlayerScript.DynamicItemStorage.GetActiveHandSlot(),
buttonState,
selfAim ? PlayerManager.LocalPlayer.transform.localPosition.To2() : InternaltargetPosition, UIManager.DamageZone, UIManager.CurrentIntent, PlayerManager.LocalPlayer.transform.localPosition.To2()));
}
protected override void OnMouseDown(MouseButtonEventArgs e)
{
base.OnMouseDown(e);
this.isMouseDown = true;
Point pt = e.GetPosition(this);
MouseButtonState mb = e.RightButton;
MouseButtonState mbl = e.LeftButton;
if (mb == MouseButtonState.Pressed)
{
mbpressed = Constants.Mousebutton.Right;
}
if (mbl == MouseButtonState.Pressed)
{
mbpressed = Constants.Mousebutton.Left;
}
int x = (int)((pt.X) / Constants.CELL_SIZE);
int y = (int)((pt.Y) / Constants.CELL_SIZE);
if (null != this.Click)
{
Click(this, new ClickEventArgs(x, y, mbpressed));
}
}
public MouseButtonEventArgs(object source, RoutedEvent routedEvent, Point rawPosition,
MouseButtonState leftButton, MouseButtonState middleButton,
MouseButtonState rightButton,
MouseButton button, int clickCount = 1)
: base(source, routedEvent, rawPosition, leftButton, middleButton, rightButton) {
this.button = button;
this.clickCount = clickCount;
}
public Visual3DClickedEventArgs(Visual3D visual, MouseButtonState left, MouseButtonState right, bool hasMoved, Point position)
{
_Visual = visual;
_LeftButton = left;
_RightButton = right;
_HasMoved = hasMoved;
_MousePosition = position;
}
/// <summary>
/// Default Constructor.
/// </summary>
/// <param name="button">The MouseButton being pressed.</param>
/// <param name="clicks">Click counter.</param>
/// <param name="x">X Axis position.</param>
/// <param name="y">Y Axis position</param>
/// <param name="delta">Up or down scroll flow.</param>
/// <param name="isUp">True if it's a mouse up event</param>
public CustomMouseEventArgs(MouseButton button, int clicks, int x, int y, int delta, MouseButtonState state = MouseButtonState.Pressed)
{
Button = button;
Clicks = clicks;
PosX = x;
PosY = y;
Delta = delta;
State = state;
}
internal MouseButtonEventArgs(RoutedEvent routedEvent,
MouseButton changedButton,
MouseButtonState buttonState,
int clickCount,
System.Windows.Input.MouseButtonEventArgs args)
: base(routedEvent)
{
this.ChangedButton = changedButton;
this.ButtonState = buttonState;
this.ClickCount = clickCount;
this.originalMouseButtonEventArgs = args;
}
private MouseButtonState DeduceMouseButtonState(MouseButtonState lastMouseButtonState, ButtonState lastButtonState, ButtonState buttonState, bool hasMoved)
{
if (lastButtonState == ButtonState.Released && buttonState == ButtonState.Released)
return new MouseButtonState(MouseButtonStates.Idle);
if (lastButtonState == ButtonState.Released && buttonState == ButtonState.Pressed)
return new MouseButtonState(MouseButtonStates.Pressed, new MouseDragState(this.position, this.position));
if (lastButtonState == ButtonState.Pressed && buttonState == ButtonState.Pressed)
{
if (!hasMoved)
return lastMouseButtonState;
if (!lastMouseButtonState.DragState.PreDrag || Math.Abs(this.position.X - lastMouseButtonState.DragState.Start.X) <= 3 && Math.Abs(this.position.Y - lastMouseButtonState.DragState.Start.Y) <= 3)
return new MouseButtonState(MouseButtonStates.Down, new MouseDragState(lastMouseButtonState.DragState.Start, this.position, true));
if (lastMouseButtonState.State == MouseButtonStates.DragStarted || lastMouseButtonState.State == MouseButtonStates.Dragging)
return new MouseButtonState(MouseButtonStates.Dragging, new MouseDragState(lastMouseButtonState.DragState.Start, this.position, true));
else
return new MouseButtonState(MouseButtonStates.DragStarted, new MouseDragState(lastMouseButtonState.DragState.Start, this.position, true));
}
else
{
if (lastButtonState != ButtonState.Pressed || buttonState != ButtonState.Released)
throw new InvalidOperationException();
if ((lastMouseButtonState.State == MouseButtonStates.Pressed || lastMouseButtonState.State == MouseButtonStates.Down) && !hasMoved)
return new MouseButtonState(MouseButtonStates.Clicked);
else
return new MouseButtonState(MouseButtonStates.DragEnded);
}
}
public void Update(GameTime time)
{
MouseState state = Mouse.GetState();
this.wheelTurns = state.ScrollWheelValue - this.lastState.ScrollWheelValue;
this.wheelTurnedUp = FezButtonStateExtensions.NextState(this.wheelTurnedUp, this.wheelTurns > 0);
this.wheelTurnedDown = FezButtonStateExtensions.NextState(this.wheelTurnedDown, this.wheelTurns < 0);
if (this.renderPanelHandle != this.parentFormHandle)
state = Mouse.GetState();
this.movement = new Point(state.X - this.position.X, state.Y - this.position.Y);
this.position = new Point(state.X, state.Y);
if (state != this.lastState)
{
bool hasMoved = this.movement.X != 0 || this.movement.Y != 0;
this.leftButton = this.DeduceMouseButtonState(this.leftButton, this.lastState.LeftButton, state.LeftButton, hasMoved);
this.middleButton = this.DeduceMouseButtonState(this.middleButton, this.lastState.MiddleButton, state.MiddleButton, hasMoved);
this.rightButton = this.DeduceMouseButtonState(this.rightButton, this.lastState.RightButton, state.RightButton, hasMoved);
this.lastState = state;
}
else
{
this.ResetButton(ref this.leftButton);
this.ResetButton(ref this.middleButton);
this.ResetButton(ref this.rightButton);
}
}
public RawMouseButtonEventArgs(MouseButton button, MouseButtonState buttonState, Point position, int timestamp)
: base(position, timestamp)
{
this.Button = button;
this.ButtonState = buttonState;
}
public MouseEventArgs(object source, RoutedEvent routedEvent, Point rawPosition,
MouseButtonState leftButton, MouseButtonState middleButton, MouseButtonState rightButton)
: base(source, routedEvent) {
//
this.rawPosition = rawPosition;
this.LeftButton = leftButton;
this.MiddleButton = middleButton;
this.RightButton = rightButton;
}
/// <summary>
/// ボタンの押し状態をセットする関数
/// </summary>
/// <param name="mButtonState">押し状態</param>
internal void SetState(MouseButtonState mButtonState)
{
mouseButtonState=mButtonState;
}
private void OnButtonDown(object sender, MouseButtonEventArgs e)
{
var pos = ScreenPosition;
_updateActions.Add(()=>ButtonDown?.Invoke(new Point((int)pos.X, (int)pos.Y), (int)e.ChangedButton));
_left = e.LeftButton;
_right = e.RightButton;
_middle = e.MiddleButton;
}
/// <summary>
/// 押し状態とホイール回転状態をセットする関数
/// </summary>
/// <param name="mbuttonstate">押し状態</param>
/// <param name="rot">回転度合い</param>
internal void SetState(MouseButtonState mbuttonstate,double rot)
{
rotation = rot;
mouseButtonState = mbuttonstate;
}
public void ParseInputEvent(INPUT_RECORD inputRecord, Control rootElement) {
if (inputRecord.EventType == EventType.MOUSE_EVENT) {
MOUSE_EVENT_RECORD mouseEvent = inputRecord.MouseEvent;
if (mouseEvent.dwEventFlags != MouseEventFlags.PRESSED_OR_RELEASED &&
mouseEvent.dwEventFlags != MouseEventFlags.MOUSE_MOVED &&
mouseEvent.dwEventFlags != MouseEventFlags.DOUBLE_CLICK &&
mouseEvent.dwEventFlags != MouseEventFlags.MOUSE_WHEELED &&
mouseEvent.dwEventFlags != MouseEventFlags.MOUSE_HWHEELED) {
//
throw new InvalidOperationException("Flags combination in mouse event was not expected.");
}
Point rawPosition;
if (mouseEvent.dwEventFlags == MouseEventFlags.MOUSE_MOVED ||
mouseEvent.dwEventFlags == MouseEventFlags.PRESSED_OR_RELEASED) {
rawPosition = new Point(mouseEvent.dwMousePosition.X, mouseEvent.dwMousePosition.Y);
lastMousePosition = rawPosition;
} else {
// При событии MOUSE_WHEELED в Windows некорректно устанавливается mouseEvent.dwMousePosition
// Поэтому для определения элемента, над которым производится прокручивание колёсика, мы
// вынуждены сохранять координаты, полученные при предыдущем событии мыши
rawPosition = lastMousePosition;
}
Control topMost = findSource(rawPosition, rootElement);
// если мышь захвачена контролом, то события перемещения мыши доставляются только ему,
// события, связанные с нажатием мыши - тоже доставляются только ему, вместо того
// контрола, над которым событие было зарегистрировано. Такой механизм необходим,
// например, для корректной обработки перемещений окон (вверх или в стороны)
Control source = (inputCaptureStack.Count != 0) ? inputCaptureStack.Peek() : topMost;
if (mouseEvent.dwEventFlags == MouseEventFlags.MOUSE_MOVED) {
MouseButtonState leftMouseButtonState = getLeftButtonState(mouseEvent.dwButtonState);
MouseButtonState middleMouseButtonState = getMiddleButtonState(mouseEvent.dwButtonState);
MouseButtonState rightMouseButtonState = getRightButtonState(mouseEvent.dwButtonState);
//
MouseEventArgs mouseEventArgs = new MouseEventArgs(source, Control.PreviewMouseMoveEvent,
rawPosition,
leftMouseButtonState,
middleMouseButtonState,
rightMouseButtonState
);
eventsQueue.Enqueue(mouseEventArgs);
//
lastLeftMouseButtonState = leftMouseButtonState;
lastMiddleMouseButtonState = middleMouseButtonState;
lastRightMouseButtonState = rightMouseButtonState;
// detect mouse enter / mouse leave events
// path to source from root element down
List<Control> mouseOverStack = new List<Control>();
Control current = topMost;
while (null != current) {
mouseOverStack.Insert(0, current);
current = current.Parent;
}
int index;
for (index = 0; index < Math.Min(mouseOverStack.Count, prevMouseOverStack.Count); index++) {
if (mouseOverStack[index] != prevMouseOverStack[index])
break;
}
for (int i = prevMouseOverStack.Count - 1; i >= index; i-- ) {
Control control = prevMouseOverStack[i];
MouseEventArgs args = new MouseEventArgs(control, Control.MouseLeaveEvent,
rawPosition,
leftMouseButtonState,
middleMouseButtonState,
rightMouseButtonState
);
eventsQueue.Enqueue(args);
}
for (int i = index; i < mouseOverStack.Count; i++ ) {
// enqueue MouseEnter event
Control control = mouseOverStack[i];
MouseEventArgs args = new MouseEventArgs(control, Control.MouseEnterEvent,
rawPosition,
leftMouseButtonState,
middleMouseButtonState,
rightMouseButtonState
);
eventsQueue.Enqueue(args);
}
prevMouseOverStack.Clear();
prevMouseOverStack.AddRange(mouseOverStack);
}
if (mouseEvent.dwEventFlags == MouseEventFlags.PRESSED_OR_RELEASED) {
//
MouseButtonState leftMouseButtonState = getLeftButtonState(mouseEvent.dwButtonState);
MouseButtonState middleMouseButtonState = getMiddleButtonState(mouseEvent.dwButtonState);
MouseButtonState rightMouseButtonState = getRightButtonState(mouseEvent.dwButtonState);
//
if (leftMouseButtonState != lastLeftMouseButtonState) {
MouseButtonEventArgs eventArgs = new MouseButtonEventArgs(source,
leftMouseButtonState == MouseButtonState.Pressed ? Control.PreviewMouseDownEvent : Control.PreviewMouseUpEvent,
rawPosition,
leftMouseButtonState,
lastMiddleMouseButtonState,
lastRightMouseButtonState,
MouseButton.Left
);
eventsQueue.Enqueue(eventArgs);
}
if (middleMouseButtonState != lastMiddleMouseButtonState) {
MouseButtonEventArgs eventArgs = new MouseButtonEventArgs(source,
middleMouseButtonState == MouseButtonState.Pressed ? Control.PreviewMouseDownEvent : Control.PreviewMouseUpEvent,
rawPosition,
lastLeftMouseButtonState,
middleMouseButtonState,
lastRightMouseButtonState,
MouseButton.Middle
);
eventsQueue.Enqueue(eventArgs);
}
if (rightMouseButtonState != lastRightMouseButtonState) {
MouseButtonEventArgs eventArgs = new MouseButtonEventArgs(source,
rightMouseButtonState == MouseButtonState.Pressed ? Control.PreviewMouseDownEvent : Control.PreviewMouseUpEvent,
rawPosition,
lastLeftMouseButtonState,
lastMiddleMouseButtonState,
rightMouseButtonState,
MouseButton.Right
);
eventsQueue.Enqueue(eventArgs);
}
//
lastLeftMouseButtonState = leftMouseButtonState;
lastMiddleMouseButtonState = middleMouseButtonState;
lastRightMouseButtonState = rightMouseButtonState;
}
if (mouseEvent.dwEventFlags == MouseEventFlags.MOUSE_WHEELED) {
MouseWheelEventArgs args = new MouseWheelEventArgs(
topMost,
Control.PreviewMouseWheelEvent,
rawPosition,
lastLeftMouseButtonState, lastMiddleMouseButtonState,
lastRightMouseButtonState,
mouseEvent.dwButtonState > 0 ? 1 : -1
);
eventsQueue.Enqueue( args );
}
}
if (inputRecord.EventType == EventType.KEY_EVENT) {
KEY_EVENT_RECORD keyEvent = inputRecord.KeyEvent;
KeyEventArgs eventArgs = new KeyEventArgs(
ConsoleApplication.Instance.FocusManager.FocusedElement,
keyEvent.bKeyDown ? Control.PreviewKeyDownEvent : Control.PreviewKeyUpEvent);
eventArgs.UnicodeChar = keyEvent.UnicodeChar;
eventArgs.bKeyDown = keyEvent.bKeyDown;
eventArgs.dwControlKeyState = keyEvent.dwControlKeyState;
eventArgs.wRepeatCount = keyEvent.wRepeatCount;
eventArgs.wVirtualKeyCode = keyEvent.wVirtualKeyCode;
eventArgs.wVirtualScanCode = keyEvent.wVirtualScanCode;
eventsQueue.Enqueue(eventArgs);
}
}
/// <summary>
/// Called on MouseMove event raised from Map Control when tool is activated.
/// </summary>
public void OnMouseMove(MouseButtonState left, MouseButtonState right,
MouseButtonState middle, ModifierKeys modifierKeys, double x, double y)
{
}
//*************************************************************************
// Method: DragIsInProgress()
//
/// <summary>
/// Determines whether a particular type of mouse drag is in progress.
/// </summary>
///
/// <param name="oMouseDrag">
/// Object that represents the drag operation, or null if the drag
/// operation hasn't begun.
/// </param>
///
/// <param name="oMouseEventArgs">
/// Standard mouse event arguments.
/// </param>
///
/// <param name="aeMouseButtonStates">
/// Array of button states, one for each button that can be pressed to
/// allow the drag to be considered in progress.
/// </param>
///
/// <param name="oMouseLocation">
/// Where the mouse location get stored if true is returned.
/// </param>
///
/// <returns>
/// true if the specified mouse drag is in progress.
/// </returns>
//*************************************************************************
protected Boolean DragIsInProgress(
MouseDrag oMouseDrag,
MouseEventArgs oMouseEventArgs,
MouseButtonState [] aeMouseButtonStates,
out Point oMouseLocation
)
{
Debug.Assert(oMouseEventArgs != null);
Debug.Assert(aeMouseButtonStates != null);
Debug.Assert(aeMouseButtonStates.Length > 0);
AssertValid();
oMouseLocation = new Point();
if (oMouseDrag != null)
{
foreach (MouseButtonState eMouseButtonState in aeMouseButtonStates)
{
if (eMouseButtonState == MouseButtonState.Pressed)
{
oMouseLocation = oMouseEventArgs.GetPosition(this);
return ( oMouseDrag.OnMouseMove(oMouseLocation) );
}
}
}
return (false);
}
/// <summary>
/// Converts a <see cref="MouseButtonState"/> into a <see cref="ButtonState"/>.
/// </summary>
/// <param name="mouseState">Window mouse button state.</param>
/// <returns></returns>
private ButtonState GetButtonState(MouseButtonState mouseState)
{
return mouseState == MouseButtonState.Pressed ? ButtonState.Pressed : ButtonState.Released;
}
protected static ButtonState MapButtonState(MouseButtonState mouseButtonState)
{
if (mouseButtonState == MouseButtonState.Pressed)
return ButtonState.Pressed;
return ButtonState.Released;
}
/// <summary>
/// Fired when a mousebutton releases the clicked state
/// </summary>
/// <param name="e"></param>
protected override void OnMouseUp(MouseButtonEventArgs e)
{
Mouse.Capture(this, CaptureMode.None);
if (_LeftButton == MouseButtonState.Pressed)
{
Point mouseposition = e.GetPosition(this);
// make sure to register a click even if the user moved the mouse a bit
if (mouseposition == ff ||
(ff.X + _ClickSensitivity > mouseposition.X &&
ff.X - _ClickSensitivity < mouseposition.X &&
ff.Y + _ClickSensitivity > mouseposition.Y &&
ff.Y - _ClickSensitivity < mouseposition.Y))
{
_MouseMoved = false;
Point3D testpoint3D = new Point3D(mouseposition.X, mouseposition.Y, 0);
Vector3D testdirection = new Vector3D(mouseposition.X, mouseposition.Y, 10);
PointHitTestParameters pointparams = new PointHitTestParameters(mouseposition);
RayHitTestParameters rayparams = new RayHitTestParameters(testpoint3D, testdirection);
//test for a result in the Viewport3D
_LeftButton = e.LeftButton;
_RightButton = e.RightButton;
_CurrentMousePosition = mouseposition;
VisualTreeHelper.HitTest(this, HittestFilter, HTClickResult, pointparams);
}
}
}
private void ResetButton(ref MouseButtonState button)
{
if (button.State == MouseButtonStates.Pressed)
button = new MouseButtonState(MouseButtonStates.Down, button.DragState);
if (button.State == MouseButtonStates.Clicked || button.State == MouseButtonStates.DragEnded)
button = new MouseButtonState(MouseButtonStates.Idle);
if (button.State != MouseButtonStates.DragStarted)
return;
button = new MouseButtonState(MouseButtonStates.Dragging, button.DragState);
}
/// <summary>
/// 设置鼠标某个按钮的当前状态
/// </summary>
public void SetMouseButtonState(MouseButton key, MouseButtonState state)
{
UpdateRender.KS_MOUSE_Dict[key] = state;
}
/// <summary>
/// Returns True if mouse button is in specified state (Default state: click)
/// </summary>
/// <param name="button">Mouse button</param>
/// <param name="bState">Mouse button state</param>
public bool IsMousePressed(MouseButton button, MouseButtonState bState = MouseButtonState.Click)
{
switch(button)
{
case MouseButton.Right:
return bState == MouseButtonState.Click ? LastMouseState.RightButton == ButtonState.Released && MouseState.RightButton == ButtonState.Pressed : MouseState.RightButton == ButtonState.Pressed;
case MouseButton.Middle:
return bState == MouseButtonState.Click ? LastMouseState.MiddleButton == ButtonState.Released && MouseState.MiddleButton == ButtonState.Pressed : MouseState.MiddleButton == ButtonState.Pressed;
default:
return bState == MouseButtonState.Click ? LastMouseState.LeftButton == ButtonState.Released && MouseState.LeftButton == ButtonState.Pressed : MouseState.LeftButton == ButtonState.Pressed;
}
}
public MouseButton()
{
L = new MouseButtonState();
R = new MouseButtonState();
M = new MouseButtonState();
}
public void OnMouseMove(MouseButtonState left, MouseButtonState right,
MouseButtonState middle, ModifierKeys modifierKeys, double x, double y)
{
Point point = new Point(x, y);
// Project point from Web Mercator to WGS84 if spatial reference of map is Web Mercator.
if (_mapControl.Map.SpatialReferenceID.HasValue)
{
point = WebMercatorUtil.ProjectPointFromWebMercator(point, _mapControl.Map.SpatialReferenceID.Value);
}
_popupAddress.OnMouseMove(point.X, point.Y);
}
/// <summary>
/// React on mouse move.
/// </summary>
/// <param name="left">Left button state.</param>
/// <param name="right">Right button state.</param>
/// <param name="middle">Middle button state.</param>
/// <param name="modifierKeys">Modifier keys state.</param>
/// <param name="x">X coord.</param>
/// <param name="y">Y coord.</param>
public void OnMouseMove(MouseButtonState left, MouseButtonState right, MouseButtonState middle,
ModifierKeys modifierKeys, double x, double y)
{
Debug.Assert(_mapControl != null);
if (_editingInProcess && left == MouseButtonState.Pressed)
{
Debug.Assert(_editedGraphic != null);
Point point = new Point(x, y);
// Project point from Web Mercator to WGS84 if spatial reference of map is Web Mercator.
if (_mapControl.Map.SpatialReferenceID.HasValue)
{
point = WebMercatorUtil.ProjectPointFromWebMercator(point, _mapControl.Map.SpatialReferenceID.Value);
}
double dx = point.X - _previousX;
double dy = point.Y - _previousY;
// Save current position.
_previousX = point.X;
_previousY = point.Y;
// Do pan object.
object obj = _editedGraphic.Data;
if (obj is EditingMarker || obj is IGeocodable || obj is Zone || obj is Barrier)
{
_PanObject(EditingObject, dx, dy);
}
else
Debug.Assert(false);
}
else
{
// If can start drag - change cursor.
Cursor newCursor = null;
DataGraphicObject pointedGraphicObject = _mapControl.PointedGraphic as DataGraphicObject;
if (pointedGraphicObject != null)
{
if (pointedGraphicObject.Data == EditingObject || pointedGraphicObject is EditMarkerGraphicObject)
{
bool multiple = false;
if (pointedGraphicObject is EditMarkerGraphicObject)
{
EditMarkerGraphicObject editMarkerGraphicObject = (EditMarkerGraphicObject)pointedGraphicObject;
multiple = editMarkerGraphicObject.EditingMarker.MultipleIndex > -1;
}
if (multiple)
newCursor = _moveVertexCursor;
else
newCursor = _moveShapeCursor;
}
}
_ChangeCursor(newCursor);
}
_popupAddress.OnMouseMove(_previousX, _previousY);
}
void OnGLMouse(MouseButton button, MouseButtonState state, int x, int y)
{
// Use the mouse to move things around.
if (button == MouseButton.Left)
{
CheckSelect(x, y);
Vec2 p = ConvertScreenToWorld(x, y);
if (state == MouseButtonState.Down)
{
if ((ModifierKeys & Keys.Shift) != 0)
{
}
else
{
}
}
if (state == MouseButtonState.Up)
{
}
}
else if (button == MouseButton.Right)
{
if (state == MouseButtonState.Down)
{
lastp = ConvertScreenToWorld(x, y);
rMouseDown = true;
}
if (state == MouseButtonState.Up)
{
rMouseDown = false;
}
}
}
public MouseWheelEventArgs(object source, RoutedEvent routedEvent, Point rawPosition,
MouseButtonState leftButton, MouseButtonState middleButton,
MouseButtonState rightButton, int delta)
: base(source, routedEvent, rawPosition, leftButton, middleButton, rightButton) {
Delta = delta;
}
/// <summary>
/// Fired when the mouse button is in a 'down' position.
/// </summary>
/// <param name="e"></param>
protected override void OnMouseDown(MouseButtonEventArgs e)
{
_LeftButton = e.LeftButton;
_RightButton = e.RightButton;
ff = e.GetPosition(this);
Mouse.Capture(this, CaptureMode.Element);
_PreviousPosition2D = e.GetPosition(this);
_previousPosition3D = ProjectToTrackball(
ActualWidth, ActualHeight, _PreviousPosition2D);
Point mouseposition = e.GetPosition(this);
PointHitTestParameters pointparams = new PointHitTestParameters(mouseposition);
Console.WriteLine(this.GetType().GUID.ToString());
Console.WriteLine(e.OriginalSource.ToString());
}
