protected override bool OnScrollEvent(EventScroll evnt)
{
if ((evnt.State & ModifierType.ShiftMask) == 0) //no shift, let's zoom
{
ZoomAboutPoint((evnt.Direction == ScrollDirection.Up || evnt.Direction == ScrollDirection.Right) ? ZOOM_FACTOR : 1.0 / ZOOM_FACTOR,
(int)evnt.X, (int)evnt.Y);
return(true);
}
int x_incr = (int)Hadjustment.PageIncrement / 4;
int y_incr = (int)Vadjustment.PageIncrement / 4;
if ((evnt.State & ModifierType.ControlMask) == 0) //no control scroll
{
ScrollBy((evnt.Direction == ScrollDirection.Left) ? -x_incr : (evnt.Direction == ScrollDirection.Right) ? x_incr : 0,
(evnt.Direction == ScrollDirection.Up) ? -y_incr : (evnt.Direction == ScrollDirection.Down) ? y_incr : 0);
return(true);
}
else //invert x and y for scrolling
{
ScrollBy((evnt.Direction == ScrollDirection.Up) ? -y_incr : (evnt.Direction == ScrollDirection.Down) ? y_incr : 0,
(evnt.Direction == ScrollDirection.Left) ? -x_incr : (evnt.Direction == ScrollDirection.Right) ? x_incr : 0);
return(true);
}
}
protected override bool OnScrollEvent(EventScroll evnt)
{
double step = 1;
var delta = new Vector();
if (evnt.Direction == ScrollDirection.Down)
{
delta = new Vector(0, -step);
}
else if (evnt.Direction == ScrollDirection.Up)
{
delta = new Vector(0, step);
}
else if (evnt.Direction == ScrollDirection.Right)
{
delta = new Vector(-step, 0);
}
if (evnt.Direction == ScrollDirection.Left)
{
delta = new Vector(step, 0);
}
var e = new RawMouseWheelEventArgs(GtkMouseDevice.Instance, evnt.Time, _inputRoot, new Point(evnt.X, evnt.Y), delta, GetModifierKeys(evnt.State));
Input(e);
return(base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll e)
{
int delta;
#if NETFRAMEWORK
delta = e.Direction == Gdk.ScrollDirection.Down ? -120 : 120;
#else
if (e.Direction == Gdk.ScrollDirection.Smooth)
{
delta = e.DeltaY < 0 ? mouseWheelScrollRows : -mouseWheelScrollRows;
}
else
{
delta = e.Direction == Gdk.ScrollDirection.Down ? -mouseWheelScrollRows : mouseWheelScrollRows;
}
#endif
if (delta < 0)
{
ScrollDown();
}
else
{
ScrollUp();
}
Refresh();
return(true);
}
protected override bool OnScrollEvent(EventScroll evnt)
{
if (!this.IsFocus)
{
return(false);
}
return(base.OnScrollEvent(evnt));
}
/// <summary>
/// Creates the mouse wheel event arguments.
/// </summary>
/// <param name="e">The scroll event args.</param>
/// <returns>Mouse event arguments.</returns>
public static OxyMouseWheelEventArgs ToMouseWheelEventArgs(this EventScroll e)
{
return(new OxyMouseWheelEventArgs
{
Delta = e.Direction == ScrollDirection.Down ? -120 : 120,
Position = new ScreenPoint(e.X, e.Y),
ModifierKeys = GetModifiers(e.State)
});
}
protected override bool OnScrollEvent(EventScroll evnt)
{
if (string.IsNullOrEmpty(this.Text) || !this.IsFocus)
{
return(false);
}
this.KeyScroll(evnt.Direction == ScrollDirection.Up ? 0 : 1);
return(true);
}
protected override bool OnScrollEvent(EventScroll evnt)
{
Scrollbar scrollWidget = (evnt.Direction == ScrollDirection.Up || evnt.Direction == ScrollDirection.Down) ? (Scrollbar)vScrollBar : leftHScrollBar;
if (scrollWidget.Visible)
{
double newValue = scrollWidget.Adjustment.Value + GetWheelDelta(scrollWidget, evnt.Direction);
newValue = System.Math.Max(System.Math.Min(scrollWidget.Adjustment.Upper - scrollWidget.Adjustment.PageSize, newValue), scrollWidget.Adjustment.Lower);
scrollWidget.Adjustment.Value = newValue;
}
return(base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll evnt)
{
var adjustment = (evnt.Direction == ScrollDirection.Up || evnt.Direction == ScrollDirection.Down) ? vAdjustment : hAdjustment;
if (adjustment.PageSize < adjustment.Upper)
{
double newValue = adjustment.Value + GetWheelDelta(adjustment, evnt.Direction);
newValue = System.Math.Max(System.Math.Min(adjustment.Upper - adjustment.PageSize, newValue), adjustment.Lower);
adjustment.Value = newValue;
}
return(base.OnScrollEvent(evnt));
}
/// <summary>
/// Called when [scroll event].
/// </summary>
/// <param name="evnt">The evnt.</param>
/// <returns></returns>
protected override bool OnScrollEvent(EventScroll evnt)
{
if (evnt.Direction == ScrollDirection.Up)
{
WaveServices.Input.MouseState.Wheel += 1;
}
else if (evnt.Direction == ScrollDirection.Down)
{
WaveServices.Input.MouseState.Wheel -= 1;
}
return(base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll evnt)
{
var scrollWidget = (evnt.Direction == ScrollDirection.Up || evnt.Direction == ScrollDirection.Down) ? vScrollBar : hScrollBar;
var adj = (evnt.Direction == ScrollDirection.Up || evnt.Direction == ScrollDirection.Down) ? vAdjustment : hAdjustment;
if (scrollWidget.Visible)
{
double newValue = adj.Value + GetWheelDelta(adj, evnt.Direction, scrollWidget is Scrollbar ? ((Scrollbar)scrollWidget).Inverted : false);
newValue = System.Math.Max(System.Math.Min(adj.Upper - adj.PageSize, newValue), adj.Lower);
adj.Value = newValue;
}
return(base.OnScrollEvent(evnt));
}
private static bool GetContact(Event evt)
{
var state = evt switch
{
EventMotion motion => motion.State,
EventButton button when button.Type == EventType.ButtonPress => ModifierType.Button1Mask,
EventScroll scroll => scroll.State,
_ => ModifierType.None,
};
return
(state.HasFlag(ModifierType.Button1Mask) ||
state.HasFlag(ModifierType.Button2Mask) ||
state.HasFlag(ModifierType.Button3Mask));
}
private void ProcessEventScroll(EventScroll ev)
{
var windowReg = FindWindow(ev.Window);
if (windowReg == null)
{
return;
}
var eventArgs = new MouseWheelEventArgs(
((float)ev.XOffset, (float)ev.YOffset),
new ScreenCoordinates(windowReg.LastMousePos, windowReg.Id));
_clyde.SendScroll(eventArgs);
}
//MOUSE WHEEL
protected override bool OnScrollEvent(EventScroll evnt)
{
//daca este inainte este pozitiva, daca este inapoi este negativa valoarea delta
int delta = 120;
if (evnt.Direction == ScrollDirection.Down)
{
delta = 0 - delta;
}
GcMouseEventArgs args = new GcMouseEventArgs(this, 0, delta, (int)evnt.X, (int)evnt.Y, MouseButton.None);
if (MouseWheel != null)
{
MouseWheel(this, args);
}
return(base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll evnt)
{
if ((evnt.State & Gdk.ModifierType.ControlMask) == Gdk.ModifierType.ControlMask)
{
if (evnt.Direction == ScrollDirection.Down)
{
Options.ZoomIn();
}
else
{
Options.ZoomOut();
}
this.Repaint();
return(true);
}
return(base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll evnt)
{
var alloc = Allocation;
double dx, dy;
evnt.GetPageScrollPixelDeltas(alloc.Width, alloc.Height, out dx, out dy);
if (dx != 0.0 && hScrollBar.Visible)
{
hAdjustment.AddValueClamped(dx);
}
if (dy != 0.0 && vScrollBar.Visible)
{
vAdjustment.AddValueClamped(dy);
}
return((dx != 0.0 || dy != 0.0) || base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll evnt)
{
// Allow the user to zoom in/out with Ctrl-Mousewheel
if (FilterModifierKeys(evnt.State) == ModifierType.ControlMask)
{
switch (evnt.Direction)
{
case ScrollDirection.Down:
case ScrollDirection.Right:
PintaCore.Workspace.ActiveWorkspace.ZoomOutFromMouseScroll(new Cairo.PointD(evnt.X, evnt.Y));
return(true);
case ScrollDirection.Left:
case ScrollDirection.Up:
PintaCore.Workspace.ActiveWorkspace.ZoomInFromMouseScroll(new Cairo.PointD(evnt.X, evnt.Y));
return(true);
}
}
return(base.OnScrollEvent(evnt));
}
// FIXME: if the editors have different adjustment ranges, the pixel deltas
// don't really feel quite right since they're applied after scaling via the
// linked adjustment
protected override bool OnScrollEvent(EventScroll evnt)
{
//using the size of an editor for the calculations means pixel deltas apply better
var alloc = editors[0].Allocation;
double dx, dy;
evnt.GetPageScrollPixelDeltas(alloc.Width, alloc.Height, out dx, out dy);
if (dx != 0.0 && hAdjustment.PageSize < (hAdjustment.Upper - hAdjustment.Lower))
{
hAdjustment.AddValueClamped(dx / (alloc.Width / hAdjustment.PageSize));
}
if (dy != 0.0 && vAdjustment.PageSize < (vAdjustment.Upper - vAdjustment.Lower))
{
vAdjustment.AddValueClamped(dy / (alloc.Height / vAdjustment.PageSize));
}
return((dx != 0.0 || dy != 0.0) || base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll scroll)
{
if ((scroll.State & ModifierType.ControlMask) != 0)
{
switch (scroll.Direction)
{
case ScrollDirection.Up:
ZoomIn();
break;
case ScrollDirection.Down:
ZoomOut();
break;
case (ScrollDirection)4: // GDK_SCROLL_SMOOTH
double delta_x;
double delta_y;
gdk_event_get_scroll_deltas(scroll.Handle, out delta_x, out delta_y);
smooth_scroll_size += delta_y;
if (smooth_scroll_size < -1)
{
ZoomIn();
smooth_scroll_size += 1;
}
else if (smooth_scroll_size > 1)
{
ZoomOut();
smooth_scroll_size -= 1;
}
break;
default:
return(base.OnScrollEvent(scroll));
}
return(true);
}
return(base.OnScrollEvent(scroll));
}
protected override bool OnScrollEvent(EventScroll evnt)
{
// Allow the user to zoom in/out with Ctrl-Mousewheel
if (evnt.State.FilterModifierKeys() == ModifierType.ControlMask)
{
switch (evnt.Direction)
{
case ScrollDirection.Down:
case ScrollDirection.Right:
document.Workspace.ZoomOutFromMouseScroll(new Cairo.PointD(evnt.X, evnt.Y));
return(true);
case ScrollDirection.Left:
case ScrollDirection.Up:
document.Workspace.ZoomInFromMouseScroll(new Cairo.PointD(evnt.X, evnt.Y));
return(true);
}
}
// Allow the user to scroll left/right with Shift-Mousewheel
if (evnt.State.FilterModifierKeys() == ModifierType.ShiftMask)
{
switch (evnt.Direction)
{
case ScrollDirection.Down:
case ScrollDirection.Right:
document.Workspace.ScrollCanvas(hScrollAmount, 0);
return(true);
case ScrollDirection.Up:
case ScrollDirection.Left:
document.Workspace.ScrollCanvas(-hScrollAmount, 0);
return(true);
}
}
return(base.OnScrollEvent(evnt));
}
protected override bool OnScrollEvent(EventScroll args)
{
float shift = 1.0f;
if ((args.State & Gdk.ModifierType.ShiftMask) > 0)
{
shift = 6f;
}
switch (args.Direction)
{
case ScrollDirection.Up:
case ScrollDirection.Right:
Position -= shift;
return(true);
case Gdk.ScrollDirection.Down:
case Gdk.ScrollDirection.Left:
Position += shift;
return(true);
}
return(false);
}
protected override bool OnScrollEvent(EventScroll e)
{
try
{
int delta;
if (e.Direction == Gdk.ScrollDirection.Smooth)
{
delta = e.DeltaY < 0 ? mouseWheelScrollRows : -mouseWheelScrollRows;
}
else
{
delta = e.Direction == Gdk.ScrollDirection.Down ? -mouseWheelScrollRows : mouseWheelScrollRows;
}
sheet.InvokeScroll(delta);
}
catch (Exception err)
{
ViewBase.MasterView.ShowError(err);
}
return(true);
}
protected override bool OnScrollEvent(EventScroll evnt)
{
float shift = 1f;
if ((evnt.State & ModifierType.ShiftMask) > 0)
{
shift = 6f;
}
switch (evnt.Direction)
{
case ScrollDirection.Up:
case ScrollDirection.Right:
Position = animation.To - shift;
return(true);
case ScrollDirection.Down:
case ScrollDirection.Left:
Position = animation.To + shift;
return(true);
}
return(false);
}
public bool HandleScroll(EventScroll args)
{
if (editable)
{
switch (args.Direction)
{
case Gdk.ScrollDirection.Up:
case Gdk.ScrollDirection.Right:
Value++;
return(true);
case Gdk.ScrollDirection.Down:
case Gdk.ScrollDirection.Left:
Value--;
return(true);
}
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// Called when the mouse wheel is scrolled.
/// </summary>
/// <param name="e">An instance that contains the event data.</param>
/// <returns><c>true</c> if the event was handled.</returns>
protected override bool OnScrollEvent(EventScroll e)
{
return(this.ActualController.HandleMouseWheel(this, e.ToMouseWheelEventArgs()));
}
private PointerPointProperties BuildProperties(EventScroll scrollEvent)
=> new PointerPointProperties
{
MouseWheelDelta = scrollEvent.DeltaX != 0 ? (int)scrollEvent.DeltaX : (int)scrollEvent.DeltaY,
IsHorizontalMouseWheel = scrollEvent.DeltaX != 0,
};
protected override bool OnScrollEvent(EventScroll args)
{
return(HandleScroll(args));
}
