VarGui

Extension

Description

SC setups may contain discrete and continuous control, e.g. using combinations of Pbinds, Tasks and Synths. There are many possible ways of interaction between such elements, sometimes there is the alternative to control things by server or language (e.g. Pbinds versus Demand Ugens) but often one needs to have both. VarGui is a multi purpose slider and player GUI, originally intended for indentifying parameters to be reused in other setups. Pbinds and Tasks can easily refer to environmental variables - in case of Pbinds e.g. via Pfunc, Plazy, Pcollect, but more conveniently via the dynamic scope PLx_suite - so VarGui can control environmental variables and synth controllers. For using event patterns with functional code and the related scoping features see Event_patterns_and_Functions. VarGui was not intended for performance, however (since miSCellaneous v0.4) it includes a player section. Players can be used in different (reset) modes, states of synths and streams are reflected by colors, it also works with wslib slider classes (Ex.8). For quick GUI generation using SynthDef metadata for controlspecs and / or automatic Pbind builds see VarGui_shortcut_builds. As both VarGui help files are quite full of details, a more general overview, including some exercises, is given in Introduction_to_miSCellaneous.

Some Important Issues Regarding VarGui

VarGui allows to choose SynthDefs or Synths, Events patterns or EventStreamPlayers and Task functions or Tasks as input. It is recommended to take the more general objects (SynthDefs, Event patterns, Task functions) as then derived Synths, EventStreamPlayers and Tasks are newly generated and the latter are run in newly generated Environments. If you follow this it is very unlikely to accidentally break gui representation of data (though it's not strict MVC paradigm).

On the other hand there are special cases when you might want to pass Synth objects / synth nodes, Tasks or EventStreamPlayers directly (e.g. HS_with_VarGui). Then a bit more care has to be taken as, although a VarGui instance doesn't allow to poll more than one GUI window from it, nothing prevents you from refering to identical Synth objects / synth nodes, Tasks, EventsStreamPlayers or environmental variables with different VarGui instances. This is not recommended as, obviously, a possible source of confusion.

If you are passing a Synth directly and moreover its SynthDef is not known to SynthDescLib setting a single component of an arrayed control also causes setting of all components below (no other choice at the moment, however, a very special case).

GUI specific

With miSCellaneous v0.16 (March 2017) backwards compatibility with Cocoa and SwingOSC is no longer supported, now cross-platform Qt is standard. VarGui was originally written with Cocoa as reference, though restrcitions on Qt are minor.

1. With Qt mouseDown is the hardcoded mode of player action, which anyway could be regarded as standard usage.
2. Moving several sliders in parallel (Ex.1c) works on all platforms and with wslib sliders.
3. Combined slider movement with modifier keys can differ in the necessary order of key pressing and mouse clicking. In Qt you can (and with the Cmd modifier involved you have to) press thereafter.
4. With EZSlider you can jump to a certain slider position by clicking at an arbitrary position in the slider field. With wslib sliders you can choose modes \jump and \move (Ex.8).
5. Combined synth / stream player button actions with Caps-lock are currently not working with Qt.

You can list styles by GUI.availableStyles and set with GUI.style = \myFavoriteStyle

Class Methods

.new

Create a new VarGui object, which holds control specifications.

Arguments:

varCtr	specPairs or a collection of specPairs, where specPairs is a collection of the form [ key, spec, ... ] where key is the symbol of the environmental variable to be set and spec must be one of those: Collection of the form [ minval, maxval, warp, step, default ], defining the corresponding ControlSpec, or a collection of specs of this form for an arrayed control if the environmental variable should have the value of a collection itself. step is used for the derivation of slider step size. Symbol refering to a ControlSpec globally stored in Spec.specs or a collection thereof for arrayed control. ControlSpec.step is used for the derivation of slider step size. SimpleNumber for a dummy slider with fixed value. If specPairs or single components of a collection of specPairs are nil and the corresponding stream arg is a Symbol or String pointing to a SynthDef, it will be tried to derive controls from corresponding SynthDef metadata resp. global ControlSpecs (see VarGui_shortcut_builds). Variables are set in environments that are either given implicitely (1) or explicitely (2): by eventstream players / tasks passed to stream - they are already bound to an environment - or newly generated together with eventstream players or tasks from patterns or functions passed to stream. by envir. This allows setting of variables in Environments in case of absent stream players. From explicit or implicit envir input an ordered collection of non-identical environments is derived, which, without one of the above infos, will consist of currentEnvironment only. If varCtr is already grouped as a collection of specPairs then variables from i-th specPairs will be set in the i-th environment of the derived collection. If varCtr is given as a flat collection and specPairs contains no multiple keys then variables are set in the first resp. only environment in question. If varCtr is given as a flat collection and specPairs contains multiple keys then varEnvirGroups is needed to map variables to environments (Ex.5a). Note that the i-th environment means the i-th non-identical environment, not necessarily (in the case of environments implicitely given by eventstream players / tasks) the environment of the i-th stream. Defaults to nil.
synthCtr	specPairs or a collection of specPairs, where specPairs is a collection of the form [ key, spec, ... ] where key is the symbol of the control arg to be set and spec must be one of those: Collection of the form [ minval, maxval, warp, step, default ], defining the corresponding ControlSpec or a collection of specs of this form for an arrayed control. step is used for the derivation of slider step size. Symbol refering to a ControlSpec globally stored in Spec.specs or a collection thereof for arrayed control. ControlSpec.step is used for the derivation of slider step size. SimpleNumber for a dummy slider with fixed value. If specPairs or single components of a collection of specPairs are nil, it will be tried to derive controls from SynthDef metadata resp. global ControlSpecs (see VarGui_shortcut_builds). If synthCtr is already grouped as a collection of specPairs then controls from i-th specPairs will be used for setting the i-th synth. If synthCtr is given as a flat collection and specPairs contains no multiple keys then controls will be used for setting the only synth in question. If synthCtr is given as a flat collection and specPairs contains multiple keys then synthCtrGroups is needed to map synth controls to synths (Ex.5b). Defaults to nil.
stream	Expects Pattern, EventStreamPlayer, Function, Task or a collection thereof, determining the number of stream players. Patterns / Functions are used as templates for EventStreamPlayers / Tasks in environments generated at init time. If stream is unequal nil variables given by varCtr will be set in the environments derived from it. Size of stream must at least equal and may exceed the number of varCtr groups, which (see above) may be given by varCtr itself (if a grouped collection of specPairs) or varCtrGroups. Correspondence between environments of variables and eventstream / task players is optionally indicated in the GUI - however the user is responsible for defining patterns and task functions that really involve the variables to be set ! Defaults to nil.
synth	Input to which synth controls are mapped. Expects Symbol refering to a SynthDef, Synth, nodeID or collection thereof. Size of synth must at least equal and may exceed the number of synthCtr groups, which (see above) may be given by synthCtr itself (if a grouped collection of specPairs) or synthCtrGroups. It is recommended to refer to "known" SynthDefs (SynthDescLib), best by passing Symbols or also registered Synths, otherwise the correct synth state must be given explicitely by assumePlaying, assumeRunning resp. assumeEnded, which is a nearby source of error and confusion. Defaults to nil.
clock	TempoClock, nil or collection thereof for playing streams. Passed clocks have precedence over implicitely given clocks (running eventstream players or tasks as stream input) in case of resuming from pause state. Defaults to the default TempoClock. quant - Quant, Float, nil or collection thereof used as quant data for playing streams. Will be used in case of resuming from pause state for running eventstream players or tasks given as stream input. Defaults to Quant.default (none).
quant	Quant, Float, nil or collection thereof used as quant data for playing streams. Will be used in case of resuming from pause state for running eventstream players or tasks given as stream input. Defaults to Quant.default (none).
varEnvirGroups	SequenceableCollection of Collections of Integer. Expects ordered partition of the number N of specPairs given to varCtr as a flat collection, also counting multiple occurences, thus defining a mapping: variable keys -> environments. Must be a valid partition of N (taking all integers i < N, 0 included, each only once). Its size must not exceed the number of implicitely or explicitely given environments (see varCtr). E.g. for 3 environments and 6 variables [[2], [0,1,5], [4,3]] would be valid. Defaults to nil.
envir	SequenceableCollection of Environments. Environments to be used for variable setting in case of absent stream players, only admissible if stream is nil. Defaults to nil.
synthCtrGroups	SequenceableCollection of Collections of Integer. Expects ordered partition of the number N of specPairs given to synthCtr as a flat collection, also counting multiple occurences, thus defining a mapping: synth control keys -> environments. Must be a valid partition of N (taking all integers i < N, 0 included, each only once). Its size must not exceed the size of synth. Defaults to nil.
assumePlaying	Boolean, nil or collection thereof, then size must equal the number of synths given by synth or synthCtr. Player state information for (unregistered) synths or nodeIDs, booleans are not accepted if corresponding items in synth are instances of Symbol or String. Defaults to nil.
assumeRunning	Boolean, nil or collection thereof, then size must equal the number of synths given by synth or synthCtr. Player state information for (unregistered) synths or nodeIDs, booleans are not accepted if corresponding items in synth are instances of Symbol or String. Defaults to nil.
assumeEnded	Boolean, nil or collection thereof, then size must equal the number of synths given by synth or synthCtr. Player state information for (unregistered) synths or nodeIDs, booleans are not accepted if corresponding items in synth are instances of Symbol or String. Defaults to nil.
server	The server to send node messages to. Defaults to the local server.

Discussion:

 ( s = Server.local; Server.default = s; s.boot; )

Pbind defined with variable to be controlled while playing. Pfunc's function is evaluated at playtime of each Event and gets the value of the variable ~midi in the environment in which the EventStreamPlayer will be playing.p = Pbind(\midinote, Pfunc { ~midi } + Pseq([0, 3, 5, 7], inf), \dur, 0.2)

VarGui to set this variable. As a pattern is given as stream arg the derived EventStreamPlayer will run in a new environment which is generated at VarGui init time.v = VarGui([\midi, [50, 70, \lin, 1, 55]], stream: p).gui;

Try out basic slider and player functionality.

Playing:

Background of player button lightening yellow. Functionality of the reset button depends on the active mode. The green background of the reset mode button indicates that the reset button will reset while playing and its background will flash yellow.

The text field on the right side indicates whether an eventstream player or a task is playing, that on the left side shows the index of the environment in which the stream is playing. This is mainly useful if more stream players and variables of same names in different environments are involved - below the players there is a toggle button to indicate the envir index in slider name fields.

Pausing:

Now pushing the play button will resume the stream where it has been paused, pushing the reset button (if the reset mode button has green background) will reset and play the stream.

Pausing and reset:

This state can be reached from playing, pausing or ended stream when pushing the reset button under reset mode pause (orange background). Now only the play button can play the (reset) stream.

Stream has ended:

E.g. if an eventstream player has encountered nil, reset button's background will become red. Now it needs the reset button to go on and its action - pause or play - depends on the active mode.

 // synth definition with raising frequency ( SynthDef(\synth_0, { |devFactor = 0.1, devFreq = 10, amp = 0.1| var freq = XLine.kr(400, 1200, 10); Out.ar(0, SinOsc.ar(SinOsc.ar(devFreq, 0, devFactor * freq, freq), mul: amp).dup(2) * EnvGate.new) }).add; )

VarGui to play synth of above definition and set synth args, player functionality with different stop / renew modes. Notification must be on. Note that pause, stop and resume actions cause sending of run / free messages, thus possibly audible clicks. To avoid that work with amp = 0 or use a gated envelope and a gate control slider with only values 0 and 1 or use Synths of limited duration as in Ex. 2.( VarGui( synthCtr: [\devFactor, [0, 0.99, \lin, 0.01, 0.5], \devFreq, [1, 100, \lin, 0.1, 70], \amp, [0, 0.3, \lin, 0.001, 0.1]], synth: \synth_0 ).gui; )

Latency options (buttons and boxes below the player section): bundle latency of synth player actions can be set to nil, a custom value (button abbrieviation c) or global server latency (abbr. s), these two values can be set in the boxes below. Settings can be used to sync synth and stream players, if both contained in a GUI.

Synth players work similar as stream players, but there are more options. There is an addtional stop mode button that determines how and if renewing (creating new synth nodes of same definition) is handled.

If, as above, a synth is given by a reference to a known SynthDef VarGui will start with a basicNew Synth object, indicated by white background of the synth's number field:

Rate type (audio) is indicated in the field on the right. From this state a node on the server will be created by pause (newPaused) or play (new):

Now playing and pausing work as usual. The red and blue background of the stop mode button indicates that the red stop button will become a blue renew button as soon as the Synth is stopped (node freed). In addition to the renew modes play (green) and pause (orange) there is also a renew mode basic new (white):

If stop mode is set to renew (blue) the renew button will never change its function. Under renew mode play (green) every renew will free a Synth and immediately start a new (background flashing yellow):

If stop mode is set to stop (red background), the stop / renew button will change to red:

The renew mode button loses its function (greyed out) and stopping just frees the Synth:

Now stop mode would have to be changed in order to play a new Synth.

General functionality buttons:

Update

Unless the VarGui window was generated with option updateNow set to false (which could be desired e.g. for a start with Synth defaults), variables and synth controls are set to slider values at gui init time, normally updating is not required. As for most uses VarGui would generate new separate environments for passed event patterns and task functions, there is no update mechanism implemented if these variables would be changed otherwise. Analagously controls of Synths played (and probably just yet generated) by a VarGui player could of course be set by means other than a VarGui slider action. Anyway both situations seem to be exceptional (you could hardly do so just by an oversight), though you can update to all slider values manually.

Save

Opens a dialog to save the current slider state as an array of four items: varCtr as flattened array of specPairs, synthCtr as flattened array of specPairs, varEnvirGroups, synthCtrGroups (which are only stored as groupings in case of multiple key occurences, nil optherwise). Player data and synth information is not stored. For loading from a file you would have to pass this (see the load method below).

Stop

Free all synths and stop all streams. You can also use modifier keys for stopping groups of players, e.g. Shift-click on a stream players's pause button to stop all streams. Freeing all synths in the same way only works if all synth players can be stopped by their stop buttons at this time.

.load

.load_old

Instance Methods

.gui

.update

.updateVarSliders

.updateSynthSliders

.font

.addSliderAction

.startMIDIlearn

.stopMIDIlearn

Examples

Ex. 1a: step sequencer

There are different ways to read a sequence of values from a settable array assigned to an envir variable. PLseq is convenient, for a comparison with Plazy, Pfunc etc. see PLx_suite. In all cases the EventStreamPlayer can be played in an arbitrary environment, from which ~seq will be taken. This holds true for Patterns with functional code like Pfunc and also for PLseq, the latter has an envir arg which defaults to \current. Note that all PLx Patterns default to repeats = inf, ListPatterns as Pseq default to repeats = 1.( SynthDef(\synth_1a, { |freq = 400, preAmp = 5, amp = 0.1| var src = SinOsc.ar(freq, 0, mul: preAmp).tanh ! 2; OffsetOut.ar(0, src * amp * EnvGen.ar(Env.perc, doneAction: 2)) }).add; ) ( p = Pbind( \instrument, \synth_1a, \preAmp, PL(\preAmp), // or Pfunc { ~preAmp } \amp, PL(\amp), // or Pfunc { ~amp } \midinote, PLseq(\seq) + PL(\seqAdd), \dur, 0.2 ); )

~seq will be set and read in the new Environment, which will be generated at VarGui init time.( ~specPairs = [\seq, [36, 60, \lin, 1, 36] ! 5, \seqAdd, [0, 12, \lin, 1, 0], \amp, [0, 0.3, \lin, 0.01, 0.1], \preAmp, [5, 50, \lin, 0.01, 20]]; v = VarGui(~specPairs, stream: p).gui; )

Ex. 1b: step sequencer with MIDI

Ex. 1c: more step sequencers, quantization, slider modifiers

SynthDef from Ex.1a , four players from a Pbind, four varCtr specifications with shifted range.( p = Pbind( \instrument, \synth_1a, \preAmp, PL(\preAmp), \amp, PL(\amp), \midinote, PLseq(\seq) + PL(\seqAdd), \dur, 0.2 ); ~spec = 4.collect { |i| [\seq, [12*i + 24, 12*i + 48, \lin, 1, 24*i + 36] ! 5, \seqAdd, [0, 12, \lin, 1, 0], \amp, [0, 0.15, \lin, 0.01, 0.07 - (0.01 * i)], \preAmp, [5, 50, \lin, 0.01, 20]] }; ) // run all players in sync by passing a quant arg v = VarGui(~spec, stream: p!4, quant: 0.2).gui(tryColumnNum: 2, streamPlayerGroups: [[0,3], [1,2]]); // EventStreamPlayers derived from Pbind are run in // four newly generated environments, // variables, as their names are passed four times in spec, // are automatically set in these Environments in order. // Envir index display can be toggled with the button on the right. v.envirs; // get envirs // try slider action with modifier keys

Ex. 1d: step sequencer, stream players in same environment

You can try to benefit from eventstream players having variables in common. SynthDef from Ex.1a , second Pbind derived from p without pitch offset as parallel pattern.( p = Pbind( \instrument, \synth_1a, \preAmp, PL(\preAmp), \amp, PL(\amp), \midinote, PLseq(\seq) + PL(\seqAdd), \dur, 0.2 ); q = Pbindf(p, \midinote, PLseq(\seq)); v = VarGui([\seq, { [48, 84, \lin, 1, rrand(48, 84)] } ! 5, \seqAdd, [0, 12, \lin, 1, 7], \amp, [0, 0.3, \lin, 0.01, 0.07], \preAmp, [5, 50, \lin, 0.01, 20]], stream: [q,p].collect(_.asESP), // so currentEnvironment is given implicitely by both ESPs and used for setting quant: 1 // ensures that players, also if started separately for the first time, // will play the sequence in sync ).gui; ) // stopping and resuming of a single player may break parallelism // Shift-clicked reset syncs again

Ex. 1e: step sequencer and replacements with PLx

SynthDef from Ex.1a( // SynthDef from (1a) // Pbind with PL as placeholder for pitch patterns // master VarGui with player // start and set seq p = Pbind( \instrument, \synth_1a, \preAmp, PL(\preAmp), \amp, PL(\amp), \midinote, PL(\a) + PL(\seqAdd), \dur, 0.2 ); // ESP as stream arg: variables will be read from (build time) current Environment. ~basePat = PLseq(\seq); ~a = ~basePat; v = VarGui([\seq, [36, 60, \lin, 1, 36] ! 5, \seqAdd, [0, 12, \lin, 1, 0], \amp, [0, 0.1, \lin, 0.001, 0.05], \preAmp, [5, 50, \lin, 0.01, 20]], stream: p.asESP).gui(name: \seq); // control spec array builder for midi range ~pitchSpec = { |key = \seq, default = 60, step = 1, lo = 24, hi = 96| var spec = default.asArray.collect([lo, hi, \lin, step, _]); [key, (spec.size == 1).if { spec.flatten }{ spec }]; }; ) // replace while playing: // chord sequence ( ~chordPat = PLseq(\seq) + [0, 7]; ~a = ~chordPat; ) // random sequence with new VarGui for lead voice bounds ( VarGui(~pitchSpec.(\b, [75, 85], 0.01)).gui(name: \random); ~randPat = Pfunc { rrand(~b[0], ~b[1]) } + [0, -13.3, -17.7]; ~a = ~randPat; ) // accumulation sequence with new VarGui ( VarGui(~pitchSpec.(\accum, { rrand(40,80) }!7 )).gui(name: \accum); ~accPat = Ptuple( [ PL(\accum), PLseq((0..6)) ] ).collect { |x| x[0].keep(x[1]) - x[1] }; ~a = ~accPat; ) // switch between PLs and set values in VarGui windows ~a = ~basePat; ~a = ~chordPat; ~a = ~randPat; ~a = ~accPat;

Ex. 2: stream players and synths in one VarGui

Try multiple slider movements with modifier keys as described in Ex.1c. As synth args and variables are identically named they can be controlled with linked slider movements using Cmd. Accordingly stream and synth player buttons can also be pressed in parallel.( v = VarGui([\freq, [600, 700, 900, 1000].collect([400, 1200, \lin, 0.01, _]), \freqFac, [0.25, 1.25, \lin, 0.01, 1], \amp, [0.0, 0.1, \lin, 0.001, 0.03], \step, [0.7, 1.25, \lin, 0.01, 1.03]] ! 2, [\freq, [600, 700, 900, 1000].collect([400, 1200, \lin, 0.01, _]), \freqFac, [0.25, 1.25, \lin, 0.01, 1], \attTime, [0.02, 2, \lin, 0.01, 0.2], \relTime, [0.02, 2, \lin, 0.01, 2], \susTime, [0.1, 10, \lin, 0.01, 5], \amp, [0.0, 0.1, \lin, 0.001, 0.03], \preAmp, [5, 50, \lin, 0.01, 20]] ! 2, p!2, \synth_2 ! 2, quant: 0.4 ).gui(tryColumnNum: 2, allowSynthsBreak: false, allowEnvirBreak: false /*, colorDeviation: 0 */ /*, sliderPriority: \synth, playerPriority: \synth */ ) )

Ex. 3: granular synthesis with Tasks

Ex. 4a: interaction of synth and stream players, control synth controlling pbind synths

Pbind producing a sequence of short events, each pbind-driven synth reading frequency from a control bus( // control synth SynthDef(\synth_4_kr, {|out = 0, devFreq = 0.5, midiCenter = 60, midiDev = 10| Out.kr(out, LFDNoise3.kr(devFreq, midiDev, midiCenter)) }).add; // audio synth // mix of sine and pulse, interval, basic frequency read from control bus SynthDef(\synth_4_ar, {|out = 0, in = 0, soundMix = 0.5, pulseWidth = 0.5, indexLR = 0, att = 0.005, rel = 0.1, amp = 0.1, midiInt = 3, midiAdd = 0| var mix, freq1, freq2, fr; freq1 = (In.kr(in, 1) + midiAdd).midicps; freq2 = freq1 * midiInt.midicps / 0.midicps; fr = [Select.kr(indexLR, [freq1, freq2]), Select.kr(1-indexLR, [freq1, freq2])]; mix = (SinOsc.ar(fr, 0, amp) * (1 - soundMix)) + (Pulse.ar(fr, pulseWidth, amp) * soundMix); Out.ar(out, EnvGen.ar(Env.perc(att, rel), doneAction: 2) * mix) }).add; x = Pbind(\instrument, \synth_4_ar, \dur, 0.1, \in, PL(\in), \amp, PL(\amp), \midiInt, Pfunc { rrand(~int[0], ~int[1]) }, // interval bounds \rel, Pfunc { ~rel.choose }, // short and long release time \soundMix, Pwhite(0.1, 0.9), \indexLR, PLrand([0, 1]) ); ) ( // in GUI start control synth before EventStreamPlayer // then try playing with sliders and pausing / resuming the control synth c = Bus.control(s,1).index; VarGui([\in, [c, c, \lin, 1, c], // bus fixed, display only \int, [3,4].collect([0, 19, \lin, 0.1, _]), \rel, [0.01, 0.15].collect([0.01, 0.4, \lin, 0.005, _]), \amp, [0.0, 0.3, \lin, 0.01, 0.15]], [\midiCenter, [45, 80, \lin, 0.1, 70], \midiDev, [0, 20, \lin, 0.1, 20], \devFreq, [0.1, 15, \lin, 0.1, 1], \out, c], // bus fixed, display only x, \synth_4_kr ).gui(sliderPriority: \synth, playerPriority: \synth) )

Ex. 4b: interaction of synth and stream players, pbind and control synth controlling audio synth

Audio synth controlled by LFO pitch synth and a Pbind setting synth args (like Pmono). PLx ListPatterns taken here as they default to repeats = inf.( y = Pbind(\type, \set, // sequencing of durations and amplitudes quite fixed, just global tempo and amp control \dur, PLshufn([0.15, 0.15, 0.35]) / PL(\tempo), \amp, PLrand([0.05, 0.12, 0.2]) * PL(\amp), \soundMix, PLseq([0.1, 0.5, 0.9]), \indexLR, PLrand([0, 1]), \midiInt, Pfunc { rrand(0, ~intMax) }, \args, [\amp, \soundMix, \midiInt, \indexLR] // args to be set must be listed ); // In GUI start control synth (#0) first, then audio synth (#1) and EventStreamPlayer, // then try playing with sliders and pausing / resuming the control synth and EventStreamPlayer. d = Bus.control(s,1).index; VarGui([ \tempo, [0.7, 1.2, \lin, 0.01, 1], \amp, [0.0, 1.5, \lin, 0.01, 0.7], \intMax, [-12, 12.0, \lin, 0.1, 8]], [[\midiCenter, [45, 80, \lin, 0.1, 60], \midiDev, [0, 20, \lin, 0.1, 1.5], \devFreq, [0.1, 15, \lin, 0.1, 10], \out, d], // just display bus indices [\in, d, \out, 0, \rel, 10000]], // ignore Env.perc definition y, [\synth_4_kr,\synth_4_ar] ).gui(sliderPriority: \synth, playerPriority: \synth) )

Ex. 5a: reordering of var control

One may want to have controls grouped per name, not per Environment (resp. Pbind, Task, Synth), this can be achieved by passing a flat (not grouped) array of specPairs and the appropriate grouping, there are methods implemented for that special case of reordering:

SynthDef from Ex.1a( p = Pbind( \instrument, \synth_1a, \preAmp, PL(\preAmp), \amp, PL(\amp), \midinote, Pfunc { ~midi + rrand(~midiDev.neg, ~midiDev) }, \dur, 0.2 ); // flat specPairs array without multiple keys ~specPairs = [\midi, [24, 80, \lin, 1, 36], \midiDev, [0, 0.5, \lin, 0.01, 0.25], \amp, [0, 0.3, \lin, 0.01, 0.1], \preAmp, [5, 50, \lin, 0.01, 25]]; // get flat expansion of specPairs and appropriate groups ~specPairsDupped = ~specPairs.specPairsDup(5).postln; ~specPairsGroups = ~specPairs.specPairsDupGroups(5); ) // parallel slider movement with Alt (not an array here but identically named variables in different envirs) // parallel player action with Shift-click ( v = VarGui( ~specPairsDupped, stream: p!5, varEnvirGroups: ~specPairsGroups, quant: 0.2 ).gui(colorDeviation: 0); ) // compare implicit mapping by passing a grouped collection of specPairs as varCtr arg ( v = VarGui( ~specPairs!5, stream: p!5, quant: 0.2 ).gui(colorDeviation: 0); ) // Note that in the case of not connected varEnvirGroups the column break gui option // allowEnvirBreak is ignored, means always set to true.

Ex. 5b: reordering of synth control

Ex. 6a: non standard usage: passing Synths

Passing symbols or strings as synth args, refering to known (added) SynthDefs, is recommended. However also Synths or nodeIDs can be given, but the player would have to know their state, so Synths should be registered.( SynthDef(\sine, { |freq = 400, amp = 0.1| Out.ar(0, SinOsc.ar(freq, mul: amp)) }).add; SynthDef(\pulse, { |freq = 400, amp = 0.1| Out.ar(0, Pulse.ar(freq, mul: amp)) }).add; ) ( x = Synth(\sine).register; y = Synth(\pulse).register; ) // pause pulse y.run(false); // VarGui checks state, definition is known, new Synths of same definition can be started v = VarGui(synth: [x,y]).gui; // With nodeIDs or non-registered Synths VarGui demands addtional state info ( x = { SinOsc.ar(400, mul: 0.1) }.play; y = { Pulse.ar(700, mul: 0.01) }.play; ) y.run(false); // no new Synths from temporary synth definition v = VarGui(synth: [x,y], assumePlaying: true, assumeRunning: [true, false]).gui;

Ex. 6b: non standard usage: setting sliders from outside

Ex. 6c: non standard usage: setting values for plotting

Ex. 7: color grouping

Ex. 8: EZSmoothSlider, EZRoundSlider

Ex. 9: slider step precision

Ex. 10: MIDI learn functionality with sliders

Connect your midi device, maybe you have to restart SC then. As gui example e.g. take SynthDefs and Pbind from Ex.4a, evaluate both code blocks. It must be possible to refer to the VarGui instance (e.g. v = VarGui(...))// start MIDI MIDIIn.connectAll // on your device define desired knobs, faders etc. to send cc messages // probably you want to control different parameters, so define different cc numbers // start learning mode v.startMIDIlearn // now assignment can happen by selecting a slider box // it gets a focus (blue border, sometimes not very well visible) // then send midi cc with the fader/knob of your choice // sending data with different cc number, while the same slider is still or again selected, will overwrite // end of learning has to be defined v.stopMIDIlearn // adaption of control can be done by recalling the learning mode v.startMIDIlearn ... v.stopMIDIlearn