class:: ProxyMixer
summary:: mix control for a proxyspace or Ndef.all
categories:: JITLib>GUI, Live Coding
related:: Classes/ProxySpace, Classes/Ndef, Classes/JITGui, Classes/NdefGui, Classes/MonitorGui, Classes/NdefParamGui

description::

ProxyMixer provides controls for handling and editing the node proxies in a proxyspace and their monitors (cross-platform graphics). It replaces the earlier ProxyMixer class. For Ndefs, use link::Classes/NdefMixer::.

Overview: link::Overviews/JITLib::

code::

// First examples:
(
p = ProxySpace.push(s.boot, p);
"abcde".do { |k| p[k.asSymbol].ar };
m = ProxyMixer(p, 8);
n.parent.alwaysOnTop_(true); // show mixer in front of IDE
)

p.do(_.play(0));
m.object_(nil);
m.object_(p);

// if you have JITLibExtensions installed, try ProxyMeter to see the proxy levels:
if (\ProxyMeter.asClass.notNil) { ProxyMeter.addMixer(m); };


"abcdefghijk".do { |k| p[k.asSymbol].ar };

"lmnopqrtuvw".do { |k| p[k.asSymbol].kr };

"abcdefghijk".do { |k, i|
	p[k.asSymbol].playN(vol: 0.8 - (0.1 * i) );
	p[k.asSymbol].source = {
		VarSaw.ar((i + 1 * 100) + [-1, 1])
		* LFSaw.ar((i + 1 * 0.25));
	};
};
::

ClassMethods::

subsection::Creation

method::new

argument::obj
the proxyspace to show and control

argument::numItems
how many ar and kr proxies can be shown

argument::parent
by default nil, so a window is made automatically. if a parent is supplied, the ProxyMixer will be shown there.

argument::bounds
window bounds - default is nil, so it determines it size.

argument::makeSkip
a flag whether to make make a skipjack

argument::options
additional settings - currently none provided.

method::small
like *new, but creates a proxyMixer for small screen sizes.


InstanceMethods::

subsection::Instance variables

strong::GUI areas and elements: ::
method::arZone, krZone, editZone, arGuis, krGuis, editGui, arScroller, krScroller

strong::current state and access methods: ::
method::proxyspace, existingProxies, activeProxies, playingProxies, selectedKeys, arNames, krNames, numArs, numKrs, atAr, atKr

subsection::Instance methods

method:: highlight, unhighlight
highlight and unhighlight an arGui slot in the arZone (left)
method:: highlightSlots
highlight a block of the arGuis in the arZone/

method::sizes, switchSize
switch between display modes 0: ar, 1: ar+kr, 2: ar+kr+ed

method::arKeysRotation, krKeysRotation
if too many proxies are present, by how much to rotate arKeys or krKeys to display.

method:: title
get the proxymixer window title.


method:: getNameLeftBorder
gets current left border of nameView
method:: setNameLeftBorder
sets current left border of nameView, trading size with volume slider
method:: shiftNameLeftBorder
shifts current left border of nameView

code::
m.getNameLeftBorder; // get its current left border position
m.setNameLeftBorder(250); // default
m.setNameLeftBorder(200); // aps left pos, smaller slider
// relative adjust:
m.shiftNameLeftBorder(10);
m.shiftNameLeftBorder(-10);

strong::standard JITGui methods: ::
method:: setDefaults, accepts, getState, checkUpdate

strong::internal - making the ProxyMixer gui elements: ::
method:: makeViews, makeTopLine, makeArZone, makeKrZone, makeEditZone, setEdButs

Examples::

code::

// make a proxyspace and 5 ar proxies, and a mixer to show them
(
p = ProxySpace.push(s.boot, p);
"abcde".do { |k| p[k.asSymbol].ar };
m = ProxyMixer(p, 8);
p.do(_.play(0));
)

m.object_(nil); // no object
m.object_(p);   // the proxyspace

// if you have JITLibExtensions installed, try ProxyMeter to see the proxy levels:
if (\ProxyMeter.asClass.notNil) { ProxyMeter.addMixer(m); };

    // make too many ar proxies, get a scroller
