public static void ProcessMouse(int oriX,int oriY){
EventArgs evnt=null;
var pressed = false;
prevMouseState =curMouseState;
curMouseState = Mouse.GetCursorState ();
Gwen.Input.InputHandler.HoveredControl =input.m_Canvas.GetControlAt(curMouseState.X - oriX, curMouseState.Y - oriY);
foreach (var mouseCode in mouseCodes)
if (curMouseState[mouseCode]!=prevMouseState[mouseCode]){
evnt = new MouseButtonEventArgs(curMouseState.X - oriX, curMouseState.Y - oriY, mouseCode, true);//last param bugged
//evnt = new MouseButtonEventArgs (curMouseState.X, curMouseState.Y, mouseCode,true);//last param bugged
if (curMouseState [mouseCode]) {
pressed = true;
Gwen.Input.InputHandler.MouseFocus = Gwen.Input.InputHandler.HoveredControl;
OnMouseDown?.Invoke ((MouseButtonEventArgs)evnt);
} else {
OnMouseUp?.Invoke ((MouseButtonEventArgs)evnt);
}
}
Vector2 delta =MainWindow.lastPos - new Vector2(curMouseState.X, curMouseState.Y);
if (Math.Abs (delta.X) > 0 || Math.Abs (delta.Y) > 0) {
evnt = new MouseMoveEventArgs (curMouseState.X-oriX, curMouseState.Y-oriY,(int)delta.X,(int)delta.Y);
OnMouseMove?.Invoke (evnt as MouseMoveEventArgs);
}
input.ProcessMouseMessage (evnt,pressed);
MainWindow.lastPos = new Vector2 (curMouseState.X, curMouseState.Y);
}
public void MouseUp(MouseButtonEventArgs args)
{
if (Interfaces.ContainsKey (lastState)) {
Interfaces [lastState].MouseUp(args);
}
}
public void MouseButtonDown(object sender, MouseButtonEventArgs e)
{
if (!Main.Focused)
{
return;
}
}
void Mouse_ButtonDown(object sender, MouseButtonEventArgs e)
{
for (Int16 i = 0; i < 6; i++)
{
if ((e.X > menuVects[i][0].X && e.X < menuVects[i][1].X) && ((Settings.Height - e.Y) > menuVects[i][0].Y && (Settings.Height - e.Y) < menuVects[i][2].Y))
{
switch (i)
{
case 0: //Singleplayer clicked
ScreenManager.Push(new Screens.Singleplayer());
break;
case 1: //Multiplayer clicked
ScreenManager.Push(new Screens.Multiplayer());
break;
case 2: //Texture Packs clicked
break;
case 3: //Mods clicked
break;
case 4: //Options clicked
break;
case 5: //Exit clicked
Program.Close();
break;
}
}
}
}
private void OpenGLDisplay_MouseDown( object sender, MouseButtonEventArgs e )
{
_mouse_x = 0;
_mouse_y = 0;
System.Windows.Forms.Cursor.Position = new System.Drawing.Point( X + ( Width ) / 2, Y + Height / 2 );
HiddenMouse = true;
}
void mouse_ButtonUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
MouseButton button = (MouseButton)e.Button;
Vector2 position = new Vector2(e.X, e.Y);
root.OnMouseUpEvent(new MouseButtonEventArgs(button, position, GetModifierKeys()));
}
private void _ButtonDown(object sender, MouseButtonEventArgs arguments)
{
if (!_window.Focused) return;
_downButtons.Add((Button)arguments.Button);
if(ButtonDown != null)
ButtonDown(sender, new DunamisMouseButtonEventArgs((Button)arguments.Button));
}
void Mouse_ButtonDown(object sender, MouseButtonEventArgs e)
{
if (e.Button == MouseButton.Left)
{
AddLine(e.X, e.Y);
}
}
void Mouse_ButtonDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
if (e.Button == OpenTK.Input.MouseButton.Left)
{
switch (CurrentState)
{
case GameState.Playing:
break;
case GameState.RailTrackEdition:
if (RailTrack.CurrentSegment == null)
{
RailTrack.CurrentSegment = new TrackSegment(terrain.SelCenterPos);
RailTrack.TrackStarts.Add(RailTrack.CurrentSegment);
}
else
{
TrackSegment newTS = new TrackSegment(RailTrack.CurrentSegment.EndPos, RailTrack.vEnd);
RailTrack.CurrentSegment.NextSegment.Add(newTS);
newTS.PreviousSegment.Add(RailTrack.CurrentSegment);
RailTrack.CurrentSegment = newTS;
}
RailTrack.UpdateTrackMesh();
break;
}
}
}
public bool OnRaycastHitchanged(Input input, QbMatrix matrix, RaycastHit hit, ref Colort color, MouseButtonEventArgs e)
{
if ((e != null && e.IsPressed && e.Button == MouseButton.Left) || (e == null && input.mousedown(MouseButton.Left)))
{
QbMatrix mat = Singleton<QbManager>.INSTANCE.ActiveModel.matrices[hit.matrixIndex];
if (mat != null)
{
Voxel voxel;
if (mat.voxels.TryGetValue(mat.GetHash(hit.x, hit.y, hit.z), out voxel))
{
for (int i = 0; i < 10; i++)
{
var colorpal = Singleton<GUI>.INSTANCE.Get<EmptyWidget>(GUIID.START_COLOR_SELECTORS + i);
if ((bool)colorpal.customData["active"])
{
colorpal.appearence.Get<PlainBackground>("background").color = mat.colors[voxel.colorindex];
Singleton<GUI>.INSTANCE.Dirty = true;
Singleton<BrushManager>.INSTANCE.brushColor = mat.colors[voxel.colorindex];
Color4 colorr = mat.colors[voxel.colorindex];
Singleton<Broadcaster>.INSTANCE.Broadcast(Message.ColorSelectionChanged, colorpal, colorr);
}
}
}
}
return true;
}
return false;
}
void Mouse_ButtonUp(object sender, MouseButtonEventArgs e)
{
md.X = e.X; md.Y = e.Y;
md[e.Button] = false;
md.Button = e.Button;
app.MouseUp(sender, md);
}
void Mouse_ButtonDown(object sender, MouseButtonEventArgs e)
{
md.X = e.X; md.Y = e.Y;
md[e.Button] = true;
md.Button = e.Button;
app.MouseDown(sender, md);
}
protected void OnMouseDownHandler(object sender, OpenTK.Input.MouseButtonEventArgs e)
{ //Handles MouseDown Events
if (e.IsPressed && (currentX != e.X && currentY != e.Y))
{
UpdateMouse(e.X, e.Y);
}
}
public override void OnClick(OpenTK.Input.MouseButtonEventArgs e)
{
if (IsToggleButton)
{
Checked = !Checked;
}
base.OnClick(e);
}
public override void OnClick(OpenTK.Input.MouseButtonEventArgs e)
{
base.OnClick(e);
if (Parent as ToolBarBase != null)
{
(Parent as ToolBarBase).OnButtonClick(this);
}
}
public void GameWindow_MouseDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
mouseClicked = true;
mouseClickedPos = new Vector2(e.X, e.Y);
Vector2 glPos = ScreenPositionToGLViewport(e.X, e.Y);
ui.Click(glPos.X, glPos.Y);
}
private void Mouse_ButtonDown(object sender, MouseButtonEventArgs ea)
{
isDragging = true;
mousePos = MousePos;
if (mousePos.ModulusSquared > 0.98)
isDraggingAngle = true;
initialMousePos = mousePos;
}
void MouseButtonUp(object s, OpenTK.Input.MouseButtonEventArgs e)
{
if (e.Button == MouseButton.Right)
{
this.mouseDown = false;
lastx = 0;
lasty = 0;
}
}
void onDown (object sender, MouseButtonEventArgs e)
{
decimal tmp = 0;
if (!decimal.TryParse (l.Text, out tmp))
return;
tmp -= 1;
l.Text = tmp.ToString ();
}
public override void MouseDown(MouseButtonEventArgs e)
{
base.MouseDown(e);
if (this.IsMouseOver())
{
SetChecked(!this.IsChecked);
}
}
protected override void OnMouseDown(MouseButtonEventArgs e)
{
if (e.Button == MouseButton.Right)
{
_move = e.IsPressed;
_moveFocusX = e.X;
_moveFocusY = e.Y;
}
base.OnMouseDown(e);
}
void Mouse_ButtonDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
Game Window1 = new Game(1280, 729, null, "Window1", GameWindowFlags.FixedWindow);
double fps = 60;
Window1.VSync = VSyncMode.Adaptive;
Window1.Run(fps, fps);
}
protected override void OnMouseUp(OpenTK.Input.MouseButtonEventArgs e)
{
base.OnMouseUp(e);
if (screen)
{
Vector2 p = new Vector2(e.Mouse.X, e.Mouse.Y);
screen.HandleMouseButtonEvent(p, 0, e.IsPressed, 0);
}
}
void mouse_ButtonDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
MouseButton button = (MouseButton)e.Button;
Vector2 position = new Vector2(e.X, e.Y);
if (root.Bounds.ContainsPoint(position))
{
root.OnMouseDownEvent(new MouseButtonEventArgs(button, position, GetModifierKeys()));
}
}
protected override void OnMouseUp(MouseButtonEventArgs e)
{
if (e.Button == MouseButton.Right)
{
_move = e.IsPressed;
Rescale();
CalcData();
}
base.OnMouseUp(e);
}
protected override void OnMouseUp(MouseButtonEventArgs e)
{
var button = ControllerMouseButton.Left;
if (e.Button == MouseButton.Left)
button = ControllerMouseButton.Left;
else if (e.Button == MouseButton.Middle)
button = ControllerMouseButton.Middle;
else if (e.Button == MouseButton.Right)
button = ControllerMouseButton.Right;
_controller.MouseUp(button, e.X, e.Y);
}
private void Mouse_ButtonUp(object sender, OpenTK.Input.MouseButtonEventArgs mbe)
{
if (mbe.Button == OpenTK.Input.MouseButton.Left)
{
Game.leftButton = false;
}
else if (mbe.Button == OpenTK.Input.MouseButton.Right)
{
Game.rightButton = false;
}
}
protected override void OnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
base.OnMouseDown(e);
Vector2 p = new Vector2(e.Mouse.X, e.Mouse.Y);
if (screen && screen.ContainsPoint(p))
{
screen.HandleMouseButtonEvent(p, (int)e.Button, e.IsPressed, 0);
}
}
void OpenGLTess_MouseUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
if (!_enabled)
{
return;
}
_state = State.NONE;
}
public override void OnClick(OpenTK.Input.MouseButtonEventArgs e)
{
if (Parent != null && Parent.Parent != null)
{
TabContainer tc = Parent.Parent as TabContainer;
if (tc != null)
{
tc.SelectedTab = this.TabPage;
}
}
base.OnClick(e);
}
void Mouse_ButtonDown(object sender, MouseButtonEventArgs e)
{
var button = ConvertMouseButtonFromOpenTK(e.Button);
var buttonId = (int)button;
CurrentMousePosition = new Vector2(e.X / ControlWidth, e.Y / ControlHeight);
var mouseInputEvent = new MouseInputEvent { Type = InputEventType.Down, MouseButton = button };
lock (MouseInputEvents)
MouseInputEvents.Add(mouseInputEvent);
MouseButtonCurrentlyDown[buttonId] = true;
HandlePointerEvents(buttonId, CurrentMousePosition, PointerState.Down, PointerType.Mouse);
}
public void OnMouseUp(OpenTK.Input.MouseButtonEventArgs e)
{
if (e.Button == MouseButton.Left)
{
if (_selectedCollider != null)
{
_selectedCollider.Grabbed = false;
if (_selectedCollider.IsTrigger)
{
}
_selectedCollider = null;
}
}
}
public override void OnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
base.OnMouseDown(e);
SetActiveIcon(e.X, e.Y);
if (ActiveItem != null)
{
ShowSubMenu(ActiveItem);
}
else
{
Invalidate();
}
}
public void Click(object sender, MouseButtonEventArgs e)
{
if (HandleRectangle.Contains(e.Position))
{
if (DynamicGrip)
{
Grip = new Point(e.Position.X - HandleRectangle.X, e.Position.Y - HandleRectangle.Y);
}
else
{
Grip = new Point(HandleRectangle.Width / 2, HandleRectangle.Height / 2);
}
}
}
public override void MouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
if (Status != WidgetStatus.Disabled)
{
if (e.Button == OpenTK.Input.MouseButton.Right && OnRightClick.Res != null)
{
OnRightClick.Res.Execute(this.GameObj, RightClickArgument);
}
if (e.Button == OpenTK.Input.MouseButton.Left && OnLeftClick.Res != null)
{
Status = WidgetStatus.Active;
OnLeftClick.Res.Execute(this.GameObj, _leftClickArgument);
}
}
}
public bool OnMouseDown(object sender, MouseButtonEventArgs e)
{
if (focusedControl != null && focusedControl.OnMouseDown(sender, e)) return true;
for (int i = 0; i < windows.Length; i++)
{
if (windows[i].OnMouseDown(sender, e))
{
SetTopMostWindow(windows[i]);
return true;
}
}
focusedControl = null;
return false;
}
void Mouse_ButtonUp(object sender, MouseButtonEventArgs e)
{
var button = ConvertMouseButtonFromOpenTK(e.Button);
var buttonId = (int)button;
// the mouse events series has been interrupted because out of the window.
if (!MouseButtonCurrentlyDown[buttonId])
return;
CurrentMousePosition = new Vector2(e.X / ControlWidth, e.Y / ControlHeight);
var mouseInputEvent = new MouseInputEvent { Type = InputEventType.Up, MouseButton = button };
lock (MouseInputEvents)
MouseInputEvents.Add(mouseInputEvent);
MouseButtonCurrentlyDown[buttonId] = false;
HandlePointerEvents(buttonId, CurrentMousePosition, PointerState.Up, PointerType.Mouse);
}
private void MouseButtonDownInternal(object _sender, MouseButtonEventArgs _e)
{
EMouseButton btn = EMouseButton.LEFT;
switch (_e.Button)
{
case MouseButton.Left:
btn = EMouseButton.LEFT;
break;
case MouseButton.Middle:
btn = EMouseButton.MIDDLE;
break;
case MouseButton.Right:
btn = EMouseButton.RIGHT;
break;
}
MouseButtonDown(new Point(_e.X / Constants.TILE_SIZE, _e.Y / Constants.TILE_SIZE), btn);
}
protected void MouseClick(object s, OpenTK.Input.MouseButtonEventArgs e)
{
if (e.Button == OpenTK.Input.MouseButton.Left)
{
mouseLock = !mouseLock;
if (mouseLock)
{
System.Windows.Forms.Cursor.Hide();
System.Windows.Forms.Cursor.Position =
new Point(Bounds.Left + (Bounds.Width / 2), Bounds.Top + (Bounds.Height / 2));
}
else
{
System.Windows.Forms.Cursor.Show();
}
}
}
public bool OnRaycastHitchanged(Input input, QbMatrix matrix, RaycastHit hit, ref Colort color, MouseButtonEventArgs e)
{
lastmatrix = matrix;
switch (state)
{
case ToolState.Start:
if ((e != null && e.IsPressed && e.Button == MouseButton.Left) || (e == null && input.mousedown(MouseButton.Left)))
{
state = ToolState.Base;
Singleton<Raycaster>.INSTANCE.testdirt = true;
startPosition = new VoxelLocation(hit, false);
endPosition = new VoxelLocation(hit, false);
volume = new VoxelVolume(startPosition, endPosition);
modifiedVoxels.Clear();
EnumerateVolume(volume, lastvolume, matrix, ref color, modifiedVoxels);
lastvolume = volume;
return true;
}
break;
case ToolState.Base:
if ((e != null && e.IsPressed && e.Button == MouseButton.Left) || (e == null && input.mousedown(MouseButton.Left)))
{
endPosition = new VoxelLocation(hit, false);
volume = new VoxelVolume(startPosition, endPosition);
EnumerateVolume(volume, lastvolume, matrix, ref color, modifiedVoxels);
CleanLastVolume(lastvolume, volume, matrix, modifiedVoxels);
lastvolume = volume;
return true;
}
else if ((e != null && !e.IsPressed && e.Button == MouseButton.Left) || (e == null && input.mouseup(MouseButton.Left)))
{
state = ToolState.Start;
lastvolume = VoxelVolume.NEGATIVE_ZERO;
Singleton<UndoRedo>.INSTANCE.AddUndo(BrushType, matrix, volume, color, modifiedVoxels);
return true;
}
break;
case ToolState.Limit:
break;
}
return false;
}
public override void OnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
IsMouseDown = true;
base.OnMouseDown(e);
Invalidate();
if (IsAutofire)
{
if (Enabled && WidgetState == WidgetStates.Pressed)
{
try {
OnFire();
Timer.Start();
} catch (Exception ex) {
ex.LogWarning();
}
}
}
}
public void processMouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
if (CardInstance.selectedCard == null)
{
return;
}
switch (e.Button)
{
case OpenTK.Input.MouseButton.Left:
ClickOnCard(CardInstance.selectedCard);
break;
case OpenTK.Input.MouseButton.Right:
CardInstance.selectedCard.SwitchFocus();
break;
}
}
protected override void OnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
var mouseX = e.Position.X - 300;
var mouseY = 300 - e.Position.Y;
if (this.criandoObjeto && !this.criandoFilho)
{
this.criarObjeto(mouseX, mouseY);
}
else if (this.criandoFilho)
{
this.criarFilho(mouseX, mouseY);
}
else
{
this.selecionarObjeto(mouseX, mouseY);
}
}
protected virtual void mouseDownHandler(object sender, MouseButtonEventArgs e)
{
if (!base.Focused) return;
this.mouseButtonDown = true;
// cast ray for mouse click
var clientRect = new System.Drawing.Size(ClientRectangle.Width, ClientRectangle.Height);
Vector2 mouseLoc = new Vector2(e.X,e.Y);
SSRay ray = OpenTKHelper.MouseToWorldRay(
this.scene.renderConfig.projectionMatrix, this.scene.renderConfig.invCameraViewMatrix, clientRect, mouseLoc);
// Console.WriteLine("mouse ({0},{1}) unproject to ray ({2})",e.X,e.Y,ray);
// scene.addObject(new SSObjectRay(ray));
selectedObject = scene.Intersect(ref ray);
updateWireframeDisplayText ();
}
protected override void OnMouseDown(MouseButtonEventArgs e)
{
switch (Settings.gameStatus)
{
case Settings.GameStatus.Startmenu:
Menu.OnMouseDown(e);
break;
case Settings.GameStatus.Gamewindow:
break;
case Settings.GameStatus.Optionsmenu:
Menu.OnMouseDown(e);
break;
case Settings.GameStatus.Highscoresmenu:
Menu.OnMouseDown(e);
break;
default:
break;
}
}
void Mouse_ButtonEvent(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
_MouseBtnState = 0;
if (e.Button == MouseButton.Left && e.IsPressed)
{
_MouseBtnState |= 1;
}
if (e.Button == MouseButton.Right && e.IsPressed)
{
_MouseBtnState |= 2;
}
if (e.Button == MouseButton.Middle && e.IsPressed)
{
_MouseBtnState |= 4;
}
Input.MouseEvent(_MouseBtnState);
}
private void GameWindow_MouseDown(object sender, MouseButtonEventArgs e)
{
//transform window coordinates to grid coordinates
var gridX = (e.X * gameState.GridWidth) / (gameWindow.Width - 1);
var gridY = (e.Y * gameState.GridHeight) / (gameWindow.Height - 1);
FieldType field;
switch (e.Button)
{
case MouseButton.Left:
field = FieldType.CROSS;
break;
case MouseButton.Right:
field = FieldType.DIAMONT;
break;
default:
field = FieldType.EMPTY;
break;
}
gameState[gridX, gridY] = field;
}
// TODO unify this with Android code
private void OnMouseButtonChange(object sender, MouseButtonEventArgs e)
{
double now = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
float xConversion = SparrowSharpApp.Stage.Width / Size.Width;
float yConversion = SparrowSharpApp.Stage.Height / Size.Height;
Touch touchInFocus;
if (e.Mouse.LeftButton == ButtonState.Pressed)
{
Touch newTouch = new Touch();
newTouch.TouchID = pointerId;
newTouch.TimeStamp = now;
newTouch.GlobalX = e.Mouse.X * xConversion;
newTouch.GlobalY = e.Mouse.Y * yConversion;
newTouch.InitialGlobalX = newTouch.GlobalX;
newTouch.InitialGlobalY = newTouch.GlobalY;
newTouch.Phase = TouchPhase.Began;
Point touchPosition = Point.Create(newTouch.GlobalX, newTouch.GlobalY);
newTouch.Target = SparrowSharpApp.Stage.HitTestPoint(touchPosition);
_touches.Add(newTouch.TouchID, newTouch);
}
else
{
touchInFocus = _touches[pointerId];
touchInFocus.Phase = TouchPhase.Ended;
long downTime = -1; // TODO
touchInFocus.TimeStamp = now;
double dist = Math.Sqrt(
(touchInFocus.GlobalX - touchInFocus.InitialGlobalX) * (touchInFocus.GlobalX - touchInFocus.InitialGlobalX) +
(touchInFocus.GlobalY - touchInFocus.InitialGlobalY) * (touchInFocus.GlobalY - touchInFocus.InitialGlobalY));
// TODO: move the time out to a constant, make dist DPI dependent
if (downTime < 300 && dist < 50)
{
touchInFocus.IsTap = true;
}
}
processTouch();
}
private void OpenTKButtonUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
MouseButton button;
if (e.Button == OpenTK.Input.MouseButton.Left)
{
button = MouseButton.Left;
}
else if (e.Button == OpenTK.Input.MouseButton.Middle)
{
button = MouseButton.Middle;
}
else if (e.Button == OpenTK.Input.MouseButton.Right)
{
button = MouseButton.Right;
}
else
{
return;
}
OnButtonUp(e.Position, button);
}
void OpenGLTess_MouseDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
if (!_enabled)
{
return;
}
if (_state == State.NONE)
{
if (OpenTK.Input.Mouse.GetState()[MouseButton.Right])
{
_state = State.PAN;
}
else
{
_state = State.ROTATE;
}
// _state = e.Button;// event.button;
}
if (_state == State.ROTATE && !_noRotate)
{
_rotateStart = GetMouseProjectionOnBall(e.X, e.Y);
_rotateEnd = _rotateStart;
}
else if (_state == State.ZOOM && !_noZoom)
{
_zoomStart = GetMouseOnScreen(e.X, e.Y);
_zoomEnd = _zoomStart;
}
else if (_state == State.PAN && !_noPan)
{
_panStart = GetMouseOnScreen(e.X, e.Y);
_panEnd = _panStart;
}
}
public bool OnRaycastHitchanged(Input input, QbMatrix matrix, RaycastHit hit, ref Colort color, MouseButtonEventArgs e)
{
if (matrix == null)
{
if (lastmatrix != null)
{
lastmatrix.highlight = Color4.White;
lastmatrix = null;
Singleton<GUI>.INSTANCE.Get<Label>(GUIID.STATUS_TEXT).text = "";
}
return true;
}
if(matrix != lastmatrix)
{
if (lastmatrix != null)
lastmatrix.highlight = Color4.White;
matrix.highlight = new Colort(1.5f, 1.5f, 1.5f);
lastmatrix = matrix;
Singleton<GUI>.INSTANCE.Get<Label>(GUIID.STATUS_TEXT).text = $"Over Matrix : {matrix.name}";
}
return true;
}
void Mouse_ButtonUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
}
private void MouseKeyboard_MouseDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
_xOffset = e.X;
_yOffset = e.Y;
_mouseButton = e.Button;
}
protected void OnMouseButtonUp(object sender, MouseButtonEventArgs e)
{
if (!Focused)
return;
gwenInput.ProcessMouseMessage(e);
}
public void GameWindow_MouseUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
mouseClicked = false;
}
/// <summary>
/// Called when mouse button is released.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="mouseArgs">The <see cref="MouseButtonEventArgs"/> instance containing the event data.</param>
protected void OnGameWinMouseUp(object sender, MouseButtonEventArgs mouseArgs)
{
if (MouseButtonUp != null)
{
var mb = MouseButtons.Unknown;
switch (mouseArgs.Button)
{
case MouseButton.Left:
mb = MouseButtons.Left;
break;
case MouseButton.Middle:
mb = MouseButtons.Middle;
break;
case MouseButton.Right:
mb = MouseButtons.Right;
break;
}
MouseButtonUp(this, new MouseEventArgs
{
Button = mb,
Position = new Point {x = mouseArgs.X, y = mouseArgs.Y}
});
}
}
public void GameWindow_MouseDown(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
mouseButtonDown = true;
}
public void OnMouseDown(MouseButtonEventArgs e)
{
}
private void MouseKeyboard_MouseUp(object sender, OpenTK.Input.MouseButtonEventArgs e)
{
OnChangeOrientPosZoomOperationCompleted(new EventArgs());
}
