VarGui shortcut builds | SuperCollider 3.13.0 Help

Description

VarGui allows combined control of Synths, Pbinds / EventStreamPlayers and Tasks in one GUI. Many of its options though may not be relevant for most usages, also control specs were to be given directly (changed with v0.5). Shortcut build methods take advantage of SynthDef controlspec metadata, if defined (or global ControlSpecs), and autogenerate Pbinds for sequencing. Controls and Pbinds can be customized with options. Main tools are the methods sVarGui ( synth ), pVarGui ( pattern ) and compound builders spVarGui / psVarGui. Methods sVarGui / pVarGui, applied to a single Symbol / String, produce a VarGui for one or more Synth(s) or Pbind(s) based on the referred single SynthDef ( Ex.1a, Ex.1b, Ex.2a, Ex.2b ). Both methods also apply to collections of SynthDef Symbols / Strings ( Ex.3a, Ex.3b ), whereas spVarGui and psVarGui, builders of mixed Synth / Pbind VarGuis, expect collections of two items which may be Symbols / Strings or collections of Symbols / Strings ( Ex.3c ). Examples are using Patterns from dynamic scope PLx_suite for conveniently refering to environmental variables.

1. Synth GUIs

Ex.1a: default instrument

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

// No metadata is defined with default instrument, per default global ControlSpecs are used.
// Here its definition from Event.sc:

(
SynthDef(\default, { arg out=0, freq=440, amp=0.1, pan=0, gate=1;
    var z;
    z = LPF.ar(
        Mix.new(VarSaw.ar(freq + [0, Rand(-0.4,0.0), Rand(0.0,0.4)], 0, 0.3)),
        XLine.kr(Rand(4000,5000), Rand(2500,3200), 1)
    ) * Linen.kr(gate, 0.01, 0.7, 0.3, 2);
    OffsetOut.ar(out, Pan2.ar(z, pan, amp));
}, [\ir]).storeOnce;
)

// With the next line you should get a VarGui with controls for freq, amp and pan.
// If not, global ControlSpecs and / or the default instrument have probably been changed,
// see below how to display and change global Specs.
// In global ControlSpecs amp defaults to 0, you have to raise in order 
// to hear sound after pressing the player button

\default.sVarGui.gui;

// automatic use of global ControlSpecs turned off, Synths with default args

\default.sVarGui(useGlobalSpecs: false).gui;

// global specs, not all of them ControlSpecs, are stored in Spec.specs ...

Spec.specs.associationsDo(_.postln);

// ... they can be added or replaced with .add
// for default instrument examples 
// we replace \amp spec with a new ControlSpec with default 0.1

Spec.add(\amp, [0, 1, \lin, 0, 0.1]);

// generating a number of Synths, controls can be excluded,
// parallel slider dragging with Alt, parallel button action with Shift-click

\default.sVarGui(exclude: \pan, num: 3).gui;

// controls can be replaced ...

\default.sVarGui(ctrReplace: [\freq, [400, 440, \exp, 0, 420]]).gui;

// ... and added, before or after the main block of controls from metadata or global ControlSpecs,
// this collection is empty here, so ctrBefore and ctrAfter are equivalent

\default.sVarGui(useGlobalSpecs: false, ctrBefore: [\freq, [400, 440, \exp, 0, 420]]).gui;

// bad definition, \freq is already used as global ControlSpec

\default.sVarGui(ctrBefore: [\freq, [300, 1000, \exp, 0, 440]]).gui; // WRONG

Ex.1b: SynthDefs including metadata

