Any canvas object can have any number of annotations associated with it. Each annotation is some text that should be displayed on the canvas as well as possible, and the text should be connected with the canvas object somehow, perhaps with a line if necessary.
The text has levels of detail in the form of multiple font sizes and abbreviations, which are shorter forms of the text that may be provided. For example, an annotation text might be "Water splashing 2s15f 4/16/2002 2:15pm" but its abbreviations might be "Water splashing 2s15f", "Water splashing", and "Water..". The canvas will select an appropriate version of the text as space permits. The canvas will have min and max allowable font sizes that the application should let the user choose. If there is not enough room to draw an annotation, the canvas may decide to leave it out.
When many annotations are competing for space, a priority system helps the canvas decide how much space to give each anno. Annos with equal priority values should always draw at the same LOD (or at least the same font size) even if there's extra room for some of them. Prios can change any time, and the application might even make a mouseover event temporarily raise the prio of an anno, so the user can wave over a highly-detailed area and still read all the annos.
The priority system gets more complicated: the anno priorities are supplemented by object priorities ("user wants to see full detail on all annos for this object on all canvases"), canvas-wide priorities ("make this canvas have less junk all over it"), and even regional priorities ("this rectangle is also being viewed in a separate canvas, so all objects within it don't need their annos drawn").
The canvas draws arrows from text to objects as necessary. It might look good to put transparent colored panels behind blocks of text that are very close together. How does canvas know where to draw the arrow? When you're attaching an anno to an object, you might hint that the arrow can point anywhere on the object; that it should point at the center; that it should point to a particular coordinate in object space; etc.
Anno can be constrained to fit within a shape. "light9's":http://light9.bigasterisk.com leveldisplay widget had channel names in a compact table. I wanted the names to flip from short to long versions as I made the table bigger and smaller. With the annotating canvas, I might make the table cells canvas rectangles that have to be "internally annotated". Then the annocan would make the right LOD decision as I change the window size.
The anno layout algorithm is wide open, of course, and it may improve slowly over a long time. Among the goals should be smooth updates (text doesn't jump very far between updates) and animated updates (the update happens over a few steps which are each displayed so the user can see the text slide around).
Can an annotation contain more than just text? Sounds nice. At least, the text should have full font/style/color control per-character so I can include a big symbol from a symbol font where appropriate. Annos are always wrappable entities that can be "poured" into various spaces. Well-- I'd like the canvas to help me place arbitrary objects too. I might want a roto app that can display little versions of the keyframe timings next to each point (space permitting). The anno layout engine knows how to search for space. But how would it tell my keyframe timing widget (a subcanvas) how big to be, etc?
The anno layout engine can take hints about what's okay to draw over and what isn't. It's never ok to put one anno over another, but it might be okay to put annos over a line object (or "over up to 60% of the line object" or something). Other objects might block annos completely. Each object has an "ok to cover" flag, maybe.