Creating inlets and outlets automatically

You can using scripting with the thispatcher object to create objects and connect them. It takes a bit to figure out how to properly write the patch, but I've used this before and it works like a charm.

Right....but I was hoping someone had already made such a facility that I could just use....For example, it would be a nice addition to the Max Toolbox

I did this recently in an attempt to build a modular synth.
Have a look:

IO.maxpat:

IO.js:

// IO Objects
var myInlets = null;
var myOutlets = null;
var numInlets = 0;
var numOutlets = 0;

// Inlet coordinates
var inletInsetX = 100;
var inletInsetY = 0;
var inletOffsetX = 50;
var inletOffsetY = 10;
// Outlet coordinates
var outletInsetX = 100;
var outletInsetY = 400;
var outletOffsetX = 50;
var outletOffsetY = 10;

// Creates a given number of inlets and outlets
function createIO(nInlets, nOutlets) {
    clearIO();
    numInlets = nInlets;
    myInlets = [numInlets];
    for(var i=0; i-1; i--) {
            if(myInlets[i] != null) {
                this.patcher.remove(myInlets[i]);
                myInlets[i] = null;
            }
        }
    }
    if(myOutlets != null) {
        for(i=numOutlets-1; i>-1; i--) {
            if(myOutlets[i] != null) {
                this.patcher.remove(myOutlets[i]);
                myOutlets[i] = null;
            }
        }
    }
    numInlets = numOutlets = 0;
    myInlets = null;
    myOutlets = null;
}

Sorry, took too long to edit that post into something more human-readable. But the patch is there, and just in case the [js] object within it doesn't already contain the script, I've uploaded it here... Just be sure to add a path to it under 'Options->File Preferences' so the [js] object can find it.

if all you need is functionality, this is extremely easy in max. [poly~]. just fill up with maximum needed ins and outs, then make all your poly~ patches from same template. then in parent the only 'scripting' you need to do is changing the 'comment' attributes on the actual outlets/etc to useful things (such as "unused", or whatever). then dynamically switch poly~ patchers. in audio situations, either live with the (tiny) discontinuity (in its own thread, so everything else safe) or auto ramp your immediate outputs on the changeover.

scripting actual objects and cables takes time and is messy unless done in javascript, and even then massive time taker. i have never come across a general situation where scripting ins/outs was actually useful / advisable / desirable. sometimes i understand it for specific tasks, good recent example is all the peter batchelor modular stuff - but those modules are not designed for 'live' use / changes - only set up etc. they are incredibly slow to instantiate.

2cents.

I want this as a technique to significantly simply the design of patchers that will have lots of abstractions. It's beneficial for bottom-up development where you create a patcher, make it work and then turn it into an abstraction with inlets and outlets instantly available (and it's much easier to then just delete the ones you don't want). As you build upwards, you have abstractions containing abstractions and some of the inlets and outlets need to just "flow" up or down, so making it trivial to create them would be very valuable.

For top-down development, I'd also love the ability to be able to simply define a new object by giving it a name and a couple of arguments that represent the number of inlets and outlets that the object should have. You could then wire that object up to other objects at a high level and then drill into the object later to implement it.

That's typically how a lot of top-down structured programs get created, you just assume that the lower level pieces you need will be there and you go implement them later. If you were writing with Pascal (say), you would just insert procedure calls with arguments into your top level algorithm and then go back and implement them afterwards. You don't actually want to manually have to go create each stub as you do this, it's a distraction from thinking about the algorithm.

Similarly, having to create the inlets/outlets manually each time is a distraction and automating this would go a long way towards allowing easier top-down development.

I think the combination of these two features would make it much easier to developer larger scale applications in Max.

For what it's worth, I had these features in an iconic programming language I developed a long time (early 90s) and found them to be very effective.

I think @pid is correct that this has to be done outside of the scripting mechanism. Ideally, you want to be able to just select an object and then press a key sequence that just inserts the precise number of needed inlets and outlets for that object into the patcher.

I suspect the Max Toolkit could be modified to do this but I don't yet have enough knowledge of Max infrastructure to attempt it myself.

Not quite sure it is what you had in mind but here's a little example of automatically scripting [inlet]s and [outlet]s into place for selected objects. Highlight some objects and press a numeric key to automatically create and connect: 1 for just [inlet]s, 2 for [outlet]s and 3 for both. Inside max javascript has no knowledge of how many inlets and outlets objects have so this code defaults to just the first inlet and/or outlet.

I'm working on a way to get the information about the number of inlets and outlets each selected object has and checking to see if they are already connected to another object. Let me know if you think this would be useful because I am easily fascinated and shelve loads of projects because I find something new to work on, maybe if other people give me a push I'll actually get something completed for once. Any feedback at all would be great!

//autoio1.js

var selobj = [];
var io = "inlet";
var offset;
var flag = 1;

function genin() {
io = "inlet";
offset = -27;
bang();
}

function genout() {
io = "outlet";
offset = 2;
bang();
}

function genio() {
genin();
flag = 0;
genout();
flag = 1;
}

function bang() {
if (flag) {
selobj = [];
}
this.patcher.apply(iter);
for (i=0; i
x = selobj[i].rect[0];
y = (selobj[i].rect[1]*(offset0))+offset;
var auto = this.patcher.newdefault(x, y, io);
if (offset > 0) {
this.patcher.connect(selobj[i],0,auto,0);
} else {
this.patcher.connect(auto,0,selobj[i],0);
}
}
}

function iter(obj) {
if (obj.selected) {
selobj.push(obj);
}
return true;
}
// EOF

I just tried this --- this is essentially exactly what I'm looking for.

Obviously it needs to create an inlet/outlet for all ports, not just the first one.

It would also be convenient if the created inlet/outlet contained the same comment as the original port of the object.

I really appreciate your trying to make this work, I think a lot of people could benefit from this particular feature.