SynthDef with defined controlspec metadata. The specs can be stored as ControlSpecs or Arrays, may also be Symbols / Strings refering to the global dictionary of Specs (Spec.specs). It's only convention to store specs under the key \specs, it can be anything else, and nothing prevents you from storing more than one dictionary of ControlSpecs per SynthDef - the VarGui shortcut methods have a metaKey arg (default: \specs) which determines where to lookup in the metadata dictionary.( SynthDef(\buzz, { arg freq = 400, out, gate = 1, freqDev = 0.01, att = 0.01, dec = 0.01, susLevel = 0.5, rel = 1, cutoff = #[1000, 1000, 1000], rq = 0.25, amp = 0.2, preAmp = 1, maxDelay = 0.03; var src, srcFreq, sig; sig = Mix.fill(3, { |i| // chorus spread over three registers srcFreq = (2 ** i) * freq * (1 + Rand(freqDev.neg, freqDev)) / 2; src = RLPF.ar(Saw.ar(srcFreq, preAmp), cutoff[i], rq).softclip * amp * EnvGen.kr(Env.adsr(att, dec, susLevel, rel), gate, doneAction: 2); // random spatialization (for sequencing) by L/R delay [DelayL.ar(src, maxDelay, Rand(0, maxDelay)), DelayL.ar(src, maxDelay, Rand(0, maxDelay))] }) ; // ensure sample accurate output for events of short durations OffsetOut.ar(out, sig); }, metadata: ( specs: ( freq: [20, 5000, \exp, 0, 80], gate: [0, 1.0, \lin, 0, 1], freqDev: [0.0, 0.02, \lin, 0, 0.002], att: [0.01, 0.2, \lin, 0, 0.01], dec: [0.01, 0.2, \lin, 0, 0.01], susLevel: [0.01, 1, \lin, 0, 0.5], rel: [0.01, 2, \exp, 0, 1], cutoff: [200, 5000, \exp, 0, 1000], rq: [0.1, 0.9,\lin, 0, 0.2], amp: [0.0, 1, \lin, 0, 0.2], preAmp: [0.9, 5, \lin, 0, 1], maxDelay: [0, 0.01, \lin, 0, 0.002] ), // doesn't matter for VarGui if spec defined as Array or ControlSpec, // an arbitrary number of arbitrarily named alternative Spec Events may be passed, // for non-sequencing use adsr params may be dropped basicSpecs: ( freq: [20, 5000, \exp, 0, 80], gate: [0, 1.0, \lin, 0, 1], cutoff: [200, 5000, \exp, 0, 1000], rq: [0.1, 0.9,\lin, 0, 0.2], amp: [0.0, 1, \lin, 0, 0.2], preAmp: [0.9, 5, \lin, 0, 1] ) ) ).add; ) // here metadata includes a gate spec with default 1 // metadata has priority over global ControlSpecs // metaKey \specs used per default \buzz.sVarGui.gui; // use gui options for better arrangement \buzz.sVarGui(num: 4).gui(tryColumnNum: 2, sliderHeight: 16); // alternative metadata, metaKey to be passed, // mostly sounds different from last version // because of fixed max chorus-width param freqDev \buzz.sVarGui(num: 4, metaKey: \basicSpecs).gui(tryColumnNum: 2);

2. Sequencing GUIs

Controlling Pbinds / EventStreamPlayers with VarGui is based on (a) the setting of environmental variables and (b) the proper definition of Pbinds with Patterns of PLx_suite or Patterns with functional code ( Event_patterns_and_Functions ) so that EventStreamPlayers get the updated variable values in the following events.

Basic example of a Pbind to get envir values:p = Pbind( \dur, Pfunc { ~dur } * Pseq([2,1,1], inf), \legato, Pfunc { ~legato }, \amp, Pfunc { ~amp } ) // or p = Pbind( \dur, PL(\dur) * Pseq([2,1,1], inf), \legato, PL(\legato), \amp, PL(\amp) )

Especially when based on a SynthDef with a large number of args writing a Pbind can be lengthy, moreover redundant if there are many pbind pairs of the form [ aSymbol, Pfunc { ~aSymbol } ]

The pVarGui method is going the opposite way: Pbind pairs get this most simple form for all args with metadata or global ControlSpecs defined, though it's possible to exclude keys and add respectively replace customized pairs before and after the automatically generated ones. All you need is a SynthDef that is suited for Pbind sequencing (known to SynthDescLib by being added, properly defined Envelopes).

WARNING: As a lot of the underlying Pbind structure (by default all of it !) is hidden, it's possible to call pVarGui without knowing anything about Patterns. Nevertheless it's highly recommended to be aware of the mechanisms of Pbind for applying useful sequencing customizations and having a look at the fully written Pbind examples in VarGui. Clearly: adding, replacing and excluding Pbind pairs without seeing the resulting code is a possible source of error, so if using VarGui this way better start slowly and go on stepwise. With the post option you can print out the ordered list of pairs.

Ex.2a: default instrument

// for default instrument examples 
// we replace \amp spec with a new ControlSpec with default 0.1

