Creates a new controller.

If you don't provide a configuration object, a default one (translating movements into scrolling) will be created for you.

This is the device to translate movements of.

The value can be:

• A numeric device ID (like 65597)
• "any" to use any device (note: try to not lock yourself out of using the computer)
• "select" to prompt for device selection on startup
• "debug" to display devices+offsets without translating anything

When deviceID is "select", this indicates how far (in pixels) a pointing device should be moved before being selected.

Initializes Raw Input and binds the event listener.

You should call this after you've set up most of the parameters.

You may hot-swap the configuration object after creating a controller.

sb := ScrollBall()
sb.Listen()
; ... and later on
sb.config := otherConfig

Indicates whether the cursor is currently locked and movements from chosen device(s) are being translated.

Locks the cursor and starts translating movements.

Calling this function will not automatically start the unlockDelay timer until the mouse moves, so you can use it in hotkeys.

For example, the following would translate movement from any device into scrolling, but only after pressing Alt+S (and until the movement stops):

sb := ScrollBall()
sb.config.unlockDelay := 100
sb.config.conditions := ScrollBall.ManualStart()
sb.deviceID := "any"
sb.Listen()

!s::sb.Start()

Unlocks the cursor and stops translating movements.

This is an alternative to defining a ShouldStop condition.

For example, the following would toggle between using the cursor for movement and scrolling when pressing Alt+S:

sb := ScrollBall()
sb.config.unlockDelay := 0
sb.config.conditions := ScrollBall.ManualStart()
sb.deviceID := "any"
sb.Listen()

!s::{
	if sb.active {
		sb.Stop()
	} else {
		sb.Start()
	}
}

While the cursor is locked, this is how long can pass (in milliseconds) without movement from chosen device(s) before it will be unlocked.

Lower values may feel more responsive when using two pointing devices at once, but be careful - setting this below (1000 / device polling rate) can cause buggy movement.

Setting this to 0 disables the timeout completely,

Controls when the macro can activate and when it should deactivate.

See Conditions for more information.

Whether diagonal input is allowed (if it isn't, only the greater of two axes is considered during movements).

Controls how X-Axis works - see ScrollBall.AxisConfig for more information.

Controls how X-Axis works - see ScrollBall.AxisConfig for more information.

When an axis is disabled, mouse movement across it is ignored.

The number of pixels (of cursor movement) required to trigger one action (wheel step, key press) on this axis.

If set to a value greater than zero, after moving the cursor across this axis for this many pixels, the axis will "lock" and input across the other axis will be ignored until the cursor unlocks.

A "scroller" decides what happens whenever an action triggers - see Scrollers for more information.

This is the default set of conditions, that is - the lack of thereof.

If you are defining your own conditions, you can extend it, like so

class MyConditions extends ScrollBall.Conditions {
	; ...
}

The class can define the following methods:

class MyConditions extends ScrollBall.Conditions {
	CanStart() => GetKeyState("LAlt")
}

class MyConditions extends ScrollBall.Conditions {
	CanStart() => GetKeyState("LAlt")
	ShouldStop() => not GetKeyState("LAlt")
}

This is a convenience class

This is a convenience class for locking the mouse when a key is held (polled through GetKeyState).

If stopOnRelease is true, unlocks the mouse when the key is released.

For example,

sb := ScrollBall()
sb.config.conditions := ScrollBall.KeyHoldConditions("LAlt", true)
sb.deviceID := "any"
sb.Listen()

Would lock mouse and scroll for any device, but only while Left Alt is held.

This is the base scroller. When making your own, you should inherit from it, like so:

class MyScroller extends ScrollBall.Scroller {
	; ...
}

The class should define the following methods:

class ArrowScroller extends ScrollBall.Scroller {
	Apply(dir) {
		if dir < 0 {
			Send("{up}")
		} else {
			Send("{down}")
		}
	}
}

The class may override the following properties:

This is a convenience class that sends one or other key stroke (using Send) depending on direction.

This is a convenience function that displays one or more values in the attached console window.

If there is no console window, it will be created on first call.