RotaryView | SuperCollider 3.13.0 Help

An example of a series of RotaryViews in a layout.

Description

A GUI view that mimics a rotary-style encoder, similar to Knob, but fully customizable, including optionally a full 360-degree continuous range.

The view works in much the same was at other SC widgets, but has additional capabilities to notify dependents of changes, and the appearance is extensively customizable via numerous drawing layers with settable properties.

Class Methods

RotaryView.new(parent, bounds, spec, initVal, startAngle: 0, sweepLength: 6.2831853071796, innerRadiusRatio: 0.25, outerRadiusRatio: 1, direction: 'cw')

Create a new RotaryView.

Arguments:

parent	A Window or View, in which to embed this view. If `nil`, a window will be created to hold the view.
bounds	A Rect describing the bounds of this view within its parent. If parent is `nil`, the Rect specifies the dimensions of the newly created Window and its location on the screen.
spec	A ControlSpec that will control the range and warping of your value. -input is the unmapped -value. If `nil`, a `\unipolar` spec is created. NOTE: : The step of the provided ControlSpec will determine the step resolution of the rotary when changing the value with a mouse or arrow key (default is `0`, i.e. highest step resolution possible). See RotaryView: Example: radio dial.
initVal	The initial -value within range of the spec when the view is first drawn.
startAngle	The angular position of the start of the rotary's range, in radians. Default is `0`. Can be negative. Reference `0` position is up, 12 o'clock, and advances according to direction (default clockwise).
sweepLength	The range of motion of the rotary, in radians. Default is `2pi`.
innerRadiusRatio	A value from `(0..1)` determining radius of the the inner edge of the rotary. Default is `0`.
outerRadiusRatio	A value from `(0..1)` determining radius of the the outer edge of the rotary, where `1` is the maximum radius given the size of the view. Default is `1`.
direction	A Symbol, `\cw` or `\ccw`, clockwise and counterclockwise, respectively, indicating the direction of positive movement, for both value changes as well as affecting how startAngle is determined.

Returns:

A RotaryView.

Inherited class methods

Instance Methods

.value

.value = val

From superclass: ValueView

Get/set the value held by the view, which is the mapped counterpart of the -input (via the -spec).

The new value and corresponding -input will be broadcast to dependents, via \value and \iinput messages, respectively, every time either is set, unless -broadcastNewOnly is true, in which case the values are only broadcast if they differ from their previous state.

Arguments:

val	A Number. The number will either be constrained or wrapped within the view's -spec, depending on the state of -wrap (default is `false`, i.e. constrained to the spec.).

.input

.input = normValue

From superclass: ValueView

Get/set the input held by the view, which is the unmapped counterpart of the -value (via the -spec), i.e. a value from (0..1). This is useful for updating other UI elements which are often set through normalized values, like Sliders.

The new input and corresponding -value will be broadcast to dependents, via \input and \value messages, respectively, every time either is set, unless -broadcastNewOnly is true, in which case the values are only broadcast if they differ from their previous state.

Arguments:

normValue

A Number in the range (0..1), which will be mapped by the -spec to set the value.

.valueAction = val

From superclass: ValueView

Set the value of the view and perform the -action. This also updates the -input by unmapping from the -spec.

Arguments:

val	A Number in the range of the -spec. Out-of-range values will be clipped to the range of the -spec, unless -wrap is `true`, in which case the val is wrapped into range.

.inputAction = normValue

From superclass: ValueView

Set the input value of the view and perform the -action. This also updates the -value by mapping through the -spec.

Arguments:

normValue

A Number in the range of (0..1). Out-of-range inputs will be clipped to the range, unless -wrap is true, in which case the normValue is wrapped into range.

.doAction(newValue: true)

From superclass: ValueView

Perform the -action. Usually called through -valueAction or -inputAction.

Arguments:

newValue

A Boolean determining whether the actions is performed. Default is true. (In the underlying implementation of -valueAction and -inputAction, this argument is passed the result of newValue != oldValue, i.e. whether the value has changed to signal whether the action should be suppressed according to -supressRepearedAction, hence the name newValue. When calling this method directly, the argument is redundant.)