Spec.add(\amp, [0, 1, \lin, 0, 0.1]);

// Most simple example to get a VarGui controlling a Pbind / EventStreamPlayer with 
// default instrument, control of duration and legato is automatically added.
// As with the sVarGui method synth controls are added when found in metadata definition 
// or global ControlSpecs, different from sVarGui \gate is excluded by default.

\default.pVarGui.gui;

// adding a pattern pair - if it contains one of the keys \note, \midinote or \degree
// the freq pair is removed automatically, see posted Pbind pairs

\default.pVarGui(pAfter: [\degree, Pwhite(0,5)], post: true).gui;

// pattern pair replacement as in basic example above

\default.pVarGui(pReplace: [\dur, PL(\dur) * Prand([2,1,1], inf)] ).gui;

// adding a pattern pair after the main block of pairs,
// same effect as before

\default.pVarGui(pAfter: [\dur, Pkey(\dur) * Prand([2,1,1], inf)], post: true).gui;

// Internally a Pbind of this form had been generated (see post window), 
// in each Event the second Stream with key \dur gets the value from the first, 
// overrides it in the Event.

Pbind(
    // pBefore pairs (optinally passed to pVarGui) 
    ...
    
    // these are always placed before the main block
    \instrument, \default,
    \dur, Pfunc { ~dur },
    \legato, Pfunc { ~legato },
    
    // main block of pairs corresponding to args for which 
    // spec definition was found (if not excluded or replaced), 
    // ordered like in SynthDef
    
    \freq, Pfunc { ~freq },
    \amp, Pfunc { ~amp },
    \pan, Pfunc { ~pan },
    
    // pAfter pairs (optinally passed to pVarGui)
    \dur, Pkey(\dur) * Prand([2,1,1], inf)
)

// Additional arrayed control for simple step sequencing with random init values. 
// The PLseq degree pattern defaults to repeats = inf and envir = \current.
// It would take values from the current Environment of streamification.

// Here playing and setting the variables will 
// happen in a new Environment generated by the VarGui.

(
\default.pVarGui(
    ctrBefore: [\a, { [0, 5, \lin, 1, rrand(0,6)] } ! 8 ],
    pBefore: [\degree, PLseq(\a) ]
).gui;
)

// A number of Pbinds and control sets can be generated with the num arg,
// control and pattern customization args take Functions (optionally of indices)
// for expansion.

// This a potentially powerful feature, also suited for producing a real mess !
// Especially think of possibly inappropriate ranges ! 
// If you are unsure try out evaluating code of the form ...

{ |i| ... } ! n

// ... separately before plugging in the shortcut methods.

// Here the Function passed to ctrBefore has no index arg, 
// it just produces 4 different tuples of 
// init values for the step sequencers,

// the pBefore Function determines 4 different octave registers
// quant arg ensures staying in sync based on the passed rhythmic patterns

(
\default.pVarGui(
    /* ctrBefore: */ { [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 8 ] },
    /* ctrReplace: */ [\dur, [0.2, 0.6, \lin, 0.2, 0.2]],
    pBefore: { |i| [\degree, PLseq(\a), \octave, i+4] },
    num: 4,
    quant: 0.2,
    post: true 
).gui(tryColumnNum: 2);
)

Ex.2b: SynthDefs including metadata

