private void DiagramManager_Wheel(WheelEventArgs e)
{
if (!DiagramManager.Options.AllowZooming)
{
return;
}
var oldZoom = DiagramManager.Zoom;
var deltaY = DiagramManager.Options.InverseZoom ? e.DeltaY * -1 : e.DeltaY;
var newZoom = deltaY > 0 ? oldZoom * _scaleBy : oldZoom / _scaleBy;
if (newZoom < 0)
{
return;
}
// Other algorithms (based only on the changes in the zoom) don't work for our case
// This solution is taken as is from react-diagrams (ZoomCanvasAction)
var clientWidth = DiagramManager.Container.Width;
var clientHeight = DiagramManager.Container.Height;
var widthDiff = clientWidth * newZoom - clientWidth * oldZoom;
var heightDiff = clientHeight * newZoom - clientHeight * oldZoom;
var clientX = e.ClientX - DiagramManager.Container.Left;
var clientY = e.ClientY - DiagramManager.Container.Top;
var xFactor = (clientX - DiagramManager.Pan.X) / oldZoom / clientWidth;
var yFactor = (clientY - DiagramManager.Pan.Y) / oldZoom / clientHeight;
var newPanX = DiagramManager.Pan.X - widthDiff * xFactor;
var newPanY = DiagramManager.Pan.Y - heightDiff * yFactor;
DiagramManager.Pan = new Point(newPanX, newPanY);
DiagramManager.ChangeZoom(newZoom);
}
private void OnMouseWheel(WheelEventArgs e)
{
NavigationSettings.OnMouseWheel(e);
Nodes.ReRenderIfOffCanvasChanged();
Links.TriggerStateHasChanged();
Overview?.TriggerUpdate(just_pan_or_zoom: true);
}
protected virtual void OnScrolled(WheelEventArgs e)
{
if (Scrolled != null)
{
Scrolled(this, e);
}
}
internal static WheelEventArgs Read(JsonElement jsonElement)
{
var eventArgs = new WheelEventArgs();
foreach (var property in jsonElement.EnumerateObject())
{
if (property.NameEquals(DeltaX.EncodedUtf8Bytes))
{
eventArgs.DeltaX = property.Value.GetDouble();
}
else if (property.NameEquals(DeltaY.EncodedUtf8Bytes))
{
eventArgs.DeltaY = property.Value.GetDouble();
}
else if (property.NameEquals(DeltaZ.EncodedUtf8Bytes))
{
eventArgs.DeltaZ = property.Value.GetDouble();
}
else if (property.NameEquals(DeltaMode.EncodedUtf8Bytes))
{
eventArgs.DeltaMode = property.Value.GetInt64();
}
else
{
MouseEventArgsReader.ReadProperty(eventArgs, property);
}
}
return(eventArgs);
}
protected async Task OnMouseWheel(WheelEventArgs obj)
{
if (!obj.ShiftKey || Disabled || ReadOnly)
{
return;
}
if (obj.DeltaY < 0)
{
if (InvertMouseWheel == false)
{
await Increment();
}
else
{
await Decrement();
}
}
else if (obj.DeltaY > 0)
{
if (InvertMouseWheel == false)
{
await Decrement();
}
else
{
await Increment();
}
}
}
void UpdateSlidersFromWheel(object sender, WheelEventArgs e)
{
blockChangePoint = true;
switch (SelectedSlider.SliderType)
{
case SliderTypeEnum.RGB:
//SelectedSlider.PatternPoint.L = (double)e.NewValue;
SelectedSlider.PatternPoint.SaveLightness();
lightSlider.Value = SelectedSlider.PatternPoint.L;
break;
case SliderTypeEnum.W:
case SliderTypeEnum.WT:
whiteSlider.Value = SelectedSlider.PatternPoint.WhiteD;
break;
case SliderTypeEnum.Warm:
warmSlider.Value = SelectedSlider.PatternPoint.WarmD;
break;
case SliderTypeEnum.Cold:
coldSlider.Value = SelectedSlider.PatternPoint.ColdD;
break;
}
blockChangePoint = false;
}
private bool RotarySelector_WheelEvent(object source, WheelEventArgs e)
{
if (e.Wheel.Type == Wheel.WheelType.CustomWheel)
{
rotarySelectorManager.SelectItemByWheel(e.Wheel.Direction);
}
return(false);
}
private void OnDetentEvent(IntPtr wheelEvent)
{
WheelEventArgs e = new WheelEventArgs();
if (wheelEvent != global::System.IntPtr.Zero)
{
e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
}
DetentEventHandler?.Invoke(this, e);
}
private void HandleWheel(object sender, WheelEventArgs inputEvent)
{
var wheel = "Wheel event:" +
$" modifier: {ModifierToString((uint)inputEvent.Modifiers)}" +
$" deltax: {inputEvent.Delta.X}" +
$" deltay: {inputEvent.Delta.Y}" +
$" wheel_ticks_x: {inputEvent.Ticks.X}" +
$" wheel_ticks_y: {inputEvent.Ticks.Y}" +
$" scroll_by_page: {inputEvent.IsScrollByPage}" +
$" time: {inputEvent.TimeStamp}";
PostMessage(wheel);
inputEvent.Handled = true;
}
private void OnWindowWheelEvent(object sender, Window.WheelEventArgs e)
{
if (e != null)
{
if (e.Wheel.Type == Wheel.WheelType.CustomWheel)
{
var arg = new WheelEventArgs()
{
Wheel = e.Wheel,
};
WindowWheelEventHandler?.Invoke(this, arg);
}
}
}
private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
{
if (wheelEvent == global::System.IntPtr.Zero)
{
NUILog.Error("wheelEvent should not be null!");
return(true);
}
if (stageWheelHandler != null)
{
WheelEventArgs e = new WheelEventArgs();
e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
stageWheelHandler(this, e);
}
return(true);
}
public async Task OnScroll(WheelEventArgs e)
{
if (e.DeltaY > 0)
{
if (ZoomService.ZoomOut(SVGControl))
{
await SVGControlChanged.InvokeAsync(SVGControl);
}
}
else if (e.DeltaY < 0)
{
if (ZoomService.ZoomIn(SVGControl))
{
await SVGControlChanged.InvokeAsync(SVGControl);
}
}
}
// Callback for View Wheel signal
private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
{
if (wheelEvent == global::System.IntPtr.Zero)
{
NUILog.Error("wheelEvent should not be null!");
return(true);
}
WheelEventArgs e = new WheelEventArgs();
e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
if (_wheelEventHandler != null)
{
return(_wheelEventHandler(this, e));
}
return(false);
}
private void Diagram_Wheel(WheelEventArgs e)
{
if (Diagram.Container == null || e.DeltaY == 0)
{
return;
}
if (!Diagram.Options.Zoom.Enabled)
{
return;
}
var scale = Math.Clamp(Diagram.Options.Zoom.ScaleFactor, 1.01, 2);
var oldZoom = Diagram.Zoom;
var deltaY = Diagram.Options.Zoom.Inverse ? e.DeltaY * -1 : e.DeltaY;
var newZoom = deltaY > 0 ? oldZoom * scale : oldZoom / scale;
newZoom = Math.Clamp(newZoom, Diagram.Options.Zoom.Minimum, Diagram.Options.Zoom.Maximum);
if (newZoom < 0 || newZoom == Diagram.Zoom)
{
return;
}
// Other algorithms (based only on the changes in the zoom) don't work for our case
// This solution is taken as is from react-diagrams (ZoomCanvasAction)
var clientWidth = Diagram.Container.Width;
var clientHeight = Diagram.Container.Height;
var widthDiff = clientWidth * newZoom - clientWidth * oldZoom;
var heightDiff = clientHeight * newZoom - clientHeight * oldZoom;
var clientX = e.ClientX - Diagram.Container.Left;
var clientY = e.ClientY - Diagram.Container.Top;
var xFactor = (clientX - Diagram.Pan.X) / oldZoom / clientWidth;
var yFactor = (clientY - Diagram.Pan.Y) / oldZoom / clientHeight;
var newPanX = Diagram.Pan.X - widthDiff * xFactor;
var newPanY = Diagram.Pan.Y - heightDiff * yFactor;
Diagram.Batch(() =>
{
Diagram.SetPan(newPanX, newPanY);
Diagram.SetZoom(newZoom);
});
}
void OnDrawAreaWheel(object sender, WheelEventArgs e)
{
Drawing drw = CurrentDrawing;
if (drw != null)
{
double scale;
if (e.Delta < 0)
{
scale = 0.8;
}
else
{
scale = 1.0 / 0.8;
}
drw.ViewTransform = drw.ViewTransform * Transform2d.Translate(-cursorpixel.X, -cursorpixel.Y) * Transform2d.Scale(scale) * Transform2d.Translate(cursorpixel.X, cursorpixel.Y);
drawarea.Redraw();
}
}
public void Read_Works()
{
// Arrange
var args = new WheelEventArgs
{
AltKey = false,
CtrlKey = true,
MetaKey = true,
ShiftKey = false,
Type = "type1",
Detail = 789,
Button = 7,
Buttons = 234,
ClientX = 3.2,
ClientY = 33.1,
DeltaMode = 2,
DeltaX = 11.1,
DeltaY = 21.2,
DeltaZ = 9.1,
OffsetX = 7.2,
OffsetY = 1.2,
PageX = 5.6,
PageY = 7.8,
ScreenX = 3.56,
ScreenY = 8.32,
};
var jsonElement = GetJsonElement(args);
// Act
var result = WheelEventArgsReader.Read(jsonElement);
// Assert
MouseEventArgsReaderTest.AssertEqual(args, result);
Assert.Equal(args.DeltaMode, result.DeltaMode);
Assert.Equal(args.DeltaX, result.DeltaX);
Assert.Equal(args.DeltaY, result.DeltaY);
Assert.Equal(args.DeltaZ, result.DeltaZ);
}
private static RawInputModifiers GetModifiers(WheelEventArgs e)
{
var modifiers = RawInputModifiers.None;
if (e.CtrlKey)
{
modifiers |= RawInputModifiers.Control;
}
if (e.AltKey)
{
modifiers |= RawInputModifiers.Alt;
}
if (e.ShiftKey)
{
modifiers |= RawInputModifiers.Shift;
}
if (e.MetaKey)
{
modifiers |= RawInputModifiers.Meta;
}
if ((e.Buttons & 1L) == 1)
{
modifiers |= RawInputModifiers.LeftMouseButton;
}
if ((e.Buttons & 2L) == 2)
{
modifiers |= RawInputModifiers.RightMouseButton;
}
if ((e.Buttons & 4L) == 4)
{
modifiers |= RawInputModifiers.MiddleMouseButton;
}
return(modifiers);
}
protected void MouseWheel(WheelEventArgs e)
{
Player.IncreaseZoom(-(float)(e.DeltaY / 100.0));
}
internal NativeWheelEventArgs(WheelEventArgs src, NativeJsObject jsObject)
{
CopyProps(src, this);
_jsObject = jsObject;
}
protected async Task OnMouseWheel(WheelEventArgs obj)
{
if (obj.ShiftKey == true && obj.DeltaY < 0)
{
if (InvertMouseWheel == false)
{
if (RuntimeLocation.IsServerSide)
{
if (!Immediate)
{
_key++;
await Task.Delay(1);
await Increment();
await Task.Delay(1);
_ = FocusAsync();
}
else
{
await Increment();
}
}
else
{
_key++;
await Task.Delay(1);
await Increment();
await Task.Delay(1);
_ = FocusAsync();
}
}
else
{
if (RuntimeLocation.IsServerSide)
{
if (!Immediate)
{
_key++;
await Task.Delay(1);
await Decrement();
await Task.Delay(1);
_ = FocusAsync();
}
else
{
await Decrement();
}
}
else
{
_key++;
await Task.Delay(1);
await Decrement();
await Task.Delay(1);
_ = FocusAsync();
}
}
}
else if (obj.ShiftKey == true && 0 < obj.DeltaY)
{
if (InvertMouseWheel == false)
{
if (RuntimeLocation.IsServerSide)
{
if (!Immediate)
{
_key++;
await Task.Delay(1);
await Decrement();
await Task.Delay(1);
_ = FocusAsync();
}
else
{
await Decrement();
}
}
else
{
_key++;
await Task.Delay(1);
await Decrement();
await Task.Delay(1);
_ = FocusAsync();
}
}
else
{
if (RuntimeLocation.IsServerSide)
{
if (!Immediate)
{
_key++;
await Task.Delay(1);
await Increment();
await Task.Delay(1);
_ = FocusAsync();
}
else
{
await Increment();
}
}
else
{
_key++;
await Task.Delay(1);
await Increment();
await Task.Delay(1);
_ = FocusAsync();
}
}
}
}
private void OnWheel(WheelEventArgs e)
{
_topLevelImpl.RawMouseWheelEvent(new Point(e.ClientX, e.ClientY),
new Vector(-(e.DeltaX / 50), -(e.DeltaY / 50)), GetModifiers(e));
}
protected void OnWheel(WheelEventArgs e) => DiagramManager.OnWheel(e);
private bool RaiseEvents(MouseEvent mouseEvent, MouseLLParam param)
{
try
{
_semaphore.Wait();
try
{
var(x, y) = param.pt;
MulticastDelegate e = null;
MouseEventArgs args = null;
switch (mouseEvent)
{
case MouseEvent.MouseMove:
e = MouseMove;
args = new MouseEventArgs(x, y);
break;
case MouseEvent.LeftButtonDown:
e = ButtonDown;
args = new ButtonEventArgs(x, y, MouseButton.Left);
break;
case MouseEvent.LeftButtonUp:
e = ButtonUp;
args = new ButtonEventArgs(x, y, MouseButton.Left);
break;
case MouseEvent.LeftButtonDoubleClick:
e = ButtonDoubleClick;
args = new ButtonEventArgs(x, y, MouseButton.Left);
break;
case MouseEvent.RightButtonDown:
e = ButtonDown;
args = new ButtonEventArgs(x, y, MouseButton.Right);
break;
case MouseEvent.RightButtonUp:
e = ButtonUp;
args = new ButtonEventArgs(x, y, MouseButton.Right);
break;
case MouseEvent.RightButtonDoubleClick:
e = ButtonDoubleClick;
args = new ButtonEventArgs(x, y, MouseButton.Right);
break;
case MouseEvent.MiddleButtonDown:
e = ButtonDown;
args = new ButtonEventArgs(x, y, MouseButton.Middle);
break;
case MouseEvent.MiddleButtonUp:
e = ButtonUp;
args = new ButtonEventArgs(x, y, MouseButton.Middle);
break;
case MouseEvent.MiddleButtonDoubleClick:
e = ButtonDoubleClick;
args = new ButtonEventArgs(x, y, MouseButton.Middle);
break;
case MouseEvent.XButtonDown:
e = ButtonDown;
args = new ButtonEventArgs(x, y, MouseButton.Fourth + (byte)(param.mouseData / 0x10000) - 1);
break;
case MouseEvent.XButtonUp:
e = ButtonUp;
args = new ButtonEventArgs(x, y, MouseButton.Fourth + (byte)(param.mouseData / 0x10000) - 1);
break;
case MouseEvent.XButtonDoubleClick:
e = ButtonDoubleClick;
args = new ButtonEventArgs(x, y, MouseButton.Fourth + (byte)(param.mouseData / 0x10000) - 1);
break;
case MouseEvent.MouseWheel:
e = Wheel;
args = new WheelEventArgs(x, y, param.mouseData > 0);
break;
case MouseEvent.MouseHorizontalWheel:
e = HorizontalWheel;
args = new WheelEventArgs(x, y, param.mouseData > 0);
break;
default:
break;
}
var l = e?.GetInvocationList();
if (l != null)
{
for (var i = l.Length; i-- > 0;)
{
try
{
var d = l[i];
d.Method.Invoke(d.Target, new object[] { this, args });
}
catch { }
if (args.Suppress)
{
return(true);
}
}
}
}
finally
{
_semaphore.Release();
}
}
catch (ObjectDisposedException) { }
return(false);
}
/// <summary>
/// Raises the <c>@onmousewheel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/>
/// to the event handler.
/// </summary>
/// <param name="element">The element to raise the event on.</param>
/// <param name="eventArgs">The event arguments to pass to the event handler.</param>
/// <returns>A task that completes when the event handler is done.</returns>
public static Task MouseWheelAsync(this IElement element, WheelEventArgs eventArgs) => element.TriggerEventAsync("onmousewheel", eventArgs);
/// <summary> /// Raises the <c>@onmousewheel</c> event on <paramref name="element"/>, passing the provided <paramref name="eventArgs"/> /// to the event handler. /// </summary> /// <param name="element">The element to raise the event on.</param> /// <param name="eventArgs">The event arguments to pass to the event handler.</param> public static void MouseWheel(this IElement element, WheelEventArgs eventArgs) => _ = MouseWheelAsync(element, eventArgs);
internal void OnWheel(WheelEventArgs e) => Wheel?.Invoke(e);
public void OnWheel(WheelEventArgs e)
{
bvgGrid.VerticalScroll.compBlazorScrollbar.DoWheel(e.DeltaY > 0);
}
public void OnWheel(WheelEventArgs e)
{
_parent.bsbScrollbar.CmdWhell(e.DeltaY > 0);
}
private void OnWheel(WheelEventArgs e) => Diagram.OnWheel(e);