.suppressRepeatedAction

.suppressRepeatedAction = value

From superclass: ValueView

Get/set the Boolean which determines if the -action is performed only when a newly set value differs from its previous state. This applies when calling -valueAction, -inputAction, or -doAction. Default is true (repeated actions are suppressed). See RotaryView: Example: radio dial.

.spec

.spec_(controlSpec, updateValue: true)

From superclass: ValueView

Get/set the ControlSpec used to both map the -input and constrain the -value. Note: the step of the provided controlSpec will determine the step resolution of the rotary.

Arguments:

controlSpec	A ControlSpec.
updateValue	A Boolean specifying whether the -value(and -input) should be updated when the new controlSpec is set. Default is `true`.

User interaction

.continuous

.continuous = bool

A Boolean which determines if the rotary behaves like a continuous encoder, wrapping values around its -spec range when crossing min/max values. Useful for full 2pi range rotary controls. Synonym for -wrap. Default is false (values are clipped to range).

NOTE: If -dragMode is \circular the rotary behavior is always continuous, even if -continuous is false.

.clickMode = value

Set how mouse clicking changes the rotary position:

Arguments:

(value)

`\absolute`	jumps to the value where it is clicked
`\relative`	the value changes relative to the mouse movement once clicked.

.dragMode

.dragMode = vertHorizOrCirc: 'vertical'

Set how mouse dragging changes moves the rotary position.

NOTE: If -dragMode is \circular the rotary behavior is always continuous, even if -continuous is false.

Arguments:

vertHorizOrCirc

`\vertical`	value changes according to vertical mouse movement
`\horizontal`	value changes according to horizontal mouse movement
`\circular`	value follows the radial movement around the rotary

.rangeInPixels

.rangeInPixels = px

From superclass: ValueView

Get/set the sensitivity of mouse interaction (and output resolution) by specifying the number of pixels over which the whole view's value range can be covered. Default is 200, i.e. the entire range of possible values will be covered in 200 pixels of movement. This can also be set by -valuePerPixel.

.valuePerPixel

.valuePerPixel = value

From superclass: ValueView

Get/set the sensitivity of mouse interaction (and output resolution) by specifying the value change per pixel when interacting with the view through mouse movement. Default is spec.range / 200, i.e. the entire range of possible values will be covered in 200 pixels of movement. This can also be set by -rangeInPixels.

.scroll

.scroll = value

From superclass: ValueView

Get/set the Boolean indicating whether the value changes with mouse scrolling. Default is true.

.scrollStep

.scrollStep = value

From superclass: ValueView

Get/set the step amount when scrolling. Default is 100.reciprocal.

.xScrollDir

.xScrollDir = value

From superclass: ValueView

Get/set the x scroll direction. 1 is left to right scrolling (default), -1 is the reverse.

.yScrollDir

.yScrollDir = value

From superclass: ValueView

Get/set the y scroll direction. -1 is "natural" scrolling (default), 1 is the reverse.

.keyStep

.keyStep = value

From superclass: ValueView

Get/set the step amount of each arrow key press, as a percentage of the range of the spec. E.g. keyStep of 30.reciprocal (the default) means it takes 30 key strokes to cover the full value range (warped according to the -spec).

.keyDirLR

.keyDirLR = value

From superclass: ValueView

Get/set the step direction of Left/Right arrow keys. 1 = right increments, left decrements (default). -1 = left increments, right decrements.

.keyDirUD

.keyDirUD = value

From superclass: ValueView

Get/set the step direction of Up/Down arrow keys. 1 = up increments, down decrements (default). -1 = down increments, up decrements.

Bipolar mode

.bipolar

.bipolar = bool

Get/set how the rotary fills the color up to the current value. If false, the color is always filled from the minumum value in the range up to the current value. If true, the color is filled from the -centerValue to the current value. See RotaryView: Example: bipolar mode and Example: continuous encoder.