Automatic Pbind generation in VarGui shortcut builds is especially saving typing if SynthDefs have a lot of args and controlspec metadata defined.// most simple, controls are built for all args with metadata defined // arrayed args are detected and controls are established for a corresponding array // SynthDef from above \buzz.pVarGui.gui; // use the exclude option to exclude from automatically generated controls and Pbind pairs // you would want to do that for a static value or sequencing not to be gui-controlled // always SynthDef default value 0.01 for attack time \buzz.pVarGui(exclude: [\att], post: true).gui; // sequencing without control // RLP filter rq excluded from gui control and automatic Pbind pair generation, // though added to Pbind pairs again as passed to pBefore (could also be pAfter), // here PLseq taken as it defaults to inf \buzz.pVarGui(exclude: [\rq], pBefore: [\rq, PLseq([ 0.05, 0.8, 0.8, 0.8]) ], post: true).gui; // same effect on sound, but we have a useless rq control \buzz.pVarGui(pAfter: [\rq, PLseq([ 0.05, 0.8, 0.8, 0.8]) ], post: true).gui; \buzz.pVarGui(pReplace: [\rq, PLseq([ 0.05, 0.8, 0.8, 0.8]) ], post: true).gui; // here the pBefore arg is useless as the Pfunc that takes controlled values // comes after in execution and will overwrite the value per Event \buzz.pVarGui(pBefore: [\rq, PLseq([ 0.05, 0.8, 0.8, 0.8]) ], post: true).gui; // establishing a cutoff freq rhythm for all three layers // remember that in Pbinds arrayed args must be distinguished from the syntax for generating // multiple synths per Event, this can be achieved by wrapping in an additional array \buzz.pVarGui(pReplace: [\cutoff, Pfunc { [~cutoff] } * PLseq([3,1,1]) ]).gui; // step sequencer for quartertone bassline ( \buzz.pVarGui( ctrAfter: [\a, { var lo = 25, hi = 50; [lo, hi, \lin, 0.5, rrand(lo*2, hi*2) / 2 ] } ! 8 ], pBefore: [\midinote, PLseq(\a)], post: true ).gui; ) // step sequencer with two voices // by passing functions different control ranges and registers are established // both lines are in a quartertone scale but shifted by an eigthtone // lines itself can be shifted by an offset ~add // modifier keys can be used to perform parallel slider or button actions // alt for parallel slider movement and shift for parallel button actions (VarGui) ( \buzz.pVarGui( ctrReplace: [\dur, [0.1, 0.2, \lin, 0.1, 0.2], \amp, [0.0, 0.5, \lin, 0, 0.3]], ctrAfter: { |i| var d = 0.25; [\add, [-12, 12, \lin, 0.5, 0], \a, { [(i*d), 11.5 + (i*d), \lin, 0.25, rrand(0, 23) / 2 + (i*d)] } ! 8 ] }, pBefore: { |i| [ \note, PLseq(\a) + PL(\add), \octave, 3 + (i*4) + Pwhite(0,1) ] }, quant: 0.2, post: true, num: 2 ).gui(tryColumnNum: 2); )

Ex.2c: Combination of parameter control and pattern exchange (JITLib)

Ex.2d: Combination of parameter control and pattern exchange (PLx)

// above done with PL
// note that PLs are taking envir variables from the current Environment by default,
// this is ok for the variables set by VarGui (freq) in its Environment,
// but for PLs to take values from elsewhere we must give the Environment explicitely.
// Suppose we are in topEnvironment here:

// As PL defaults to repeats = inf, Pseq can be taken without a repeats arg 
// for endless looping

(
~co = Pseq([3, 1, 1, 1, 1]);
~fr = Pseq([1, 1, 1.3, 1.2, 1]);

\buzz.pVarGui(
    ctrReplace: [\freq, [20, 1000, \exp, 0, 80]],
    pReplace: [
        \cutoff, PL(\co, envir: \top) * Pfunc { [~cutoff] },
        \freq, PL(\fr, envir: \top) * PL(\freq)
    ]
).gui;
)

// start from gui and eval pattern replacements before playing around with sliders

~fr = Pseq([1, 1, 1.7, 1.3, 1.2]);

~co = Pseq([2, 1, 1]);

~fr = 1;

~co = Pseq([1, 2, 1.7, 1.3, 1.2]);

//////////////////////////////////

// alternative version with a PLseq placeholder

(
~co = [3, 1, 1, 1, 1];
~fr = [1, 1, 1.3, 1.2, 1];

\buzz.pVarGui(
    ctrReplace: [\freq, [20, 1000, \exp, 0, 80]],
    pReplace: [
        \cutoff, PLseq(\co, envir: \top) * Pfunc { [~cutoff] },
        \freq, PLseq(\fr, envir: \top) * PL(\freq)
    ]
).gui;
)

// start from gui and eval pattern replacements before playing around with sliders

~fr = [1, 1, 1.7, 1.3, 1.2];

~co = [2, 1, 1];

~fr = [1];

~co = [1, 2, 1.7, 1.3, 1.2];

3. Mixed GUIs

To control Synths or Pbinds / EventStreamPlayers derived from more than one SynthDef sVarGui and pVarGui can be applied to collections.

Ex.3a: Synths from different SynthDefs

Ex.3b: Pbinds from different SynthDefs

Ex.3c: Synths and Pbinds

