The XML community may want to look at prototype-based object-oriented
programming as an alternative to traditional class-instance objects.
Prototypes allow the designer/user to create an object, change its
properties, and then create new objects that inherit from the original
prototype. There's a lot more details, including a description of
inheritance by delegation of methods/properties to parent prototypes,
but it tends to be a more useful approach for objects that model real
world objects -- my dissertation used a variant of prototypes to
implement an object-oriented approach to simulation for chemical
thermodynamics.
Another useful approach might be to look into constraint-based OO. In
this approach, the relationships between objects can be described and
manipulated, usually in both directions (i.e. if x.width + y.width =
total.width, setting the total.width and x.width to new values will
force a change in y.width as well).
Finally, I was impressed with, but lost the references to, some work
on "middle-out" modeling. Basically, traditional classes are used to
go from general classes (animals, mammals) to specific classes (dogs,
beagles), and then the system permits class properties to be replaced
to allow for Ralph, a beagle with three legs, etc. A similar
middle-out approach might be useful -- define a hierarchy of DTDs, I
suppose, and then permit specific exceptions to override default
properties.
Here are the references for folks with extra time, if I'm not too
off-topic.
The classic prototype-based OO language developed at Sun:
A prototype-based, C++, constraint-based user interface system:
http://www.cs.cmu.edu/Groups/amulet/amulet-home.html
A bunch of variants on constraint-based languages and systems,
including Web layout:
(The hierarchy of constraints is especially useful for systems with
defaults and different constraint strengths)
http://www.cs.washington.edu/research/constraints/
Ken Meltsner