Arguments:

bool	A Boolean.

.centerValue

.centerValue = value

Get/set the Number that is the "center" of the bipolar axis. See RotaryView: Example: bipolar mode and Example: continuous encoder.

Arguments:

value

A Number in the range of the -spec.

Ticks

.numTicks_(num, majorEvery: 2, startAndEnd: true)

Set the number of ticks to be displayed evenly across the full range of the rotary. See Examples: radio dial and Example: continuous encoder.

Arguments:

num	An Integer. The total number of ticks (major and minor).
majorEvery	An Integer. Frequency of major ticks. E.g. majorEvery = `3` would make a tick pattern of major-minor-minor-major-minor-minor-etc. See -ticks layer for setting other properties about ticks.
startAndEnd	A Boolean, whether the first and last tick fall at the start and end of the range. E.g. If the -sweepLength is `2pi`, you wouldn't want the last tick to fall at the end of the range, as it would overlap with the first. See Example: continuous encoder.

.ticksAt_(majorRadPositions, minorRadPositions)

Set the position of major and minor ticks, in radians.

Arguments:

majorRadPositions	An Array of radian values, relative to -startAngle and -direction, for the major ticks.
minorRadPositions	An Array of radian values, relative to -startAngle and -direction, for the minor ticks.

.ticksAtValues_(majorVals, minorVals)

Set the position of major and minor ticks, in the units of your -spec. See Examples: bipolar mode.

Arguments:

majorVals	An Array of values for the major ticks, within the range of your -spec.
minorVals	An Array of values for the minor ticks, within the range of your -spec.

.ticksEveryVal_(valueHop, majorEvery: 2)

Set the ticks at an even interval, in the units of your -spec, specifying the steps between each major tick. See Example: continuous encoder.

Arguments:

valueHop	A Number specifying the interval, or "hop", between each tick.
majorEvery	An Integer specifying the steps of major ticks.

Layout

.direction

.direction = dir: 'cw'

Get/set the direction of positive movement, for both value changes as well as affecting how -startAngle is determined.

Arguments:

dir	A Symbol, `\cw` or `\ccw`, clockwise and counterclockwise, respectively.

.dirFlag

Get the value corresponding to the rotary's direction: clockwise = 1, counterclockwise = -1.

.innerRadiusRatio

.innerRadiusRatio = ratio

Set/get the radius of the the inner edge of the rotary.

Arguments:

ratio

A value from (0..1).

.outerRadiusRatio

.outerRadiusRatio = ratio

Set/get the radius of the the outer edge of the rotary, where 1 is the maximum radius given the size of the view.

Arguments:

ratio

A value from (0..1)

.startAngle

.startAngle = radians: 0

Get/set the angular position of the start of the rotary's range, in radians. Reference 0 position is up, 12 o'clock, and advances according to -direction.

Arguments:

radians

A Number in radians, can be negative.

.sweepLength

.sweepLength = radians: 6.2831853071796

Get/set the range of motion of the rotary, in radians. Default is 2pi.

Arguments:

radians

A A Number in radians.

Drawing layers: fine tuning appearance

The rotary is comprised of multiple layers, each with their own settable properties: range, level, text, ticks, handle, and outline. Each drawing layer has a *properties list (an Event), the keys of which can be accessed as pseudo-methods for getting and setting their values. Setting a property automatically refreshes the view. For example:// assuming you've created a RotaryView 'myRotary' myRotary.handle.style = \arrow; // make the rotary's "handle" an arrow myRotary.text.show = false; // hide the text of the rotary's value

.range

The layer showing the range of the rotary. Some parameters apply only for a certain style. If style == \wedge, an annularWedge is drawn for the range. If style == \arc a stroked arc is used.

