protected override bool OnScrollEvent(Gdk.EventScroll es)
{
bool result = base.OnScrollEvent(es);
if (!this.isScrollWheelScaling)
{
this.isScrollWheelScaling = true;
double mouseX = es.X;
double mouseY = es.Y;
DeviceToUser(ref mouseX, ref mouseY);
this.mousePressedUserX = mouseX;
this.mousePressedUserY = mouseY;
}
double scaleAdj = 1.0;
if (es.Direction == ScrollDirection.Down)
{
scaleAdj -= this.scrollUnits;
}
else if (es.Direction == ScrollDirection.Up)
{
scaleAdj += this.scrollUnits;
}
ValidateScaleAdj(ref scaleAdj);
if (scaleAdj != 1.0)
{
this.transformMatrix.Translate(mousePressedUserX, mousePressedUserY);
this.transformMatrix.Scale(scaleAdj, scaleAdj);
this.transformMatrix.Translate(-mousePressedUserX, -mousePressedUserY);
}
this.QueueDraw();
return(result);
}
void ScrollHandler(object o, ScrollEventArgs args)
{
Gdk.EventScroll es = args.Event;
double newloc = 0.0;
switch (es.Direction)
{
case ScrollDirection.Up:
newloc = adjustment.Value - visible_cols;
break;
case ScrollDirection.Down:
newloc = adjustment.Value + visible_cols;
break;
}
if (newloc < 0)
{
newloc = 0;
}
else if (newloc >= max_top)
{
newloc = Math.Max(max_top, 0);
}
adjustment.Value = newloc;
}
protected override bool OnScrollEvent(Gdk.EventScroll evnt)
{
if ((evnt.State & Gdk.ModifierType.ControlMask) != 0)
{
Zoom(evnt.Direction == ScrollDirection.Down ? -20 : 20);
return(true);
}
else
{
return(base.OnScrollEvent(evnt));
}
}
private void OnScrollEvent(object sender, ScrollEventArgs a)
{
Gdk.EventScroll ev = a.Event;
if (ev.Direction == ScrollDirection.Up)
{
ZoomIn();
}
else
{
ZoomOut();
}
Redraw();
}
protected override bool OnScrollEvent(Gdk.EventScroll evnt)
{
switch (evnt.Direction)
{
case ScrollDirection.Up:
TargetValue = Math.Max(TargetValue - Vadjustment.StepIncrement, 0);
break;
case ScrollDirection.Down:
TargetValue = Math.Min(TargetValue + Vadjustment.StepIncrement, Vadjustment.Upper - Vadjustment.PageSize);
break;
default:
return(base.OnScrollEvent(evnt));
}
return(true);
}
void ScrollHandler(object o, ScrollEventArgs args)
{
Gdk.EventScroll es = args.Event;
double newloc = 0.0;
int steps = Math.Max(rows / 6, 2);
switch (es.Direction)
{
case ScrollDirection.Up:
newloc = adjustment.Value - steps;
break;
case ScrollDirection.Down:
newloc = adjustment.Value + steps;
break;
}
newloc = Math.Max(newloc, 0);
newloc = Math.Min(newloc, provider.Rows - rows);
adjustment.Value = newloc;
}
/// <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)
{
// Allow the user to zoom in/out with Ctrl-Mousewheel (as long as Shift and Alt are not also pressed)
if ((evnt.State & (ModifierType.ControlMask | ModifierType.ShiftMask | ModifierType.Mod1Mask)) == 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);
}
/// <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());
}
protected override bool OnScrollEvent(Gdk.EventScroll evnt)
{
HideTooltipWindow();
ClearMouseOverItem();
return(base.OnScrollEvent(evnt));
}
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;
}
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 e)
{
if (e.Device.Source == InputSource.Mouse) {
if (e.Direction == ScrollDirection.Up)
Scale = Scale + _range.Step;
else if (e.Direction == ScrollDirection.Down)
Scale = Scale - _range.Step;
}
return base.OnScrollEvent (e);
}
protected override bool OnScrollEvent(EventScroll evnt)
{
// Allow the user to zoom in/out with Ctrl-Mousewheel
if (evnt.State == ModifierType.ControlMask) {
switch (evnt.Direction) {
case ScrollDirection.Down:
case ScrollDirection.Right:
PintaCore.Actions.View.ZoomOut.Activate ();
return true;
case ScrollDirection.Left:
case ScrollDirection.Up:
PintaCore.Actions.View.ZoomIn.Activate ();
return true;
}
}
return base.OnScrollEvent (evnt);
}
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;
}
//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 (InternalDragActive || ConfigurationMode)
return base.OnScrollEvent (evnt);
if (Painter != null) {
int x, y;
x = LocalCursor.X - painter_area.X;
y = LocalCursor.Y - painter_area.Y;
if (painter_area.Contains (LocalCursor))
Painter.Scrolled (evnt.Direction, x, y, evnt.State);
} else if ((evnt.State & ModifierType.ControlMask) == ModifierType.ControlMask) {
if (evnt.Direction == ScrollDirection.Up)
Preferences.IconSize++;
else if (evnt.Direction == ScrollDirection.Down)
Preferences.IconSize--;
return false;
} else if (HoveredItem != null) {
HoveredItem.Scrolled (evnt.Direction, evnt.State);
}
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(Gdk.EventScroll evnt)
{
HideTipWindow();
return(base.OnScrollEvent(evnt));
}
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 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 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 evnt)
{
_scrollStarted = DateTime.Now;
return base.OnScrollEvent(evnt);
}
protected override bool OnScrollEvent(EventScroll evnt)
{
Hide();
return _trackListView.ProcessEvent(evnt);
}
protected override bool OnScrollEvent (EventScroll evnt)
{
Scrollbar scrollWidget = (evnt.Direction == ScrollDirection.Up || evnt.Direction == ScrollDirection.Down) ? (Scrollbar)vScrollBar : hScrollBar;
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);
}
protected override bool OnScrollEvent(EventScroll args)
{
return HandleScroll (args);
}
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);
}