Hi everyone,

recently there have been a few really great patches posted here that use data structures for making gui objects (menus, sliders, xy pads etc). I've been using pd for a few years but I've always ignored data structures, it seemed too difficult a concept to get my head around and I never really thought I needed to learn that side of patching anyway, but now I'd like to start learning how to make (and adapt) some gui objects like slider banks, drawable envelopes and so on.

Does anyone have any suggestions at all on how to get started? Some tutorials that there might be which are useful for learning this kind of stuff? (videos would be even better).
I've looked at some existing data structure-based objects posted here but they make no sense to me at all, and the tutorials in the help browser are also a bit hard to understand (maybe because I have zero programming experience except pd), although I haven't looked at them in depth yet.

Thanks very much for your help.

@weightless struct.zip
I might have re-saved something that I should not have, but I cannot remember where it came from so........ it's as clean and unused as I can make it.....
Enjoy!
David.

@whale-av Thanks! I'll get into it and report back if I need any help.

@weightless The tutorials in doc/4.data.structures are a good place to start.

The visual and event handling part of using [drawcurve/drawpolygon/filledpolygon/filledcurve] objects is quite restrictive and idiosyncratic-- so much so that I created the [draw] class in Purr Data specifically to avoid them.

I've seen some tutorials out there for [drawcurve] and friends, but I don't have the links. But keep in mind that most people on here are creating things with them because of the challenge of using such a poor interface (poor in terms of documentation, expressivity, performance, consistency.. pretty much everything).

@jancsika I didn't realise that most people used data structures as a challenge, but from the outside it seemed like a neat way to do stuff like click and drag envelopes, sliders etc, which I wouldn't know how to achieve otherwise. Do you know of any other (simpler) way to design such things? Or externals? Thanks.

@weightless Clicking an area of the scalar that holds the envelope is pretty simple, because the [struct] sends a "click" message by default when you click an area.

Dragging a pre-defined node is trickier-- rather than defining the size of a node as a square or rectangle in relative/absolute coordinates, you must use quantization syntax node(min1:max1)(min2:max2) where one set of values are the screen coordinates and the other are unitless (or arbitrary) floating point values supplied to the field "node" from within Pd. (I can't remember which is which atm.) I don't know any other 2d interface that requires the user to supply coordinates in such a form.

Also, the entire node as drawn this way is not able to be clicked and dragged. Pd has some hard-coded "hotspot" values (either within 5 or 10 pixels of the scalar's field used to define the coordinate), and only those spots on the polygon are click-draggable. For example, even if you got through the complication with that quantization syntax and managed to draw a 50x50 pixel square, you can only drag it when the mouse is withing 5-10 pixels of one of the corners. To create a runtime-draggable 50x50 square you'd have to create a more complex polygon zig-zagging through the shape of a square with points spaced only 5-10 pixels apart.

Additionally, the "click" message doesn't return the x/y coordinate of the area that was clicked. So doing something as simple as "jump-on-click" for your slider will be a feat of astounding Pd hackery, either using the trick I outlined above or possibly another crazy hack.

Also I think z-order among different scalars is inconsistent.

Also, scalars inside GOPs... well, I'll stop for now.

my starting point was that i wanted a multislider in pure data. i was already thinking about learning another programming language like processing or open frameworks to have better interface possibilities. https://github.com/Ant1r/ofxPof or https://forum.pdpatchrepo.info/topic/6666/make-protodrom-pd-and-processing-with-libpd-controlp5-and-oscp5 for example. instead i started to discover data structures for now. i think they are limited but still it is possible to expand the pd gui a little bit and to make some useful objects. and i like the idea from miller puckette to use data structures for visual scores, but i havent seen a lot of them. i would be happy if he expands the data structure possibilities and makes them more handy

here i found a paper about data structures: http://lac.zkm.de/2006/papers/lac2006_frank_barknecht.pdf

@Jona One of the reasons I added [draw] in Purr Data was so that people can build decent interfaces without having to learn another programming language/environment.

I get the sense that this is the same reason why Pd users are willing to hack their way to a minimally workable interface using data structures or more often iemguis. Even with the complexity and spaghetti code, it is still far less work than learning and prototyping in a completely separate environment.

@jancsika Thanks for your answer, although your explanation is way over my head as I don't yet know how data structures work. I do get it though that they are limited, but I agree that it makes sense to try and build stuff inside pd rather than interfacing with other environments (which I would have to learn from scratch anyway). I'm not trying to do high quality graphics or anything, actually for now a multi-stage envelope gui would be enough so I think it's worth to at least trying and explore what pd already has to offer. I'll look into [draw] as well, thanks for the heads up.

@Jona Thanks for linking the paper, seems to complement @whale-av's tutorials quite nicely.

chapter 5.2.3.1 is about data structures: http://www.pd-tutorial.com/english/ch05s02.html#id438648
here is another documentation: http://msp.ucsd.edu/Pd_documentation/x2.htm#s9

I'm trying to get my head around this stuff and I have a question: in the attached patch there are 5 squares plotted from a template, each with a "number" field which I can retrive by clicking on them. I realise I can retrive all the values for all squares with [get], and change them with [set], but can I get/ or set a different number for only one specific square instance? In other words, can I know which pointer is associated with which square?

Thanks very much in advance.

pointers.pd

@weightless s-controlsurface.pd from that patch i learned a lot. each square gets an id (counting from 1) while creating. take a look into the pd $0template subpatch. ps.: i have to check if its possible to get the id while clicking, never used that by myself.

@weightless yes, there are two methods i know of. To get the value of the second scalar, you can use next two times and than put this pointer into get.

Or you can store the pointers in a list and access the pointers from here. The pointer to the scalar is output by the append on creation.

Both methods are shown here: pointers.pd

@Jona You get the pointer by clicking. To get the id it would have to be stored in the scalar and can than be read with the pointer.

@Jona Thanks for the patch, very helpful. But I suppose there is no way to address a scalar with the id, just the the pointer right?

@ingox Thanks for the patch, very interesting idea to save a list of pointers. One question: when you send [traverse, bang( to append, every new scalar is then added at the beginning of the list, as it were, is that right? I'm wondering if that's the reason why you used list prepend. It looks like the last element created with append is the first in the list. I hope you understand what I mean.

@weightless i never really questioned the whole traverse-bang-construct.

What i make of it is that you first set the pointer to the beginning of the subpatch and than append each scalar one after another. i just assume that the append takes care of that.

list prepend means that the previous list is put before the incoming element, so the last incoming element is the last in the list.

If you rightclick on a polygon in the subpatch and select properties, you can see the actual data structure. That is the actual data that is structured according to the template and is than visualized by draw object. Unfortunately it seems not possible to see the complete content of the subpatch in that way. But you can save the patch and look at the source code of the patch to see the exact order in which the scalars are placed in the subpatch.

@ingox Thanks, yes I got it wrong about the list prepend. The first element created with append can be addressed with 0 in the list, the second with 1 and so on, all as expected.

Thanks for the info, I'm trying to get the values saved in a specific field of each object, do stuff to them, and send them back to the data structure but I need to know which value is associated with each object. I think it's a good way to create an index of pointers based on the order of creation. It would be just so much nicer to be able to actually see the pointer itself.

With nested structs, that is data structures that contain arrays, you can actually see the full data. In the help file of [plot], if you rightclick on the purple square and select properties you can see the actual data that is written to the subpatch in a structured way that is defined by the template (struct object). This data is visualised in different ways by the draw instructions (drawcurve etc.). Don't know if that helps...

@weightless The pointer is just an address, but yes, it would be nice to have that in plaintext and be able to modify it.