property	default	description
show	`true`	show the range layer or not
style	`\wedge`	`\arc` or `\wedge` (an annularWedge); if `\arc`, the width follows width, not strokeWidth
radius	`1`	`(0..1)`, radius of outer edge of the wedge or arc
width	`1`	`(0..1)` width of range display, relative to `wedgeWidth` (`outerRadiusRatio - innerRadiusRatio`)
fill	`true`	fill the range or not
fillColor	`Color(0.9,0.9,0.9)`	color to fill the range
stroke	`false`	stroke the range or not
strokeType	`\around`	if style `== \wedge`; `\inside`, `\outside`, `\around`, or `\insideOutside`
strokeColor	`Color`	stroke color of the range
strokeWidth	`1`	if style `== \wedge`; if `< 1`, assumed to be a normalized value and changes with view size, else treated as a pixel value
joinStyle	`0`	if style `== \wedge`; `\miter`; `\round`, `\bevel`, or an Integer of the Pen: *joinStyle
capStyle	`\round`	if style `== \arc`; `\butt`, `\flat`, `\round`, `\square`, or an Integer of the Pen: *capStyle

.level

The layer showing the level of the rotary. If style == \wedge, an annularWedge is drawn for the range. If style == \arc a stroked arc is used.

property	default	description
show	`true`	show the level layer or not
style	`\wedge`	`\arc` or `\wedge` (an annularWedge); if `\arc`, the width follows width, not strokeWidth
radius	`1`	`(0..1)`, radius of outer edge of the wedge or arc
width	`1`	`(0..1)` width of range display, relative to `wedgeWidth`
fill	`true`	fill the level or not
fillColor	`Color.white`	color to fill the level;
stroke	`true`	stroke the level or not
strokeType	`\around`	if style `== \wedge`; `\inside`, `\outside`, `\around`, or `\insideOutside`
strokeColor	`Color.gray`	stroke color of the level
strokeWidth	`0.025`	if style `== \wedge`; if `< 1`, assumed to be a normalized value
joinStyle	`0`	if style `== \wedge`; `\miter`; `\round`, `\bevel`, or an Integer of the Pen: *joinStyle and changes with view size, else treated as a pixel value
capStyle	`0`	if style `== \arc`; `\butt`, `\flat`, `\round`, `\square`, or an Integer of the Pen: *capStyle

.text

The layer showing the text of the rotary's current value.

property	default	description
show	`true`	show the text layer or not
align	`\center`	`\top`, `\bottom`, `\center`, `\left`, `\right`, or a Point on which to center the text, in a range of `(0..1)` where top-left is `0@0`, bottom-right is `1@1`
round	`0.1`	a Number to round the value display to
fontSize	`0.1`	font size in pixels, unless `< 1`, then relative to radius
fontName	`"Helvetica"`	a String, the font name
color	`Color.gray`	Color of the text

.ticks

The layer showing the ticks of the rotary. The number and position of ticks are set through -numTicks, -ticksAt, -ticksAtValues, or -ticksEveryVal.

property	default	description
show	`false`	show the tick layer or not
anchor	`0.97`	`(0..1)` position/radius where the ticks are "anchored", relative to outer edge of rotary
align	`\inside`	the position of the ticks relative to anchor; `\inside`, `\outside`, or `\center`
majorLength	`0.25`	length of major ticks, `(0..1)` realtive to `maxRadius`
minorLength	`0.1`	length of major ticks, `(0..1)` realtive to `maxRadius`
majorWidth	`0.05`	width of major tick, in pixels unless `< 1`, in which case relative to radius
minorWidth	`0.025`	width of major tick, in pixels unless `< 1`, in which case relative to radius
majorColor	`Color.gray`	Color of the major ticks
minorColor	`Color.gray`	Color of the minor ticks
capStyle	`\round`	`\butt`, `\flat`, `\round`, `\square`, or an Integer of the Pen: *capStyle

.handle

The layer showing the "handle" of the rotary. Some properties are only valid for certain styles.

