maladie

Hey everyone, I have recently been exploring using Javascript to send values around some large Max patches and I have understood the basics of using notation such as:

     var seek1 = this.patcher.getnamed("seek1");

However this does not seem to work between different subpatchers, it seems that it only works in the exact same patcher. Is there another formulation for when it should be sent between subpatches and/or to a poly~ object? I'm mainly looking at this to save some space as well as a bit of CPU in patches that are used for live electronics.

Hey everyone,  I have recently been exploring using Javascript to send values around some large Max patches and I have understood the basics of using notation such as: 	var seek1 = this.patcher.getnamed("seek1");
 	seek1.message(15);

However this does not seem to work between different subpatchers, it seems that it only works in the exact same patcher. Is there another formulation for when it should be sent between subpatches and/or to a poly~ object? I'm mainly looking at this to save some space as well as a bit of CPU in patches that are used for live electronics. 

sending-values-through-javascript-between-subpatchers-and-poly

@MALADIE Check out the applydeep() JS patcher method. It may be helpful, and should theoretically work on poly~ patchers.

    if(x.getattr("varname") == "seek1") {

function findobj(x) {
	if(x.getattr("varname") == "seek1") {
		x.message(val);
	}
}

function sendval(n) {
	val = n;
	this.patcher.applydeep(findobj);
}

That method does seem a bit heavy handed. I was thinking of using Javascript in some of my larger patches to handle variables and settings, to save CPU as well as space since so many send/receives and such take up a lot of space. However, I'm wondering if this method would actually even be faster than the send/receives one normally uses?

That works, thanks a lot for the answer! 

To get objects within subpatches (wihtout the "applydeep") you must "get" the subpatch object, and then from that object get the object you want.

An example of getting a numberbox with scripting name "numbox" inside a subpatch with scripting name "subp_1" would be like:

var spobj = this.patcher.getnamed("subp_1");
var nbobj = spobj.getnamed("numbox)";

or for saving some space you could do it like:

var nbobj = this.patcher.getnamed("subp_1").getnamed("numbox)";

The apply deep will work ok, but imagine having an abstraction that has a named numberbox inside. When you create the abstraction in a patcher, the numberbox will have the same scripting name on every abstraction, and that is OK (you can't have same named objects in the same "level" i.e. the same patch). In this case the 

 will send the value in every object that meets its criteria (in Ben's example, that is having the var name "seek1".

I guess in some cased that would be fine...

Anyway, as for the [poly~], you can get an object from a specific instance (just found out how)!!

First the [poly~] must have a scripting name, and the object you want to get, must also be named.

Lets assume the [poly~] has a varname like "polyprocessor", and you want an object named "numbox". Your JS should do something like this:

var nbobj = this.patcher.getnamed("polyprocessor").subpatcher(X).getnamed("numbox");

where X is the instance you want to look into (0 based).

The apply deep will work ok, but imagine having an abstraction that has a named numberbox inside. When you create the abstraction in a patcher, the numberbox will have the same scripting name on every abstraction, and that is OK (you can't have same named objects in the same "level" i.e. the same patch). In this case the applydeep will send the value in every object that meets its criteria (in Ben's example, that is having the var name "seek1".

I definitely don't think that this will be faster than send/receive, especially because it is an iterative process. The bigger/deeper the patcher, the less economical this will be.

Another option to consider is the pattr/parameter system.

I definitely don't think that this will be faster than send/receive, especially because it is an iterative process. The bigger/deeper the patcher, the less economical this will be. 

another way to get an object within a subpatcher is to "get" the subpatcher object, and the "get" the object. For example, lets say you have a numberbox named "numbox" inside a subpatcer with varname "sub_1". You can do the following to get the numberbox:

var subObj = this.patcher.getnamed("sub_1"); // This gets the subpatcher
var numObj = subObj.getnamed("numbox"); // This gets the numberbox that is inside the sub_1 subpatcher.

var numObj = this.patcher.getnamed("sub_1").getnamed("numbox");

The difference with the "applydeep" is that the "applydeep" looks for 

 object that meets its criteria (in Ben's example that is to have a varname of "seek1") and does something. Imagin having an abstraction with a named object that you use several times in a patcher and only want to send something to one of them, with the "applydeep" it will be send to all.

Of course, you might want exctly that, so in that case go with "applydeep".

As for the [poly~] you can do something similar. You have to give a scripting name to the [poly~] and to the objects of the patch you are goind to load to the [poly~], that you want to "get". Again, as an example lets say you have [poly~] with a varname "polyProcessor" and that in the patch it loads, you have a numberbox named "numbox". To get that numberbox you ca do the following:

var polyObj = this.patcher.getnamed("polyPorcessor"); // This gets the [poly~] object
var numObj = polyObj.subpatcher(X).getnamed("numbox"); // Where X is the poly's instance (starting from 0)

var numObj = this.patcher.getnamed("polyPorcessor").subpatcher(X).getnamed("numbox");

Hi Maladie,
another way to get an object within a subpatcher is to "get" the subpatcher object, and the "get" the object. For example, lets say you have a numberbox named "numbox" inside a subpatcer with varname "sub_1". You can do the following to get the numberbox:

Or in a single line:var numObj = this.patcher.getnamed("sub_1").getnamed("numbox");

The difference with the "applydeep" is that the "applydeep" looks for every object that meets its criteria (in Ben's example that is to have a varname of "seek1") and does something. Imagin having an abstraction with a named object that you use several times in a patcher and only want to send something to one of them, with the "applydeep" it will be send to all.
Of course, you might want exctly that, so in that case go with "applydeep". 

Again you can do it like:var numObj = this.patcher.getnamed("polyPorcessor").subpatcher(X).getnamed("numbox");

I've been testing all of this out and found things that work. Weirdly enough though the following code:

 var numObj = this.patcher.getnamed(&quot;sub_1&quot;).getnamed(&quot;numbox&quot;);

does not work, unless I have the .subpatcher(x) even when it's not a poly~ object which is interesting..

I've been testing all of this out and found things that work. Weirdly enough though the following code: var numObj = this.patcher.getnamed(&quot;sub_1&quot;).getnamed(&quot;numbox&quot;); 

does not work, unless I have the .subpatcher(x) even when it's not a poly~ object which is interesting..


 even if not for the [poly~] because you get the object, and then you get the objects subpatcher.

 without a number in it when using it with [pather] objects as they only have 1 instance of the subpatcher and will just return that e.g.

var numObj = this.patcher.getnamed("sub_1").subpatcher().getnamed("numbox");

Yes, it should need the .subpatcher() even if not for the [poly~] because you get the object, and then you get the objects subpatcher.
I must have forgotten in it!
You can call the .subpather() without a number in it when using it with [pather] objects as they only have 1 instance of the subpatcher and will just return that e.g.var numObj = this.patcher.getnamed("sub_1").subpatcher().getnamed("numbox");

Sending values through javascript between subpatchers and poly~