Try this out: there's a lot more features that need to be added, and
bugs to fix, but the basic stuff is there. I don't know how it works
in color. It depends somewhat on being retained right now. Try it in
monochrome if in doubt.

Instructions (per say):

psh dataitem.ps

Goal: I don't want to ever have to type directly at a psh again.
Prognosis: Not there yet, but further than before!

The window starts up with one turd on the screen, showing a type label
and one object (a dict).  Click the left button on an object in a turd
to select it (Primary).  Double click left a composite object to open
it.  Double click left an opened composite object to close it.  If you
click left on the turd tab, it toggles it into its iconic state.  The
middle button drags turds around.  The right button gets a menu. If
you're over an object, the menu is of things to do to the object. If
you're in turd tab, the menu is of things to do to the view of the
turd. Right now, you can change the turd font size, the label tab
placement, the shrink factor, and dump out a PostScript file in DL.ps.
The object menu lets you paste the primary selection (replacing the
object), load the object, looking it up on the item's dict stack
(making a new turd), clone the object (making a new turd), or execute
the object (possible making new turd if there are return values).
There's also a menu on the background to reformat all the turds (not
too interesting.) Some of the turds may be pushed onto the stack
before executing an object.  To specify the stack, press down on a
turd with the left button, and drag outside of the turd (there will be
a rubber band).  If you release the button inside another turd, you
select that turd as the top of stack, and the ones before it are
underneath in the order that they were selected.  The top of stack is
highlighted with a border. If you drag out of a turd and release on
the background, that turd is selected as the top of the stack. Once
you have a selected some turds to be on the stack, and then execute
some object, any new or different things that are left on the stack
after the execution are plopped down onto the screen. What's fun is to
make "buttons" by pasting strings of PostScript code into turds, and
executing them.  i.e. try the following: select a number in a psterm
window (i.e.  you've selected a string), paste it into a turd (which
will then be a stringtype), and execute the turd. That will result in
the plopping down of an integertype, that number. Make a few numbers
this way. (It will be a lot easier once I hack the TextItem to work
with this!!)  Then paste the string "add" into a turd. Select a stack
of a couple numbers, by pressing on one number turd, and dragging out
and into another, and releasing. Then point at the turd with the
string "add", and choose the "exec" menu item. The sum will plop down
(you'll have to place it somewhere.) Use your imagination! This REALLY
needs editable text items that are evaluated when you hit return, and
sliders that return numeric values. I want the text items to serve as
the focus for a process, and manage the location of other turds,
lining all their labels up in a pile. Typing something at a process's
text item and hitting return evaluates it and pushes it on the stack
(or whatever). Function keys and control characters should be able to
be bound to your favorite functions. I want to be able to push
something onto a stack by dragging it on top, and have it snap into
place, and rearrange items on the stack the way the NeXT interface
builder menu item dragging works.  Please tell me everything else you
think it needs!!!

Oh yeah, accellerators: Shift double-click left will open up
everything underneath an object one level deeper. Meta double-click
left will open up an object without reformatting (in case you want to
open up a lot of stuff, without waiting between each time, just
meta-open all but the last.)  Shift-Meta double-click works too.

I also need a way to add new keys to dictionaries, and sort the keys.
Arrays are upside down (but so is my brain so I don't notice). I'd
like scroll bars on arrays and dict's that are unreasonably big, too.

I want to add real debugging support. (You should be able to do
everything the debugger can do, and much more.)

You can see how this will fit in Josh's structure=>string converter. I
just haven't had the time to hack it in yet. Been working on the
meat&potatoes functionality first. I'll put it in once I get a good
string edit item integrated into the thing. Then it will be
hellatiously useful. Also I want to be able to write out a structure
to emacs, edit it there, and read it back in. All through the
selection service. I want to enhance the write-out function so it
writes out processes, canvases, etc, as opaque objects that can be
printed out, in the form //&process_1, //&canvas_2, etc, and defines
those keywords in a dictionary that's on the dict stack at the time
they're eventually read back in. The //foo will be replaced by the
value foo is bound to when it's scanned.

A dictionary could be written out as:

20 dict begin
  /foo 123 def
  /bar {this is fun} def
  /baz //process32 def
  /can //canvas33 def
  /func {//dict34 begin yow end} def
  /ParentDict //dict35 def
  /ParentDictArray [//dict35 //dict7] def
currentdict end

	-Don