// Pbind granulation with \buzz, controls and pbind pairs adapted and added, 
// psVarGui (pbind input first) and spVarGui (synth input first)
// apply to collections of two items.

// If only one type of SynthDef is to be used for Pbind(s) or Synth(s)
// it may be a plain Symbol / String, the corresponding arg tuples may
// be given as plain (not collected) Dictionaries

// Keep in mind that nevertheless one Dictionary may produce 
// more than one Synth (Pbind)
    
(
[\buzz, \default].psVarGui(
    (
        ctrReplace: [\dur, r = [0.01, 0.05, \lin, 0, 0.03], 
            \rel, r,
            \freq, [100, 1000, \lin, 0, 100],
            \amp, [0, 0.5, \lin, 0, 0.15],
            \legato, [0.1, 2, \lin, 0, 0.5],
            \freqDev, [0, 0.2, \lin, 0, 0.01]],
        ctrBefore:    [\durDev, [0, 1, \lin, 0, 0.01]],
        pAfter: [\dur, Pkey(\dur) * Pfunc { x = 1 + ~durDev; rrand(1/x,x) }],
        post: true
    ),(
        ctrReplace: { [\dur, [0.01, 0.05, \lin, 0, 0.03],
            \freq, [100, 1000, \lin, 0, rrand(100, 1000)]] }, 
         num: 4
    )
).gui(tryColumnNum: 2, allowEnvirBreak: false);
)

// If more than one type of SynthDef is to be used for Pbind(s) or Synth(s)
// Symbols / Strings must be collected, also the corresponding Dictionaries

// spVarGui just takes input in reversed order (synth first).
// This is independent from representation in the GUI
// which can be determined by args sliderPriority (\var or \synth)
// and playerPriority (\stream or \synth)

(
[\default, [\buzz, \default]].spVarGui(
    (
        ctrReplace: { [\dur, [0.01, 0.05, \lin, 0, 0.03],
            \freq, [100, 1000, \lin, 0, rrand(100, 1000)]] }, 
        num: 4
    ),[
        (
            ctrReplace: [\dur, r = [0.01, 0.05, \lin, 0, 0.03], 
                \rel, r,
                \freq, [100, 1000, \lin, 0, 100],
                \amp, [0, 0.5, \lin, 0, 0.15],
                \legato, [0.1, 2, \lin, 0, 0.5],
                \freqDev, [0, 0.2, \lin, 0, 0.01]],
            ctrBefore:    [\durDev, [0, 1, \lin, 0, 0.01]],
            pAfter: [\dur, Pkey(\dur) * Pfunc { var x = 1 + ~durDev; rrand(1/x,x) }],
            post: true
        ),(
            ctrReplace: [\dur, r = [0.01, 0.05, \lin, 0, 0.03], 
                \freq, [100, 1000, \lin, 0, 100],
                \amp, [0, 0.5, \lin, 0, 0.15],
                \legato, [0.1, 2, \lin, 0, 0.5]],
            ctrBefore:    [\durDev, [0, 1, \lin, 0, 0.01],
                \freqDev, [0, 0.2, \lin, 0, 0.01]],
            pAfter: [\dur, Pkey(\dur) * Pfunc { var x = 1 + ~durDev; rrand(1/x,x) },
                \freq, Pkey(\freq) * Pfunc { var x = 1 + ~freqDev; rrand(1/x,x) }],
            post: true
        )
    ]
).gui(tryColumnNum: 2, allowEnvirBreak: false, sliderPriority: \synth, playerPriority: \synth);
)

4. Differences between shortcut builds and direct VarGui instantiation