property	default	description
show	`true`	show the handle layer or not
style	`'line'`	`\line`, `\circle`, or `\arrow`
anchor	`0.9`	reference radius of for drawing the anchor align, `(0..1)`
align	`'inside'`	`\inside`, `\outside`, or `\center` on the anchor
length	`0.3`	if style `== \line` or `== \arrow`, `(0..1)` relative to radius
width	`0.6`	if style `== \arrow`, `(0..1)` relative to length
stroke	`true`	if style `== \circle` or `== \arrow`, stroke the handle or not
strokeColor	`Color.black`	stroke Color of the handle
fill	`true`	if style `== \circle` or `== \arrow`, fill the handle or not
fillColor	`Color.red`	fill Color of the handle
joinStyle	`'round'`	if style `== \arrow`, `\miter`, `\round`, `\bevel`, or an Integer of the Pen: *joinStyle
radius	`0.1`	if style `== \circle`, in pixels unless `< 1`, in which case relative to radius
capStyle	`'round'`	if style `== \line`, `\butt`, `\flat`, `\round`, `\square`, or an Integer of the Pen: *capStyle
strokeWidth	`0.05`	width of stroke, in pixels, unless `< 1`, then relative to radius in which case relative to radius

.outline

The layer showing the outline of the rotary. It's called "outline", but need not be on the perimeter—it's essentially a circle of variable size/fill that can serve as an outline or visual accent. It's the topmost layer.

property	default	description
show	`false`	show the outline layer or not
radius	`1`	`(0..1)`, relative to radius
stroke	`true`	stroke or not
strokeColor	`Color.black`	stroke Color of the outline
strokeWidth	`2`	in pixels unless `< 1`, in which case relative to radius
rangeOnly	`false`	a Boolean whether outline is constrained to the rotary's range, or is a full circle
capStyle	`flat`	if rangeOnly `== \true`, `\butt`, `\flat`, `\round`, `\square`, or an Integer of the Pen: *capStyle
fill	`false`	fill or not
fillColor	`Color.white`	fill Color of the outline layer

Inherited instance methods

Examples

Example: bipolar mode

Example: radio dial

/* radio dial */
(
r = RotaryView(bounds: Size(300, 300).asRect,
    spec: ControlSpec(1,5),
    startAngle: -0.7pi,
    sweepLength: 1.4pi,
    innerRadiusRatio: 0.2,
    outerRadiusRatio: 0.9,
).front;

// action: post self, value, and normalized input
r.action = {|v, value, input| [v, value, input].postln};

// handle style: arrow
r.handle.style_(\arrow).joinStyle_(\ropund);
r.handle.length_(0.5).width_(0.6).anchor_(0.95).strokeColor_(Color.red.val_(0.5));

// appearance
r.level.show = false; // turn off the level display
r.numTicks_(5, majorEvery: 1); // 5 positions
r.ticks.show_(true).majorLength_(0.3).majorWidth_(1.5).majorColor_(Color(*0.5.dup(3)));
r.text.align_(0.5@0.8).fontName_("Monaco").fontSize_(0.18);

// behavior
r.spec.step = 1; // spec's step determins how the dial clicks into each position
r.clickMode = \absolute;   // value follows mouse down position (default)
r.dragMode = \circular; // makes sense for a radio dial (default)
)

/* a variation: handle, outline, level */
(
r.range.fill_(false).stroke_(true).strokeType_(\insideOutside);
r.handle.style_(\line).capStyle_(\round).anchor_(0.5).align_(\center).length_(0.45).strokeWidth_(0.04);
r.ticks.majorLength_(0.1).anchor_(0.5).align_(\center);
r.level.show_(true).stroke_(false).fill_(true).fillColor_(Color.red.alpha_(0.2));
)

/* a variation: handle, function for a property */
(
r.innerRadiusRatio_(0); // no center gap
r.range.fill_(false).stroke_(true).strokeWidth_(0.025).strokeType_(\outside).strokeColor_(Color(*0.5.dup(4)));
r.ticks.majorLength_(0.1).anchor_(0.7).align_(\center).majorColor_(Color(*0.5.dup(4)));
r.handle.style_(\circle).radius_(0.33);
r.handle.anchor_(0.7).align_(\center);
r.handle.fill_(true).stroke_(false);
r.handle.fillColor = { |p|
    Color.hsv(p.input * 0.999, 0.9, 1, 0.4) // color changes with position
};
r.text.show = false;
r.level.show = false;
)