"abcdefghijk".do { |k| p[k.asSymbol].ar };

    // make too many kr proxies, get a scroller
"lmnopqrtuvw".do { |k| p[k.asSymbol].kr };

p.stop;
    // play some of them
m.arNames.scramble.keep(5).do { |k| p[k.asSymbol].playN };

    // the top left menu sets which proxies will be shown.

        // existingProxies: even an empty proxy is shown
~test.ar;

(        // activeProxies: proxy appears when it is alive
~test = { |freq=250, intv=19, timescale=1, curve=0, loopnode=0|
    var env = EnvGen.kr(
        Env({ 1.0.rand2 }!11, {1.0.rand}!10, curve, releaseNode: 9, loopNode: loopnode),
        timeScale: timescale);
    var pitch = (env * [1, 0.33, -1] * intv).midiratio * freq;
    Splay.ar(Formant.ar(pitch, pitch.scramble * 2, pitch.scramble)) * 0.1;
};
)
~test.lag(\freq, 4);

        // playingProxies : only those that really play are shown.
~test.playN(vol: 1);

// switch back to active proxies...
        // the reduce button removes all proxies that are not playing
        // and that are not used as sources in other proxies:
~otto = { |dens=12| Dust.ar(dens) };

~otto.clear;        // remove it
p.reduce;

        // doc and docSel post the current proxyspace as code
p.document;

        // ProxyMixer has three preset widths:
m.switchSize(0);    // ar zone only
m.switchSize(1);    // ar + kr
m.switchSize(2);    // ar + kr + edit zone

        // try with a small ProxyMixer:
l = ProxyMixer.small(p, 8);
l.switchSize(0, true);    // ar zone only
l.switchSize(1, true);    // ar + kr
l.switchSize(2, true);    // ar + edit zone

        // Record opens a utility window, RecordProxyMixer.
        // this requires the JITLibExtensions quark.

    // the line of controls for one proxy and its monitor is
    // a ProxyMonitorGui, so for full details see ProxyMonitorGui.help.

    // it displays current volume,
~test.vol_(0.05);
~test.vol_(0.1);

    // proxy name; play/stop/end control:
~test.playN;        // playN as is
~test.stop;        // stop
~test.end;        // option-click on stop : end the monitor and the proxy itself.
~test.playN(vol: 0);    // option-click on play : start playing with volume zero.

~test.playNDialog;  // shift-click on play/stop: set multichan outputs from code


s.scope(8);
~test.playN(4);    // set proxy's first output channel:
~test.playN(0);

// One can move the border between sliders and nameView:

n.enableNameResize(true);	// try click and dragging that border now

n.setNameLeftBorder(200);   // or set by code

    //    paus/rsum toggles pause and resume:
~test.pause;
~test.resume;

    // send button resends the proxy,
    // option-click on send rebuilds the proxy
    // (e.g. for lookup in client-site state)
~test.send;
~test.send;
~test.rebuild;
~test.rebuild;


    // the ed button sends this proxy to the editor - see below

        // kr proxies show up in the middle
~lfo = { SinOsc.kr(2) };
~lfnoyz0 = { |lofreq = 0.5, mul=1, add| LFDNoise0.kr(lofreq, mul, add) };

        // the editor zone is a NodeProxyEditor
        // open it and set some params
m.switchSize(2);
m.editGui.object_(~test);
~test.set(\freq, exprand(80, 1250));    // set ~tests parameters
~test.set(\intv, 1.0.linrand);

    //    if you declare global specs for the range of a parameter,
    //    they can be used in the editor:
m.editGui.paramGui.specs.clear;

Spec.add(\intv, [0, 36, \lin]);
Spec.add(\timescale, [0.001, 10, \exp]);
Spec.add(\loopnode, [0, 7, \lin, 1]);
Spec.add(\curve, [-10, 10]);

m.editGui.object_(~test);

        // you can map a kr proxy to a control param;
~test.map(\intv, ~lfnoyz0);
~test.unmap(\intv);
        // this also works by dragging the kr proxy name
        // the field left of the param name.


p.reduce(method: \clear);

p.clean;

p.clear;

::