Shortcut methods apply to Symbols / Strings or collections thereof for Synth and Pbind generation and control. Symbols / Strings refer to the corresponding SynthDefs, known to SynthDesLib.global. For passing Synths, nodeIDs, EventStreamPlayers, also Task Functions and Tasks, you would have to call VarGui directly.
Shortcuts and also direct instantiation (not before v0.5) are using SynthDef metadata and / or global ControlSpecs. Though customization options for specs (exclude, add, replace) are a main feature of the shortcut methods. As a compromise spec- and pbindmaker methods with these options may be plugged into direct instantiation ( 5b ).
The pVarGui method invokes automatic Pbind generation with customization options for Pbind pairs (exclude, pBefore, pAfter, pReplace), VarGui expects Pbinds to be passed directly. As a compromise a pbindmaker method with these options may be plugged into direct instantiation ( 5b ).
In shortcut methods the num arg causes coordinated expansion, all other args (except server) may optionally be given as Functions of indices. With VarGui input you'd have to pass lengthy nested Arrays or write something like { |i| ... } ! n for every arg explicitely, as sizes of input must match. As a compromise spec- and pbindmaker methods with num arg may be plugged into direct instantiation ( 5b ).
Reordering / interleaving of controls of different Environments / Synths ( VarGui: Ex. 5a and VarGui: Ex. 5b ) is not possible with shortcut methods. However this seems to be a quite special feature, with shortcut methods ordering of Synths / Pbinds is primarily defined by order of args, control customization options allow further modifications of order. Finally choosing sliderPriority (\synth or \var first) is a pure gui method option and applies to both ways of VarGui building.

5. Shortcut method specifictions

Shortcut methods also take Functions, that should return args in a valid form. This can be used for defining controls in different ranges in combination with num. See examples above.

5a: core shortcut methods

Symbol: -sVarGui

SequenceableCollection: -sVarGui

Symbol: -pVarGui

SequenceableCollection: -pVarGui

NOTE: The following two methods are equivalent, just take opposite arg order. This is independent of arrangement, which can be determined by gui args sliderPriority (\var or \synth) and playerPriority (\stream or \synth).

SequenceableCollection: -spVarGui

SequenceableCollection: -psVarGui

5b: spec- and pbindmaker methods

In most cases you won't need this, except for reloading customized sequencing VarGuis ( 6 ). For special arrangements methods for making specdata and Pbinds of appropriate Pfuncs can be used for customizing control with direct VarGui instantiation. These methods take args in the same way as sVarGui and pVarGui.

Symbol: -sVarGuiSpecs

Symbol: -pVarGuiSpecs

Symbol: -pfuncPbinds// sVarGuiSpecs returns a list of spec pair lists of the form [\key, specArray, ...] // derived from SynthDef metadata / global ControlSpecs, // controls can be excluded, added and replaced ( VarGui( synth: [\default, \buzz], synthCtr: \default.sVarGuiSpecs ++ \buzz.sVarGuiSpecs(ctrReplace: [\amp, [0, 0.5, 0, 0, 0.1]]) ).gui; ) // shorter ( [\default, \buzz].sVarGui( (), (ctrReplace: [\amp, [0, 0.5, 0, 0, 0.1]]) ).gui; ) // as with sVarGui arguments can be functions of indices ( VarGui( synth: \default!4 ++ \buzz, synthCtr: \default.sVarGuiSpecs(num: 4, ctrReplace: { |i| var x = i*100 + 400; [\freq, [x, x*1.1, 0, 0, x]] }) ++ \buzz.sVarGuiSpecs(ctrReplace: [\amp, [0, 0.5, 0, 0, 0.2]]) ).gui(tryColumnNum: 2, allowSynthBreak: false); ) // shorter ( [\default, \buzz].sVarGui( (num: 4, ctrReplace: { |i| var x = i*100 + 400; [\freq, [x, x*1.1, 0, 0, x]] }), (ctrReplace: [\amp, [0, 0.5, 0, 0, 0.2]]) ).gui(tryColumnNum: 2, allowSynthBreak: false); ) // pVarGuiSpecs also returns a list of spec pair lists, // just adds specs for dur and legato by default, // pfuncPbinds returns appropriate Pbinds of Pfuncs // additional pairs can be added // however, compared to pVarGui, more coordination is the user's responsibility: // specmaker and pbindmaker don't know about each other // useless control \freq excluded explicitely here ( VarGui( varCtr: \buzz.pVarGuiSpecs(ctrBefore: [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 8 ], ctrReplace: [\dur, [0.2, 0.4, \lin, 0.2, 0.2]], exclude: \freq) ++ \default.pVarGuiSpecs(ctrBefore: [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 4 ], ctrReplace: [\dur, [0.1, 0.3, \lin, 0.1, 0.2]], exclude: \freq), stream: \buzz.pfuncPbinds(pBefore: [\degree, PLseq(\a), \octave, 3]) ++ \default.pfuncPbinds(pBefore: [\degree, Pfunc { [0, [0,4], [0,5]].choose } + PLseq(\a), \octave, Pwhite(5,7)], post: true), quant: 0.2 ).gui(tryColumnNum: 2, allowEnvirBreak: false); ) // shorter ( [\buzz, \default].pVarGui(( ctrBefore: [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 8 ], ctrReplace: [\dur, [0.2, 0.4, \lin, 0.2, 0.2]], pBefore: [\degree, PLseq(\a), \octave, 3], quant: 0.2 ),( ctrBefore: [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 4 ], ctrReplace: [\dur, [0.1, 0.3, \lin, 0.1, 0.2]], pBefore: [\degree, Pfunc { [0, [0,4], [0,5]].choose } + PLseq(\a), \octave, Pwhite(5,7) ], quant: 0.2 ) ).gui(tryColumnNum: 2, allowEnvirBreak: false); )

