public MouseEvent(float dX, float dY, Point Position, EventType Type, bool[] ButtonState, MouseEvent lastEvent)
{
this.dX = dX;
this.dY = dY;
this.Position = Position;
this.Type = Type;
this.lastEvent = lastEvent;
if(ButtonState.Length == 3)
this.ButtonState = ButtonState;
}
private void HandleWindowDragEvent(MouseEvent evt, int relX, int relY)
{
if (dragCorner == Corner.TITLE)
{
// Drag movement
Move((int)evt.dX, (int)evt.dY);
WindowManager.Instance.Cursor = WindowManager.CursorType.MOVE;
}
else if (dragCorner == Corner.BOTRIGHT)
{
WindowManager.Instance.Cursor = WindowManager.CursorType.SCALE;
// only make size bigger if mouse is near the borders
float dx = ((evt.dX > 0) ? ((Size.Width - relX < dragPosition.X) ? evt.dX : 0) : evt.dX);
float dy = ((evt.dY > 0) ? ((Size.Height - relY < dragPosition.Y) ? evt.dY : 0) : evt.dY);
System.Console.WriteLine(evt.dX + ":" + evt.dY);
ResizeDelta(new Size((int)dx, (int)dy));
}
else if (dragCorner == Corner.RIGHT)
{
WindowManager.Instance.Cursor = WindowManager.CursorType.VERT;
// only make size bigger if mouse is near the borders
float dx = ((evt.dX > 0) ? ((Size.Width - relX < dragPosition.X) ? evt.dX : 0) : evt.dX);
ResizeDelta(new Size((int)dx, 0));
}
else if (dragCorner == Corner.BOT)
{
WindowManager.Instance.Cursor = WindowManager.CursorType.HORIZ;
// only make size bigger if mouse is near the borders
float dy = ((evt.dY > 0) ? ((Size.Height - relY < dragPosition.Y) ? evt.dY : 0) : evt.dY);
ResizeDelta(new Size(0, (int)dy));
}
else if (dragCorner == Corner.LEFT)
{
WindowManager.Instance.Cursor = WindowManager.CursorType.VERT;
// only make size bigger if mouse is near the borders
float dx = ((evt.dX < 0) ? ((relX < -(dragPosition.X - dragOriginalSize.Width)) ? evt.dX : 0) : evt.dX);
Size tempSize = Size;
if (ResizeDelta(new Size((int)-dx, 0)))
Move(tempSize.Width - Size.Width, 0);
}
else if (dragCorner == Corner.TOP)
{
WindowManager.Instance.Cursor = WindowManager.CursorType.HORIZ;
// only make size bigger if mouse is near the borders
float dy = ((evt.dY < 0) ? ((relY < -(dragPosition.Y - dragOriginalSize.Height)) ? evt.dY : 0) : evt.dY);
Size tempSize = Size;
if (ResizeDelta(new Size(0, (int)-dy)))
Move(0, tempSize.Height - Size.Height);
}
}
// Handle mouse buttonrelease event
public override void MouseUpEvent(MouseEvent evt)
{
// Special case for mouselock
if (MouseLock)
{
MouseLockControl.MouseUp(evt);
}
else
{
// Finalize dragging
if (dragging && !evt.ButtonState[0])
{
// Stop dragging
dragging = false;
WindowManager.Instance.ReleaseMouseLock();
}
// Send MouseUp event to controls if no border were hit
Corner corner = CheckIsMouseHitBorders(evt.Position, false);
if (corner == Corner.MIDDLE || Borderless)
panel.MouseUp(evt);
}
}
// Handle mouse movement event
public override void MouseMoveEvent(MouseEvent evt)
{
// Special case for mouselock
if (MouseLock)
{
MouseLockControl.MouseMove(evt);
}
else
{
// Set cursor if not dragging, and not borderless
bool setCursor = (dragging || Borderless ? false : true);
Corner corner = CheckIsMouseHitBorders(evt.Position, setCursor);
int relX = evt.Position.X - Position.X;
int relY = evt.Position.Y - Position.Y;
// Handle dragging
if (dragging && dragCorner != Corner.MIDDLE && !Borderless)
{
HandleWindowDragEvent(evt, relX, relY);
}
// Else send event to panel
else if (corner == Corner.MIDDLE || Borderless)
{
// Send events to panel
panel.MouseMove(evt);
}
// Update list over controls with mouseenter
List<Control> toremove = new List<Control>();
foreach (Control control in ControlsWithMouseEnter)
{
// Is mouse not within control anymore?
if (!control.Bound.Contains(evt.Position.X, evt.Position.Y))
toremove.Add(control);
}
// Send mouseexit events to controls that lost mouseenter-state
foreach (Control control in toremove)
{
control.MouseExit(evt);
ControlsWithMouseEnter.Remove(control);
}
}
}
// Window lost mouse coverage and mush flush its cache of controls with mouseenter
public override void MouseExitEvent(MouseEvent evt)
{
if (!MouseLock)
{
foreach (Control control in ControlsWithMouseEnter)
{
control.MouseExit(evt);
}
ControlsWithMouseEnter.Clear();
WindowManager.Instance.Cursor = WindowManager.CursorType.NORMAL;
}
else
{
MouseLockControl.MouseExit(evt);
}
}
// Handle mouse downbutton event
public override void MouseDownEvent(MouseEvent evt)
{
// Special case if a control has mouselock
if (MouseLock)
{
MouseLockControl.MouseDown(evt);
}
else
{
// Check if a border were hit
int relX = evt.Position.X - Position.X;
int relY = evt.Position.Y - Position.Y;
Corner corner = CheckIsMouseHitBorders(evt.Position, false);
// Check if border is hit
if (corner != Corner.MIDDLE && !Borderless)
{
// Recieved buttonpress on a border
if (!dragging && evt.ButtonState[0] && (evt.Type & MouseEvent.EventType.BUTTON0CHANGED) > 0)
{
// Initialize dragging
dragCorner = corner;
dragging = true;
WindowManager.Instance.GetMouseLock(this);
dragPosition = new Dimension(Size.Width - relX, Size.Height - relY);
dragOriginalSize = Size;
}
}
else
{
// Send mouse event to panel
panel.MouseDown(evt);
}
}
}
public virtual void MouseUpEvent(MouseEvent evt)
{
}
public override void MouseExitEvent(MouseEvent evt)
{
state = ButtonState.NORMAL;
}
public void ContainerMouseMoveEvent(MouseEvent evt)
{
foreach (Control control in Controls)
{
if (control.Bound.Contains(evt.Position.X, evt.Position.Y))
{
if (!Window.ControlsWithMouseEnter.Contains(control))
{
Window.ControlsWithMouseEnter.Add(control);
control.MouseEnter(evt);
}
control.MouseMove(evt);
}
}
}
// Incomming mouse event from Input layer
public void HandleMouseEvent(MouseEvent evt)
{
// Ignore if UI not in focus
if (!ShowManager)
return;
// Special case for windows that has privileged focus over mouse
if (MouseLock && MouseLockWindow != null)
{
// Check button statechange and send events
if ((evt.Type & MouseEvent.EventType.MOUSEDOWN) > 0)
{
MouseLockWindow.MouseDown(evt);
// Send window to front, if necessary
if (MouseLockWindow.Zvalue < nextZvalue - 1)
MouseLockWindow.Zvalue = nextZvalue++;
}
if ((evt.Type & MouseEvent.EventType.MOUSEUP) > 0)
MouseLockWindow.MouseUp(evt);
if ((evt.Type & MouseEvent.EventType.MOVE) > 0 && MouseLockWindow != null)
MouseLockWindow.MouseMove(evt);
}
// Iterate windows and try to find one that has been hit
else
{
// sort windows - most recent focussed first
Windows.Sort(new WindowComparer());
// Iterate over windows untill a window is hit
bool windowHit = false;
foreach (Window window in Windows)
{
if (!window.Visible)
continue;
// Check against bounds
if (window.Bound.Contains(evt.Position))
{
windowHit = true;
//window.Update();
// Entering new window?
if (LastWindowMouseEnter != window)
{
// Notify old window
if (LastWindowMouseEnter != null)
LastWindowMouseEnter.MouseExit(evt);
LastWindowMouseEnter = window;
// Notify new window
window.MouseEnter(evt);
}
// Check button statechange and send events
if ((evt.Type & MouseEvent.EventType.MOUSEDOWN) > 0)
{
window.MouseDown(evt);
// Send window to front, if necessary
if (window.Zvalue < nextZvalue - 1)
window.Zvalue = nextZvalue++;
}
if ((evt.Type & MouseEvent.EventType.MOUSEUP) > 0)
window.MouseUp(evt);
if ((evt.Type & MouseEvent.EventType.MOVE) > 0)
window.MouseMove(evt);
break;
}
}
// No window hit - show default cursor
if (!windowHit)
Cursor = 0;
}
}
private void UpdateMouseSlimDX()
{
// Do Non-WPF input handling
// Switch to next MouseArgs
// Check delta
mousedx = 0; mousedy = 0;
int deltaX = 0, deltaY = 0;
// RawInput only for delta x/y
if (MouseState == client.MouseState.GAME && MouseRawInput)
{
if (NextRawMouse != null)
{
// Use raw input
for (int i = 0; i < NextRawMouseList.Count; i++)
{
MouseInputEventArgs e = NextRawMouseList[i].Key;
long ticks = NextRawMouseList[i].Value;
deltaX += e.X;
deltaY += e.Y;
if ((e.ButtonFlags & MouseButtonFlags.LeftDown) == MouseButtonFlags.LeftDown)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE1, true, ticks);
if ((e.ButtonFlags & MouseButtonFlags.LeftUp) == MouseButtonFlags.LeftUp)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE1, false, ticks);
if ((e.ButtonFlags & MouseButtonFlags.RightDown) == MouseButtonFlags.RightDown)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE2, true, ticks);
if ((e.ButtonFlags & MouseButtonFlags.RightUp) == MouseButtonFlags.RightUp)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE2, false, ticks);
if ((e.ButtonFlags & MouseButtonFlags.MiddleDown) == MouseButtonFlags.MiddleDown)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE3, true, ticks);
if ((e.ButtonFlags & MouseButtonFlags.MiddleUp) == MouseButtonFlags.MiddleUp)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE3, false, ticks);
if ((e.ButtonFlags & MouseButtonFlags.Button4Down) == MouseButtonFlags.Button4Down)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE4, true, ticks);
if ((e.ButtonFlags & MouseButtonFlags.Button4Up) == MouseButtonFlags.Button4Up)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE4, false, ticks);
if ((e.ButtonFlags & MouseButtonFlags.Button5Down) == MouseButtonFlags.Button5Down)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE5, true, ticks);
if ((e.ButtonFlags & MouseButtonFlags.Button5Up) == MouseButtonFlags.Button5Up)
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MOUSE5, false, ticks);
if ((e.ButtonFlags & MouseButtonFlags.MouseWheel) == MouseButtonFlags.MouseWheel)
{
if (NextRawMouse.WheelDelta != 0)
{
if (NextRawMouse.WheelDelta == -120)
{
// Scroll down
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MWHEELDOWN, true, 0);
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MWHEELDOWN, false, 0);
}
else if (NextRawMouse.WheelDelta == 120)
{
// Scroll up
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MWHEELUP, true, ticks);
KeyHags.Instance.ParseBinding((int)KeyHags.CubeKeys.K_MWHEELUP, false, ticks + 10);
}
else
{
Common.Instance.WriteLine("MouseWheel: Fix me! Value: " + NextRawMouse.WheelDelta);
}
Common.Instance.WriteLine(""+NextRawMouse.WheelDelta);
//if (Common.Instance.PlanetGame != null)
// Common.Instance.PlanetGame.HandleScroll(NextRawMouse.WheelDelta);
}
}
}
NextRawMouseList.Clear();
CurrentRawMouse = NextRawMouse;
NextRawMouse = null;
}
}
else if (MouseState == client.MouseState.CONSOLE)
{
NextRawMouseList.Clear();
}
if (compatNextMouseArgs.Count > 0)
{
if (MouseState == client.MouseState.CONSOLE)
{
compatNextMouseArgs.Clear();
return;
}
compatLastMouseArgs = compatCurrentMouseArgs;
compatCurrentMouseArgs = compatNextMouseArgs;
compatLastMouseArgs.Clear();
compatNextMouseArgs = compatLastMouseArgs;
// Avoid cyclic dependencies
if (LastMouseEvent != null && CurrentMouseEvent != null)
{
CurrentMouseEvent.lastEvent = null;
LastMouseEvent = CurrentMouseEvent;
}
// Get latest event
System.Windows.Forms.MouseEventArgs evnt = null;
if (compatCurrentMouseArgs.Count > 1)
{
evnt = compatCurrentMouseArgs[compatCurrentMouseArgs.Count - 1];
}
else
evnt = compatCurrentMouseArgs[0];
// Screen-space Position
Point pos = evnt.Location;
// Forms Input
if ((MouseState != client.MouseState.GAME || !MouseRawInput) && (evnt.X != mouseX || evnt.Y != mouseY))
{
deltaX = (int)mouseX - evnt.X;
deltaY = (int)mouseY - evnt.Y;
}
// Mouse centering will create an event with the delta movement, that we have to substract here
if (MouseCentered && (MouseState != client.MouseState.GAME || MouseRawInput))
{
deltaX -= MouseDeltaAfterCenter.X;
deltaY -= MouseDeltaAfterCenter.Y;
}
// Button states
bool[] buttonState = new bool[3];
buttonState[0] = (evnt.Button & System.Windows.Forms.MouseButtons.Left) == System.Windows.Forms.MouseButtons.Left ? true : false;
buttonState[1] = (evnt.Button & System.Windows.Forms.MouseButtons.Middle) == System.Windows.Forms.MouseButtons.Middle ? true : false;
buttonState[2] = (evnt.Button & System.Windows.Forms.MouseButtons.Right) == System.Windows.Forms.MouseButtons.Right ? true : false;
MouseEvent.EventType type = MouseEvent.EventType.NONE;
if (deltaX != 0 || deltaY != 0)
type |= MouseEvent.EventType.MOVE;
// Compare buttons state changes
if (buttonState[0] != mousebuttons[0]) type |= MouseEvent.EventType.BUTTON0CHANGED;
if (buttonState[1] != mousebuttons[1]) type |= MouseEvent.EventType.BUTTON1CHANGED;
if (buttonState[2] != mousebuttons[2]) type |= MouseEvent.EventType.BUTTON2CHANGED;
for (int i = 0; i < 3; i++)
{
// Have one button + movement? Drag.
if (buttonState[i] == true && (type & MouseEvent.EventType.MOVE) == MouseEvent.EventType.MOVE)
type |= MouseEvent.EventType.DRAG;
// Look for new buttons pressed
if (buttonState[i] == true && mousebuttons[i] == false)
type |= MouseEvent.EventType.MOUSEDOWN;
// Look for buttons now released
else if (buttonState[i] == false && mousebuttons[i] == true)
type |= MouseEvent.EventType.MOUSEUP;
}
if (HiddenMouseSwitched)
HiddenMouseSwitched = false;
// Create mouse event
CurrentMouseEvent = new MouseEvent(-deltaX, -deltaY, pos, type, buttonState, LastMouseEvent);
mousebuttons = buttonState;
mouseX = pos.X;
mouseY = pos.Y;
// If i GUI, send to WindowManager
if (MouseState == client.MouseState.GUI && (type > 0))
{
WindowManager.Instance.HandleMouseEvent(CurrentMouseEvent);
mousedy = mousedx = 0;
}
else
{
mousedx = deltaX;
mousedy = deltaY;
}
}
else if (CurrentMouseEvent != null)
{
CurrentMouseEvent.lastEvent = null;
LastMouseEvent = CurrentMouseEvent;
CurrentMouseEvent = new MouseEvent(0, 0, CurrentMouseEvent.Position, MouseEvent.EventType.NONE, CurrentMouseEvent.ButtonState, CurrentMouseEvent);
}
}
public virtual void MouseExitEvent(MouseEvent evt)
{
}
public virtual void MouseEnterEvent(MouseEvent evt)
{
}
// Default event methods.. useful for override
public virtual void MouseDownEvent(MouseEvent evt)
{
}
public override void MouseDownEvent(MouseEvent evt)
{
state = ButtonState.DOWN;
}
public void ContainerMouseUpEvent(MouseEvent evt)
{
foreach (Control control in Controls)
{
if (control.Bound.Contains(evt.Position.X, evt.Position.Y))
control.MouseUp(evt);
}
}
public override void MouseEnterEvent(MouseEvent evt)
{
state = ButtonState.HOVER;
}
// Metods to propagate events to all contained controls
public void ContainerMouseDownEvent(MouseEvent evt)
{
foreach (Control control in Controls)
{
if (control.Bound.Contains(evt.Position.X, evt.Position.Y))
{
control.MouseDown(evt);
// Only give focus to a panel if another control doesn't already have it
if (!(control is Panel) || Window.FocusControl == null)
Window.FocusControl = control;
}
}
}
public override void MouseUpEvent(MouseEvent evt)
{
// Go back to hightlight if mouse is still covering button
if (Bound.Contains(evt.Position.X, evt.Position.Y))
{
state = ButtonState.HOVER;
Selected();
}
else
state = ButtonState.NORMAL;
}
public virtual void MouseMoveEvent(MouseEvent evt)
{
}