/* a variation: change steps/ticks */
(
r.spec.step = 0.5;
r.numTicks_(9, majorEvery: 2, startAndEnd: true);
r.ticks.majorLength_(0.3).minorLength_(0.2);
r.ticks.majorColor_(Color(*0.5.dup(4))).minorColor_(Color(*0.2.dup(4)));
r.ticks.majorWidth_(0.03).minorWidth_(0.01);
)

// default behavior is to perform the action only if the value is new:
r.suppressRepeatedAction; // >> true
// this filtering can be turned off so the action will be performed
// on every mouse move, even if it's the same value
r.suppressRepeatedAction = false; // observe output while dragging

Example: continuous encoder

/* continuous encoder: output degrees */
(
var col = Color.hsv(0.6,1,1);
r = RotaryView(bounds: Size(300, 300).asRect,
    spec: [0, 360].asSpec,
    innerRadiusRatio: 0,
    direction: \ccw
).front;

// Note: numTicks is a view method, not ticks layer property
r.numTicks_(16, 2, startAndEnd: false);

r.action = { |view, val, input| "new value: %\n".postf(val) };

r.clickMode = \absolute;   // (default)
r.dragMode = \circular;    // (default)
r.continuous = true;       // wrap through the zero crossing
r.scrollStep_(0.01);       // percentage of the full range for each scroll step
r.keyStep_(20.reciprocal); // percentage of the full range for each key step,
                           // i.e. 20 keystrokes over the full range
// range
r.range.show_(true).stroke_(false).fillColor_(Color(0.9,0.9,0.9));

// level
r.level.fill_(false);
r.level.show_(true).strokeWidth_(0.02).strokeColor_(col).strokeType_(\outside);

// handle
r.handle.style_(\line).anchor_(0.9).align_(\inside).length_(0.3);
r.handle.strokeWidth_(0.1).strokeColor_(col);

// value text
r.text.fontSize_(0.2).color_(col);
r.text.align = 0.5@0.51;  // slightly better center position
r.text.round = 0.1;       // round the value of the displayed text

// ticks
r.ticks.show_(true).anchor_(0.9).align_(\inside).capStyle_(\round);
r.ticks.majorLength_(0.1);
r.ticks.majorWidth_(0.02).minorWidth_(0.015);
r.ticks.minorColor_(col.copy.alpha_(0.2)).majorColor_(col);

// set the value
r.value = 270;
)

// a bipolar variation
(
r.spec = ControlSpec(-180, 180);
r.bipolar = true;
r.centerValue = 0;
r.startAngle = pi;
r.sweepLength = 2pi;
r.ticksEveryVal_(22.5, 2); // Note: ticksEveryVal is a view method
r.ticks.majorColor_(       // while majorColor is a property of ticks layer
    Color.hsv(0.6,1,1,0.4)
);
)

/* another continuous encoder: simple, good for small size */
(
r = RotaryView(
    bounds: Size(100, 100).asRect,
    spec: [0, 2pi].asSpec,
    innerRadiusRatio: 0
).front;

r.action = { |view, val, input| [val, input].postln };

// range
r.range.stroke_(false);
r.range.fillColor = Color.new(0.9,0.9,0.9).alpha_(0.8);

// handle
r.handle.show_(true).strokeColor_(Color.green);
r.handle.style_(\arrow).length_(0.6).anchor_(0.65);
r.handle.stroke_(true).strokeWidth_(0.05).joinStyle_(\round);
r.handle.strokeColor = Color.hsv(0.27, 0.9, 0.8);
r.handle.fillColor = Color.hsv(0.27, 1, 0.8);

// level
r.level.show = false;

// value text
r.text.show = false;
r.text.round = 0.1;  // round the value of the displayed text

// ticks
r.numTicks_(360/22.5, 2, startAndEnd: false); // Note: numTicks is a view method
r.ticks.show_(true).capStyle_(\round).anchor_(0.9);
r.ticks.minorColor_(Color.new255(*200!3)).majorColor_(Color.new255(*150!3));
r.ticks.majorLength_(0.1).minorLength_(0.08);
r.ticks.majorWidth_(0.09);

// outline to create an inner circle
r.outline.show_(true).radius_(0.7).strokeWidth_(0.015);
)