6. Save and load

A VarGui's slider state can be saved via save button and dialog. Loading is straightforward with Synths. You just have to give the correct path and synth arg (which maybe has to be an array).// change slider positions and save \buzz.sVarGui.gui; // reload VarGui.load("Path_To_XY", "XY", synth: \buzz).gui; // change slider positions and save \buzz.sVarGui(num: 4, metaKey: \basicSpecs).gui(tryColumnNum: 2); // reload, synth arg must have corresponding size VarGui.load("Path_To_XY", "XY", synth: \buzz ! 4).gui(tryColumnNum: 2);

VarGui only saves slider states, not the Pbind structure (would open a can of worms). So if you had a customized Pbind in the original setup you'd have to pass an appropriate Pbind together with load. This can also be a Pbind other than in the original setup. But if you want to restore you can nearly copy the input of the original cutomization into the pbindmaker method pfuncPbinds ( 5b ).// with no customization save and load also works straightforward // change slider positions and save \buzz.pVarGui.gui; // standard pbind is (re-)autogenerated and fits the variables to be set VarGui.load("Path_To_XY", "XY", stream: \buzz).gui; // only controls are customized, save and load also works straightforward // change slider positions, save and reload ( [\default, \buzz].pVarGui( (ctrReplace: { |i| var f = (2*i + 1) * 100, d = 0.2, lo = 0.99, hi = 1.01; [\freq, [f*lo, f*hi, 0, 0, f*rrand(lo,hi)], \dur, [d*lo, d*hi, 0, 0, d*rrand(lo,hi)] ] }, post: true, num: 4), (ctrReplace: [\freq, [97, 103, \exp, 0, 99], \dur, [0.195, 0.205, 0, 0, 0.2] ]) ).gui(tryColumnNum: 2, allowEnvirBreak: false) ) ( VarGui.load("Path_To_XY", "XY", stream: \default ! 4 ++ \buzz) .gui(tryColumnNum: 2, allowEnvirBreak: false) ) // change slider positions and save ( [\buzz, \default].pVarGui(( ctrBefore: [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 8 ], ctrReplace: [\dur, [0.2, 0.4, \lin, 0.2, 0.2]], pBefore: [\degree, PLseq(\a), \octave, 3], quant: 0.2 ),( ctrBefore: [\a, { [0, 6, \lin, 1, rrand(0,6) ] } ! 4 ], ctrReplace: [\dur, [0.1, 0.3, \lin, 0.1, 0.2]], pBefore: [\degree, Pfunc { [0, [0,4], [0,5]].choose } + PLseq(\a), \octave, Pwhite(5,7) ], quant: 0.2 ) ).gui(tryColumnNum: 2, allowEnvirBreak: false); ) // restoring pbind structure, note that pfuncPbinds always returns a collection // and quant arg is separate in VarGui.new and VarGui.load ( VarGui.load("Path_To_XY", "XY", stream: \buzz.pfuncPbinds(pBefore: [\degree, PLseq(\a), \octave, 3]) ++ \default.pfuncPbinds(pBefore: [\degree, Pfunc { [0, [0,4], [0,5]].choose } + PLseq(\a), \octave, Pwhite(5,7) ]), quant: 0.2 ).gui(tryColumnNum: 2, allowEnvirBreak: false) )

helpfile source: HelpSource/Tutorials/VarGui_shortcut_builds.schelp
link::miSCellaneous_lib/Tutorials/VarGui_shortcut_builds::

VarGui shortcut buildsExtension

VarGui shortcut builds
Extension