This tutorial looks at a useful object for embedding subpatchers within a patcher so that their interface is visible. The bpatcher
object is superficially similar to making any abstraction: we create a patcher file (with inlets and outlets, as necessary) and save it to disk. Rather than instantiating it with an object box, however, we use the bpatcher
object to 'embed' it visibly inside another patcher. This allows us to construct a library of interface elements - pieces of patcher logic that show an interface that we can re-use multiple times.
Take a look at the tutorial patcher. The reasonably sparse window contains a toggle
labeled "Start", three button
objects ("draw", "see", and "clear"), and three identical-looking interface areas.
Click on the toggle
labeled "Start". Move the mouse over to the left-hand interface area and draw in the blue rectangle that contains the small yellow ball. This is a jsui
object loaded with a two-dimensional user-interface that simulates a two-axis slider of sorts that will track our mouse when clicked. As you "draw" by dragged in the jsui
, the gesture
of your drawing will be traced in red in the lcd
object below. The lcd
object has its turned off, so you won't see anything until you draw something in the jsui
. If you clear the lcd
(with the "erase" button
) you should see your gesture draw again.
Go to the second and third jsui
objects and "draw" in them with the mouse. Notice that they generate tracings in the lcd
object in green and blue, respectively. Hit the "erase" button
to the lcd
and see them redraw.
Turn up the slider
objects next to the jsui
objects and you will see that the tracings become slightly "noisy" - the "gestures" recorded from the jsui
are now being randomized a bit to add more texture to the drawing. Click any of the button
objects labeled "clear" to erase the captured gesture. You can then redraw a new gesture in the appropriate jsui
With some gestures "loaded", click on the button
labeled "see" at the top of the patcher. Notice that the three interface areas suddenly look different - a new set of jsui
objects appear that "trace" the gestures as you entered them. Where did the original jsui
, and "clear" button
for each interface go?
Unlock the tutorial patcher. Notice that a number of "hidden" objects appear; moreover, light blue boxes appear around the three interface areas. The blue boxed areas are in fact bpatcher
objects containing an abstraction patcher saved on disk. These patcher files have parts of their interface shown inside the main tutorial patch.
Click on any of the three interface areas and notice that, rather than being able to edit the objects within, you can merely move and resize the blue box area. This is because, as we mentioned, the patcher logic inside that area is saved in a separate file. Control-click (Mac) or right-click (Windows) on one of the blue boxes to get its contextual menu. From the menu, go down to the Object submenu and select "Open Original doodlepatch.maxpat". The master copy of the three interface areas will open. Let's take a look at that patcher.
Unlock the "doodlepatch.maxpat" abstraction. Notice that all we see is the interface elements of the patcher, regardless of whether the patcher is unlocked. This is because the patcher is in Presentation Mode - we can set any patcher to open in Presentation Mode by checking "Open In Presentation" in the Patcher Inspector. From the View menu, uncheck Presentation and the patcher will morph back to its original view and a bunch of patcher logic will appear.
Take a look at the code in the patcher. It uses a coll
object as well as some supporting logic to take the drawing data from the jsui
object and record it (this is a form of "gesture capture", as seen in a previous tutorial). The second jsui
(to the right) immediately reanimates the data from the coll
based on messages coming in from the inlet
and driving a counter
Without closing the "doodlepatch.maxpat" file, switch back to the tutorial patcher and look at the "draw" and "see" button
objects when the patcher is unlocked. Notice that they trigger message
boxes containing the messages and , respectively, sent into the second inlet of the bpatcher
Look in the bpatcher patch and see what the second inlet is connected to. Notice that it talks to a thispatcher
object. The thispatcher
object provides functionality for controlling the appearance of a patcher file, including its size, position on the screen, and whether the title bar is visible or not. When used within a bpatcher
file, the thispatcher
object can "scroll" the interface of the bpatcher
object based on coordinates provided with the message. This allows our master tutorial patcher to "switch" between two different viewpoints on the same bpatcher
file - in this case, the "draw" view and the "see view".
Look a the patcher logic attached to the outlet of the bpatcher
file. There is an append
object with three pound-sign
abstraction arguments ( ). These arguments would normally be provided in the object box if we were to load "doodlepatch.maxpat" as a normal abstraction in our patcher. In order to set these arguments within a bpatcher
object, we have to use the object's Inspector
Close the bpatcher
abstraction file and go back to the tutorial patcher. Click on one of the bpatcher
objects and open its Inspector
. Notice that at the bottom we can find the name of the loaded by the object. Directly under this is the field, which contains three numbers. These numbers are substituted for the patcher arguments for each bpatcher
independently, allowing us to differentiate multiple copies of them in our patch.
The arguments for our bpatcher
in this tutorial control the three colors drawn by the gesture capture system in the lcd
(in short, they provide the last three numbers for the commands sent to the lcd
). Open the Inspector
for each bpatcher
and change those values to a different color value in RGB form ( - ). When you record new gestures, you will see them appear in the lcd
using the colors you selected.
object provides an extremely useful way to embed visual interfaces within a larger project. An interface can be designed (with whatever supporting logic is required), saved, and displayed in another patch. The message to a thispatcher
object within a bpatcher
allows us to "scroll" the viewing rectangle of the object to reveal different portions of the interface. This, combined with the use of Presentation Mode, allows us to customize the interface further. Just as with other types of abstractions, patchers made for use with the bpatcher
object can process arguments, set through the object's Inspector.
Embed a visible subpatch inside a box
Send messages to a patcher