Example: level dial

Example: panner

Example: in a layout

Multiple rotaries in a layout.( var num = 8; var setupRot; setupRot = { |col| var r = RotaryView( bounds: Size(300, 300).asRect, spec: [10, 100, \lin].asSpec, startAngle: 0.75pi, sweepLength: 1.5pi, innerRadiusRatio: 0.1, ).front; // range r.range.fillColor_(Color.new(0.9,0.9,0.9)); r.range.stroke_(false); // level r.level.strokeColor_(col).strokeType_(\outside); r.level.fillColor_(col.copy.alpha_(0.2)); // handle r.handle.strokeColor_(col); r.handle.length_(0.95).anchor_(0.97).strokeWidth_(0.05); // text r.text.fontSize_(0.15).align_(\right); // ticks r.numTicks_(15, 5); r.ticks.show_(true); r.ticks.majorWidth_(0.05).minorWidth_(0.025); r.ticks.anchor_(0.9).capStyle_(\flat); r.action = { |v, val, in| [v, val, in].postln }; r.value_(rrand(r.spec.minval, r.spec.maxval)); }; Window( bounds: Rect(100,100, 140 * 8, 150) ).front.layout_( HLayout( *num.collect({ |i| setupRot.( Color.hsv(num.reciprocal*i, 1,1,1) ) }) ) ) )

helpfile source: /home/bgola/.local/share/SuperCollider/downloaded-quarks/ValueView/HelpSource/Classes/RotaryView.schelp
link::Classes/RotaryView::

RotaryView : ValueView : View : QObject : Object Extension

RotaryView.new(parent, bounds, spec, initVal, startAngle: 0, sweepLength: 6.2831853071796, innerRadiusRatio: 0.25, outerRadiusRatio: 1, direction: 'cw')

Arguments:

Returns:

.value

.value = val

Arguments:

.input

.input = normValue

Arguments:

.valueAction = val

Arguments:

.inputAction = normValue

Arguments:

.doAction(newValue: true)

Arguments:

.suppressRepeatedAction

.suppressRepeatedAction = value

.spec

.spec_(controlSpec, updateValue: true)

Arguments:

.continuous

.continuous = bool

.clickMode = value

Arguments:

.dragMode

.dragMode = vertHorizOrCirc: 'vertical'

Arguments:

.rangeInPixels

.rangeInPixels = px

.valuePerPixel

.valuePerPixel = value

.scroll

.scroll = value

.scrollStep

.scrollStep = value

.xScrollDir

.xScrollDir = value

.yScrollDir

.yScrollDir = value

.keyStep

.keyStep = value

.keyDirLR

.keyDirLR = value

.keyDirUD

.keyDirUD = value

.bipolar

.bipolar = bool

Arguments:

.centerValue

.centerValue = value

Arguments:

.numTicks_(num, majorEvery: 2, startAndEnd: true)

Arguments:

.ticksAt_(majorRadPositions, minorRadPositions)

Arguments:

.ticksAtValues_(majorVals, minorVals)

Arguments:

.ticksEveryVal_(valueHop, majorEvery: 2)

Arguments:

.direction

.direction = dir: 'cw'

Arguments:

.dirFlag

.innerRadiusRatio

.innerRadiusRatio = ratio

Arguments:

.outerRadiusRatio

.outerRadiusRatio = ratio

Arguments:

.startAngle

.startAngle = radians: 0

Arguments:

.sweepLength

.sweepLength = radians: 6.2831853071796

Arguments:

.range

.level

.text

.ticks

RotaryView : ValueView : View : QObject : Object
Extension