public override bool MouseWheelMove(MouseWheelScrollEventArgs e)
{
if (ClientArea.Contains(e.X, e.Y))
{
if (ScrollingNeeded())
{
if (e.Delta > 0)
{
if (ScrollOffset + 1 <= _items.Count - 1)
{
ScrollOffset++;
}
return(true);
}
else if (e.Delta < 0)
{
if (ScrollOffset - 1 >= 0)
{
ScrollOffset--;
}
return(true);
}
}
}
return(false);
}
public void MouseWheelMove(MouseWheelScrollEventArgs e)
{
if (CurrentState != null)
{
CurrentState.MouseWheelMove(e);
}
}
private void onMouseWheel(object sender, MouseWheelScrollEventArgs e)
{
_controllers.CurrentlyUsingController = false;
_mouse.WheelDelta = (double)e.Delta;
MouseWheel?.Invoke(sender, e);
}
public override bool MouseWheelMove(MouseWheelScrollEventArgs e)
{
if (base.MouseWheelMove(e))
{
return(true);
}
if (Disposing || !Visible)
{
return(false);
}
// since the RT is constructed at {0,0}, and then blitted to an offset position
// we have to offset the mouse screen pos by the blit offset.
var rtArgs = new MouseWheelScrollEventArgs(e.Position - Position, e.Wheel, e.Delta);
if (Container.MouseWheelMove(rtArgs))
{
return(true);
}
if (!ScrollbarV.Visible || !ClientArea.Translated(Position).Contains(e.X, e.Y))
{
return(false);
}
if (ScrollbarV.MouseWheelMove(e))
{
return(true);
}
return(false);
}
private void Window_MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
MouseWheelScrolled(
new Vector2(e.X, e.Y),
e.Delta,
(MouseWheel)e.Wheel
);
}
private void OnMouseScrolled(MouseWheelScrollEventArgs args)
{
MouseWheelScrolled?.Invoke(args);
if (!_blocked)
{
BlockableMouseWheelScrolled?.Invoke(args);
}
}
public override bool MouseWheelMove(MouseWheelScrollEventArgs e)
{
if (base.MouseWheelMove(e))
{
return(true);
}
return(false);
}
public override void Window_MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
float d = (float)Math.Abs(mainCamera.Near - Math.Round(mainCamera.Near)) / 2;
mainCamera.Near += d * -e.Delta;
mainCamera.Near = Math.Max(mainCamera.Near, 0.01f);
mainCamera.Near = Math.Min(mainCamera.Near, 0.99f);
}
protected virtual void OnMouseWheel(object sender, MouseWheelScrollEventArgs e)
{
usingController.Value = false;
Interlocked.Exchange(ref wheelDelta, e.Delta);
Interlocked.Exchange(ref currentWindow, (Display.Window)sender);
MouseWheel?.Invoke(sender, e);
}
internal virtual void GUI_MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
EventHandler <MouseWheelScrollEventArgs> handler = MouseWheelScrolled;
if ((handler != null) && IsActive && InsideElement(Mouse.GetPosition()))
{
handler(this, e);
}
}
public override void HandleInput(MouseWheelScrollEventArgs wheelEventArgs)
{
foreach (UIElement element in _gameUI.Elements)
{
if (element.Contains(wheelEventArgs.X, wheelEventArgs.Y))
{
element.OnScroll(wheelEventArgs.Delta);
}
}
}
internal void Window_MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
Key WheelEvent = e.Delta >= 0 ? Key.MouseWheelUp : Key.MouseWheelDown;
if (e.Delta != 0)
{
OnPressedEvent?.Invoke(WheelEvent, PlayerFlags.ANY_PLAYER);
OnReleasedEvent?.Invoke(WheelEvent, PlayerFlags.ANY_PLAYER);
}
}
/// <inheritdoc />
public void HandleMouseScrolled(object sender, MouseWheelScrollEventArgs eventArgs)
{
if (eventArgs.Delta > 0)
{
simulationDrawer.Scale(1 + Constants.ZoomStep);
}
else if (eventArgs.Delta < 0)
{
simulationDrawer.Scale(1 - Constants.ZoomStep);
}
}
public void ScrollWheel(object sender, MouseWheelScrollEventArgs e)
{
switch (Game.GameState)
{
case GameState.CardManager:
Game.cardManager.ScrollWheel(e);
break;
default:
break;
}
}
void OnMouseWheelScrolled(object sender, MouseWheelScrollEventArgs args)
{
int axis = args.Wheel switch
{
Mouse.Wheel.HorizontalWheel => 0,
Mouse.Wheel.VerticalWheel => 1,
_ => throw ExceptionHelper.Invalid(nameof(args.Wheel), args.Wheel, InvalidType.unexpected)
};
MouseHovering?.OnMouseScrolled(Float2.Create(axis, args.Delta));
}
}
/// <summary>
/// Handles MouseWheelMove event. Sent to Focused component. Returns true if component accepted and handled the event.
/// </summary>
public virtual void MouseWheelMove(MouseWheelScrollEventArgs e)
{
if (_console.Visible)
{
_console.MouseWheelMove(e);
}
foreach (var control in _components)
{
control.MouseWheelMove(e);
}
}
private void OnMouseScrolled(object sender, MouseWheelScrollEventArgs e)
{
if (MouseScrolledEvents == null)
{
return;
}
foreach (var evnt in MouseScrolledEvents)
{
evnt(new Vector2f(e.X, e.Y), e.Delta);
}
}
private void WindowOnMouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
if (e.Wheel != Mouse.Wheel.VerticalWheel)
{
return;
}
var window = (RenderWindow)sender;
var view = defaultView;
var zoom = e.Delta > 0 ? 1 / 1.1f : 1 * 1.1f;
view.Zoom(zoom);
}
private void OnMouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
Event ev = new Event
{
Type = EventType.MouseWheelScrolled
};
ev.MouseWheelScroll.Wheel = e.Wheel;
ev.MouseWheelScroll.Delta = e.Delta;
ev.MouseWheelScroll.X = e.X;
ev.MouseWheelScroll.Y = e.Y;
HandleEvent(ev);
}
public void ZoomViewEvent(object sender, MouseWheelScrollEventArgs args)
{
if (Engine.Instance.GameWindow.HasFocus() == true && IsStateActive == true)
{
if (args.Delta < 0 && View.Size.X <= 7000f)
{
View.Zoom(1.05f);
}
if (args.Delta > 0 && View.Size.X >= 1000f)
{
View.Zoom(0.95f);
}
}
}
private void MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
if (e.Wheel != Mouse.Wheel.VerticalWheel)
{
return;
}
if (e.Delta >= 1.0f)
{
MoveUp();
}
else if (e.Delta <= 1.0f)
{
MoveDown();
}
}
private static void OnMouseWheelScrolled(object sender, MouseWheelScrollEventArgs args)
{
var io = ImGui.GetIO();
switch (args.Wheel)
{
case Mouse.Wheel.VerticalWheel:
case Mouse.Wheel.HorizontalWheel when io.KeyShift:
io.MouseWheel += args.Delta;
break;
case Mouse.Wheel.HorizontalWheel:
io.MouseWheelH += args.Delta;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override bool MouseWheelMove(MouseWheelScrollEventArgs e)
{
foreach (var curr in _tabs)
{
if (curr.Key.MouseWheelMove(e))
{
return(true);
}
if (_activeTab != null)
{
if (_activeTab.MouseWheelMove(e))
{
return(true);
}
}
}
return(base.MouseWheelMove(e));
}
private void window_scroll(object sender, MouseWheelScrollEventArgs e)
{
if (current.drawable != null)
{
if (current.drawable.GetType() == typeof(CircleShape))
{
CircleShape c = current.drawable as CircleShape;
c.Radius += e.Delta;
current.drawable = c;
}
if (current.drawable.GetType() == typeof(Text))
{
SFML.Graphics.Text t = new Text((current.drawable as Text).DisplayedString, new Font(Properties.Resources.aileron_bold));
t.CharacterSize = (current.drawable as Text).CharacterSize + (uint)(e.Delta * 1.5f);
t.FillColor = currentColor;
current.drawable = t;
}
}
}
private void OnScroll(object sender, MouseWheelScrollEventArgs e)
{
if (e.Delta > 0)
{
componentindex++;
if (componentindex >= components.Count())
{
componentindex = 0;
}
}
else
{
componentindex--;
if (componentindex < 0)
{
componentindex = components.Count() - 1;
}
}
}
public void ScrollWheel(MouseWheelScrollEventArgs mouseWheel)
{
Console.WriteLine(mouseWheel.Delta);
var pos = window.MapPixelToCoords(new Vector2i(mouseWheel.X, mouseWheel.Y), Cardsview);
if (mouseWheel.Delta * -1 > 0)
{
if (Cardsview.Center.Y + Game.ScreenHeight / 2 <= maxScrollLength)
{
Cardsview.Move(new Vector2f(0, -2 * mouseWheel.Delta * 10));
}
}
else
{
if (Cardsview.Center.Y - Game.ScreenHeight / 2 - Card.height - 50 >= 0)
{
Cardsview.Move(new Vector2f(0, -2 * mouseWheel.Delta * 10));
}
}
}
public override bool MouseWheelMove(MouseWheelScrollEventArgs e)
{
if (ClientArea.Contains(e.X, e.Y))
{
if (e.Delta > 0)
{
if (Selected + 1 <= _items.Count - 1)
{
Selected++;
}
return(true);
}
else if (e.Delta < 0)
{
if (Selected - 1 >= 0)
{
Selected--;
}
return(true);
}
}
return(false);
}
private void Window_MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
/* Método chamado quando a roda do mouse é ativada */
// Caso seja ativado no menu move o menu para baixo e para cima
if (Mouse.GetPosition(window).X >= window.Size.X * Informacoes.propViewMundo)
{
if (e.Delta == 1 && coordViewMenu.Y >= yViewMenuInicial)
{
coordViewMenu.Y -= velViewMenu * deltatime;
viewMenu.Center = coordViewMenu;
menu.AtualizarPosicaoBackground(-velViewMenu * deltatime);
}
else if (e.Delta == -1)
{
coordViewMenu.Y += velViewMenu * deltatime;
viewMenu.Center = coordViewMenu;
menu.AtualizarPosicaoBackground(velViewMenu * deltatime);
}
}
// Caso seja ativado no mundo aplica mais ou menos zoom no mundo
else
{
if (e.Delta == 1)
{
viewMundo.Zoom(0.9f);
zoom++;
}
else if (e.Delta == -1)
{
viewMundo.Zoom(1.1f);
zoom--;
}
}
}
private void Window_MouseWheelMoved(object sender, MouseWheelScrollEventArgs e)
{
RenderWindow window = (RenderWindow)sender;
if (e.Delta < 0)
{
zoom = Math.Min(2, zoom + 0.1f);
}
else
{
zoom = Math.Max(0.5f, zoom - 0.1f);
}
View view = window.GetView();
view.Zoom(zoom);
window.SetView(view);
foreach (Drawable item in toDraw)
{
if (item is RectangleShape itemRect)
{
itemRect.OutlineThickness *= zoom;
}
}
}
private void RenderWindow_MouseWheelScrolled(object sender, MouseWheelScrollEventArgs e)
{
Console.WriteLine($"Mouse {e.Wheel} {e.Delta} x:{e.X}, y:{e.Y}");
}
