Changeset 1022

Timestamp:

11/30/11 17:32:55 (18 months ago)

Author:

tal

Message:

Massive rewrite of the parenting system. getParent is now deprecated (though it won't issue warnings). Each object has a tree of parent objects (currently) retrieved dynamically by using only one weakref to the object that directly owns the sub-object.

Additionally, and the reason the above changes were made, objects now have a built in self-observation system. These self-observations are removed from the dispatcher whenever the object goes away. This should hopefully resolve a real/theoretical problem of the dispatcher overflowing with dead objects.

This is all a bit slow. Speed is the next step.

Location:

packages/defcon/branches/ufo3

Files:

• Lib/defcon/objects/anchor.py (modified) (7 diffs)
• Lib/defcon/objects/base.py (modified) (4 diffs)
• Lib/defcon/objects/component.py (modified) (6 diffs)
• Lib/defcon/objects/contour.py (modified) (7 diffs)
• Lib/defcon/objects/dataSet.py (modified) (4 diffs)
• Lib/defcon/objects/features.py (modified) (3 diffs)
• Lib/defcon/objects/font.py (modified) (14 diffs)
• Lib/defcon/objects/glyph.py (modified) (17 diffs)
• Lib/defcon/objects/groups.py (modified) (2 diffs)
• Lib/defcon/objects/guideline.py (modified) (13 diffs)
• Lib/defcon/objects/image.py (modified) (9 diffs)
• Lib/defcon/objects/imageSet.py (modified) (6 diffs)
• Lib/defcon/objects/info.py (modified) (7 diffs)
• Lib/defcon/objects/kerning.py (modified) (2 diffs)
• Lib/defcon/objects/layer.py (modified) (23 diffs)
• Lib/defcon/objects/layerSet.py (modified) (12 diffs)
• Lib/defcon/objects/lib.py (modified) (3 diffs)
• Lib/defcon/objects/uniData.py (modified) (3 diffs)
• Lib/defcon/pens/glyphObjectPointPen.py (modified) (2 diffs)
• Lib/defcon/test/testAll.py (modified) (2 diffs)
• tools/infoObjectGenerator.py (modified) (7 diffs)

packages/defcon/branches/ufo3/Lib/defcon/objects/anchor.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseDictObject
 from defcon.objects.color import Color
@@ -29 +30 @@
     representationFactories = {}
 
-    def __init__(self, anchorDict=None):
+    def __init__(self, glyph=None, anchorDict=None):
+        self._glyph = None
+        self.glyph = glyph
         super(Anchor, self).__init__()
+        self.beginSelfNotificationObservation()
         self._dirty = False
         if anchorDict is not None:
@@ -41 +45 @@
     # parents
 
+    def getParent(self):
+        return self.glyph
+
     def _get_font(self):
         glyph = self.glyph
@@ -66 +73 @@
 
     def _get_glyph(self):
-        return self.getParent()
-
-    glyph = property(_get_glyph, doc="The :class:`Glyph` that this anchor belongs to.")
+        if self._glyph is None:
+            return None
+        return self._glyph()
+
+    def _set_glyph(self, glyph):
+        assert self._glyph is None
+        if glyph is not None:
+            glyph = weakref.ref(glyph)
+        self._glyph = glyph
+
+    glyph = property(_get_glyph, _set_glyph, doc="The :class:`Glyph` that this anchor belongs to. This should not be set externally.")
 
     # coordinates
@@ -171 +186 @@
         self.identifier = identifier
 
-    # -------
-    # Methods
-    # -------
+    # ----
+    # Move
+    # ----
 
     def move(self, (x, y)):
@@ -183 +198 @@
         self.x += x
         self.y += y
+
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Anchor, self).endSelfNotificationObservation()
+        self._glyph = None
 
 
@@ -229 +252 @@
     False
 
-    >>> a = Anchor(dict(x=1, y=2, name="3", identifier="4", color="1,1,1,1"))
+    >>> a = Anchor(anchorDict=dict(x=1, y=2, name="3", identifier="4", color="1,1,1,1"))
     >>> a.x, a.y, a.name, a.identifier, a.color
     (1, 2, '3', '4', '1,1,1,1')

packages/defcon/branches/ufo3/Lib/defcon/objects/base.py

@@ -39 +39 @@
 
     def _init(self):
-        self._parent = None
         self._dispatcher = None
         self._dataOnDisk = None
@@ -45 +44 @@
         self._representations = {}
 
+    def __del__(self):
+        self.endSelfNotificationObservation()
+
     # ------
     # Parent
     # ------
 
-    def setParent(self, obj):
-        """
-        Set the parent of the object. This will reference the parent using weakref.
-        """
-        if obj is None:
-            self._parent = None
-        else:
-            self._parent = weakref.ref(obj)
-
     def getParent(self):
-        """
-        Get the parent. Returns None if no parent is set.
-        Note that because the reference to the parent is stored
-        as a weakref, the parent can disappear if it is no longer
-        referenced by any object other than this one.
-        """
-        if self._parent is not None:
-            return self._parent()
-        return None
+        raise NotImplementedError
 
     # -------------
@@ -74 +59 @@
 
     def _get_dispatcher(self):
-        parent = self.getParent()
-        if parent is None:
+        if not hasattr(self, "font"):
+            return
+        font = self.font
+        if font is None:
             return None
-        return parent.dispatcher
+        return font.dispatcher
 
     dispatcher = property(_get_dispatcher, doc="The :class:`defcon.tools.notifications.NotificationCenter` assigned to the parent of this object.")
@@ -214 +201 @@
         if dispatcher is not None:
             dispatcher.postNotification(notification=notification, observable=self, data=data)
+
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def beginSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        self.addObserver(self, "selfNotificationCallback", notification=None)
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        self.removeObserver(self, notification=None)
+
+    def selfNotificationCallback(self, notification):
+        pass
 
     # ---------------

packages/defcon/branches/ufo3/Lib/defcon/objects/component.py

@@ -27 +27 @@
     representationFactories = {}
 
-    def __init__(self):
+    def __init__(self, glyph=None):
+        self._glyph = None
+        self.glyph = glyph
         super(Component, self).__init__()
+        self.beginSelfNotificationObservation()
         self._dirty = False
         self._baseGlyph = None
@@ -40 +43 @@
     # parents
 
+    def getParent(self):
+        return self.glyph
+
     def _get_font(self):
         glyph = self.glyph
@@ -65 +71 @@
 
     def _get_glyph(self):
-        return self.getParent()
-
-    glyph = property(_get_glyph, doc="The :class:`Glyph` that this component belongs to.")
+        if self._glyph is None:
+            return None
+        return self._glyph()
+
+    def _set_glyph(self, glyph):
+        assert self._glyph is None
+        if glyph is not None:
+            glyph = weakref.ref(glyph)
+        self._glyph = glyph
+
+    glyph = property(_get_glyph, _set_glyph, doc="The :class:`Glyph` that this component belongs to. This should not be set externally.")
 
     # bounds
@@ -151 +165 @@
             warn("The addComponent method needs an identifier kwarg. The component's identifier value has been discarded.", DeprecationWarning)
 
-    # -------
-    # Methods
-    # -------
+    # ----
+    # Move
+    # ----
 
     def move(self, (x, y)):
@@ -165 +179 @@
         yOffset += y
         self.transformation = (xScale, xyScale, yxScale, yScale, xOffset, yOffset)
+
+    # ------------
+    # Point Inside
+    # ------------
 
     def pointInside(self, (x, y), evenOdd=False):
@@ -228 +246 @@
         self.identifier = identifier
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Component, self).endSelfNotificationObservation()
+        self._glyph = None
+
 
 def _testIdentifier():

packages/defcon/branches/ufo3/Lib/defcon/objects/contour.py

@@ -42 +42 @@
     representationFactories = {}
 
-    def __init__(self, pointClass=None):
+    def __init__(self, glyph=None, pointClass=None):
+        self._glyph = None
+        self.glyph = glyph
         super(Contour, self).__init__()
+        self.beginSelfNotificationObservation()
         self._points = []
         self._boundsCache = None
@@ -58 +61 @@
         self._controlPointBoundsCache = None
 
-    # ----------
-    # Attributes
-    # ----------
-
-    # parents
+    def __del__(self):
+        super(Contour, self).__del__()
+        self._points = None
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.glyph
 
     def _get_font(self):
@@ -89 +97 @@
 
     def _get_glyph(self):
-        return self.getParent()
-
-    glyph = property(_get_glyph, doc="The :class:`Glyph` that this contour belongs to.")
+        if self._glyph is None:
+            return None
+        return self._glyph()
+
+    def _set_glyph(self, glyph):
+        assert self._glyph is None
+        if glyph is not None:
+            glyph = weakref.ref(glyph)
+        self._glyph = glyph
+
+    glyph = property(_get_glyph, _set_glyph, doc="The :class:`Glyph` that this contour belongs to. This should not be set externally.")
+
+    # ------
+    # Points
+    # ------
 
     def _get_pointClass(self):
@@ -98 +118 @@
     pointClass = property(_get_pointClass, doc="The class used for point.")
 
-    def _get_bounds(self):
-        from robofab.pens.boundsPen import BoundsPen
-        if self._boundsCache is None:
-            pen = BoundsPen(None)
-            self.draw(pen)
-            self._boundsCache = pen.bounds
-        return self._boundsCache
-
-    bounds = property(_get_bounds, doc="The bounds of the contour's outline expressed as a tuple of form (xMin, yMin, xMax, yMax).")
-
-    def _get_controlPointBounds(self):
-        from fontTools.pens.boundsPen import ControlBoundsPen
-        if self._controlPointBoundsCache is None:
-            pen = ControlBoundsPen(None)
-            self.draw(pen)
-            self._controlPointBoundsCache = pen.bounds
-        return self._controlPointBoundsCache
-
-    controlPointBounds = property(_get_controlPointBounds, doc="The control bounds of all points in the contour. This only measures the point positions, it does not measure curves. So, curves without points at the extrema will not be properly measured.")
-
-    def _get_clockwise(self):
-        from defcon.pens.clockwiseTestPointPen import ClockwiseTestPointPen
-        if self._clockwiseCache is None:
-            pen = ClockwiseTestPointPen()
-            self.drawPoints(pen)
-            self._clockwiseCache = pen.getIsClockwise()
-        return self._clockwiseCache
-
-    def _set_clockwise(self, value):
-        if self.clockwise != value:
-            self.reverse()
-            self._clockwiseCache = None
-
-    clockwise = property(_get_clockwise, _set_clockwise, doc="A boolean representing if the contour has a clockwise direction. Setting this posts *Contour.WindingDirectionChanged* and *Contour.Changed* notifications.")
-
-    def _get_open(self):
-        if not self._points:
-            return True
-        return self._points[0].segmentType == 'move'
-
-    open = property(_get_open, doc="A boolean indicating if the contour is open or not.")
-
     def _get_onCurvePoints(self):
         return [point for point in self._points if point.segmentType]
 
     onCurvePoints = property(_get_onCurvePoints, doc="A list of all on curve points in the contour.")
+
+    def appendPoint(self, point):
+        """
+        Append **point** to the glyph. The point must be a defcon
+        :class:`Point` object or a subclass of that object. An error
+        will be raised if the point's identifier conflicts with any of
+        the identifiers within the glyph.
+
+        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
+        """
+        assert point not in self._points
+        self.insertPoint(len(self._points), point)
+
+    def insertPoint(self, index, point):
+        """
+        Insert **point** into the contour at index. The point
+        must be a defcon :class:`Point` object or a subclass
+        of that object. An error will be raised if the points's
+        identifier conflicts with any of the identifiers within
+        the glyph.
+
+        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
+        """
+        assert point not in self._points
+        if point.identifier is not None:
+            identifiers = self.identifiers
+            assert point.identifier not in identifiers
+            if point.identifier is not None:
+                identifiers.add(point.identifier)
+        self._points.insert(index, point)
+        self._destroyBoundsCache()
+        self._clockwiseCache = None
+        self.postNotification("Contour.PointsChanged")
+        self.dirty = True
+
+    def setStartPoint(self, index):
+        """
+        Set the point at **index** as the first point in the contour.
+        This point must be an on-curve point.
+
+        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
+        """
+        onCurvePoints = self.onCurvePoints
+        if len(onCurvePoints) < 2:
+            return
+        if self.open:
+            return
+        point = self._points[index]
+        assert point.segmentType is not None, "index must represent an on curve point"
+        before = self._points[:index]
+        self._points = self._points[index:] + before
+        self.postNotification("Contour.PointsChanged")
+        self.dirty = True
+
+    # -------------
+    # List Behavior
+    # -------------
+
+    def __len__(self):
+        return len(self._points)
+
+    def __getitem__(self, index):
+        if index > len(self._points):
+            raise IndexError
+        return self._points[index]
+
+    def __iter__(self):
+        pointCount = len(self)
+        index = 0
+        while index < pointCount:
+            point = self[index]
+            yield point
+            index += 1
+
+    def clear(self):
+        """
+        Clear the contents of the contour.
+
+        This posts *Contour.PointsChanged* and *Contour.Changed* notifications.
+        """
+        self._clear()
+
+    def _clear(self, postNotification=True):
+        # clear the internal storage
+        self._points = []
+        # reset the clockwise cache
+        self._clockwiseCache = None
+        # post a dirty notification
+        if postNotification:
+            self.postNotification("Contour.PointsChanged")
+            self.dirty = True
+
+    def index(self, point):
+        """
+        Get the index for **point**.
+        """
+        return self._points.index(point)
+
+    def reverse(self):
+        """
+        Reverse the direction of the contour. It's important to note
+        that the actual points stored in this object will be completely
+        repalced by new points.
+
+        This will post *Contour.WindingDirectionChanged*,
+        *Contour.PointsChanged* and *Contour.Changed* notifications.
+        """
+        from robofab.pens.reverseContourPointPen import ReverseContourPointPen
+        oldDirection = self.clockwise
+        # put the current points in another contour
+        otherContour = self.__class__(glyph=None, pointClass=self.pointClass)
+        # draw the points in this contour through
+        # the reversing pen.
+        reversePen = ReverseContourPointPen(otherContour)
+        self.drawPoints(reversePen)
+        # clear the points in this contour
+        self._clear(postNotification=False)
+        # draw the points back into this contour
+        self.disableNotifications()
+        otherContour.drawPoints(self)
+        self.enableNotifications()
+        # post a notification
+        self.postNotification("Contour.WindingDirectionChanged", data=dict(oldValue=oldDirection, newValue=self.clockwise))
+        self.postNotification("Contour.PointsChanged")
+        self.dirty = True
+
+    # --------
+    # Segments
+    # --------
 
     def _get_segments(self):
@@ -169 +276 @@
 
     segments = property(_get_segments, doc="A list of all points in the contour organized into segments.")
-
-    # -------
-    # Methods
-    # -------
-
-    def __len__(self):
-        return len(self._points)
-
-    def __getitem__(self, index):
-        if index > len(self._points):
-            raise IndexError
-        return self._points[index]
-
-    def __iter__(self):
-        pointCount = len(self)
-        index = 0
-        while index < pointCount:
-            point = self[index]
-            yield point
-            index += 1
-
-    def clear(self):
-        """
-        Clear the contents of the contour.
-
-        This posts *Contour.PointsChanged* and *Contour.Changed* notifications.
-        """
-        self._clear()
-
-    def _clear(self, postNotification=True):
-        # clear the internal storage
-        self._points = []
-        # reset the clockwise cache
-        self._clockwiseCache = None
-        # post a dirty notification
-        if postNotification:
-            self.postNotification("Contour.PointsChanged")
-            self.dirty = True
-
-    def appendPoint(self, point):
-        """
-        Append **point** to the glyph. The point must be a defcon
-        :class:`Point` object or a subclass of that object. An error
-        will be raised if the point's identifier conflicts with any of
-        the identifiers within the glyph.
-
-        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
-        """
-        assert point not in self._points
-        self.insertPoint(len(self._points), point)
-
-    def insertPoint(self, index, point):
-        """
-        Insert **point** into the contour at index. The point
-        must be a defcon :class:`Point` object or a subclass
-        of that object. An error will be raised if the points's
-        identifier conflicts with any of the identifiers within
-        the glyph.
-
-        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
-        """
-        assert point not in self._points
-        if point.identifier is not None:
-            identifiers = self.identifiers
-            assert point.identifier not in identifiers
-            if point.identifier is not None:
-                identifiers.add(point.identifier)
-        self._points.insert(index, point)
-        self._destroyBoundsCache()
-        self._clockwiseCache = None
-        self.postNotification("Contour.PointsChanged")
-        self.dirty = True
-
-    def reverse(self):
-        """
-        Reverse the direction of the contour. It's important to note
-        that the actual points stored in this object will be completely
-        repalced by new points.
-
-        This will post *Contour.WindingDirectionChanged*,
-        *Contour.PointsChanged* and *Contour.Changed* notifications.
-        """
-        from robofab.pens.reverseContourPointPen import ReverseContourPointPen
-        oldDirection = self.clockwise
-        # put the current points in another contour
-        otherContour = self.__class__(self.pointClass)
-        # draw the points in this contour through
-        # the reversing pen.
-        reversePen = ReverseContourPointPen(otherContour)
-        self.drawPoints(reversePen)
-        # clear the points in this contour
-        self._clear(postNotification=False)
-        # draw the points back into this contour
-        self.disableNotifications()
-        otherContour.drawPoints(self)
-        self.enableNotifications()
-        # post a notification
-        self.postNotification("Contour.WindingDirectionChanged", data=dict(oldValue=oldDirection, newValue=self.clockwise))
-        self.postNotification("Contour.PointsChanged")
-        self.dirty = True
-
-    def move(self, (x, y)):
-        """
-        Move all points in the contour by **(x, y)**.
-
-        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
-        """
-        for point in self._points:
-            point.move((x, y))
-        # update the bounds cache
-        if self._boundsCache:
-            xMin, yMin, xMax, yMax = self._boundsCache
-            xMin += x
-            yMin += y
-            xMax += x
-            yMax += y
-            self._boundsCache = (xMin, yMin, xMax, yMax)
-        if self._controlPointBoundsCache:
-            xMin, yMin, xMax, yMax = self._controlPointBoundsCache
-            xMin += x
-            yMin += y
-            xMax += x
-            yMax += y
-            self._controlPointBoundsCache = (xMin, yMin, xMax, yMax)
-        self.postNotification("Contour.PointsChanged")
-        self.dirty = True
-
-    def pointInside(self, (x, y), evenOdd=False):
-        """
-        Returns a boolean indicating if **(x, y)** is in the
-        "black" area of the contour.
-        """
-        from fontTools.pens.pointInsidePen import PointInsidePen
-        pen = PointInsidePen(glyphSet=None, testPoint=(x, y), evenOdd=evenOdd)
-        self.draw(pen)
-        return pen.getResult()
-
-    def index(self, point):
-        """
-        Get the index for **point**.
-        """
-        return self._points.index(point)
-
-    def setStartPoint(self, index):
-        """
-        Set the point at **index** as the first point in the contour.
-        This point must be an on-curve point.
-
-        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
-        """
-        onCurvePoints = self.onCurvePoints
-        if len(onCurvePoints) < 2:
-            return
-        if self.open:
-            return
-        point = self._points[index]
-        assert point.segmentType is not None, "index must represent an on curve point"
-        before = self._points[:index]
-        self._points = self._points[index:] + before
-        self.postNotification("Contour.PointsChanged")
-        self.dirty = True
-
-    def positionForProspectivePointInsertionAtSegmentAndT(self, segmentIndex, t):
-        """
-        Get the precise coordinates and a boolean indicating
-        if the point will be smooth for the given **segmentIndex**
-        and **t**.
-        """
-        return self._splitAndInsertAtSegmentAndT(segmentIndex, t, False)
-
-    def splitAndInsertPointAtSegmentAndT(self, segmentIndex, t):
-        """
-        Insert a point into the contour for the given
-        **segmentIndex** and **t**.
-
-        This posts a *Contour.Changed* notification.
-        """
-        self._splitAndInsertAtSegmentAndT(segmentIndex, t, True)
-
-    def _splitAndInsertAtSegmentAndT(self, segmentIndex, t, insert):
-        segments = self.segments
-        segment = segments[segmentIndex]
-        segment.insert(0, segments[segmentIndex-1][-1])
-        firstPoint = segment[0]
-        lastPoint = segment[-1]
-        segmentType = lastPoint.segmentType
-        segment = [(point.x, point.y) for point in segment]
-        if segmentType == "line":
-            (x1, y1), (x2, y2) = segment
-            x = x1 + (x2 - x1) * t
-            y = y1 + (y2 - y1) * t
-            pointsToInsert = [((x, y), "line", False)]
-            insertionPoint =  (x, y)
-            pointWillBeSmooth = False
-        elif segmentType == "curve":
-            pt1, pt2, pt3, pt4 = segment
-            (pt1, pt2, pt3, pt4), (pt5, pt6, pt7, pt8) = bezierTools.splitCubicAtT(pt1, pt2, pt3, pt4, t)
-            pointsToInsert = [(pt2, None, False), (pt3, None, False), (pt4, "curve", True), (pt6, None, False), (pt7, None, False)]
-            insertionPoint = tuple(pt4)
-            pointWillBeSmooth = True
-        else:
-            # XXX could be a quad. in that case, we could handle it.
-            raise NotImplementedError("unknown segment type: %s" % segmentType)
-        if insert:
-            firstPointIndex = self._points.index(firstPoint)
-            lastPointIndex = self._points.index(lastPoint)
-            firstPoints = self._points[:firstPointIndex + 1]
-            if firstPointIndex == len(self._points) - 1:
-                firstPoints = firstPoints[lastPointIndex:]
-                lastPoints = []
-            elif lastPointIndex == 0:
-                lastPoints = []
-            else:
-                lastPoints = self._points[lastPointIndex:]
-            newPoints = [self._pointClass(pos, segmentType=segmentType, smooth=smooth) for pos, segmentType, smooth in pointsToInsert]
-            self._points = firstPoints + newPoints + lastPoints
-            self.dirty = True
-        return insertionPoint, pointWillBeSmooth
 
     def removeSegment(self, segmentIndex, preserveCurve=False):
@@ -472 +361 @@
         self.dirty = True
 
+    # ----------------
+    # Basic Attributes
+    # ----------------
+
+    # clockwise
+
+    def _get_clockwise(self):
+        from defcon.pens.clockwiseTestPointPen import ClockwiseTestPointPen
+        if self._clockwiseCache is None:
+            pen = ClockwiseTestPointPen()
+            self.drawPoints(pen)
+            self._clockwiseCache = pen.getIsClockwise()
+        return self._clockwiseCache
+
+    def _set_clockwise(self, value):
+        if self.clockwise != value:
+            self.reverse()
+            self._clockwiseCache = None
+
+    clockwise = property(_get_clockwise, _set_clockwise, doc="A boolean representing if the contour has a clockwise direction. Setting this posts *Contour.WindingDirectionChanged* and *Contour.Changed* notifications.")
+
+    # open
+
+    def _get_open(self):
+        if not self._points:
+            return True
+        return self._points[0].segmentType == 'move'
+
+    open = property(_get_open, doc="A boolean indicating if the contour is open or not.")
+
+    # ------
+    # Bounds
+    # ------
+
+    def _get_bounds(self):
+        from robofab.pens.boundsPen import BoundsPen
+        if self._boundsCache is None:
+            pen = BoundsPen(None)
+            self.draw(pen)
+            self._boundsCache = pen.bounds
+        return self._boundsCache
+
+    bounds = property(_get_bounds, doc="The bounds of the contour's outline expressed as a tuple of form (xMin, yMin, xMax, yMax).")
+
+    def _get_controlPointBounds(self):
+        from fontTools.pens.boundsPen import ControlBoundsPen
+        if self._controlPointBoundsCache is None:
+            pen = ControlBoundsPen(None)
+            self.draw(pen)
+            self._controlPointBoundsCache = pen.bounds
+        return self._controlPointBoundsCache
+
+    controlPointBounds = property(_get_controlPointBounds, doc="The control bounds of all points in the contour. This only measures the point positions, it does not measure curves. So, curves without points at the extrema will not be properly measured.")
+
+    # ----
+    # Move
+    # ----
+
+    def move(self, (x, y)):
+        """
+        Move all points in the contour by **(x, y)**.
+
+        This will post *Contour.PointsChanged* and *Contour.Changed* notifications.
+        """
+        for point in self._points:
+            point.move((x, y))
+        # update the bounds cache
+        if self._boundsCache:
+            xMin, yMin, xMax, yMax = self._boundsCache
+            xMin += x
+            yMin += y
+            xMax += x
+            yMax += y
+            self._boundsCache = (xMin, yMin, xMax, yMax)
+        if self._controlPointBoundsCache:
+            xMin, yMin, xMax, yMax = self._controlPointBoundsCache
+            xMin += x
+            yMin += y
+            xMax += x
+            yMax += y
+            self._controlPointBoundsCache = (xMin, yMin, xMax, yMax)
+        self.postNotification("Contour.PointsChanged")
+        self.dirty = True
+
+    # ------------
+    # Point Inside
+    # ------------
+
+    def pointInside(self, (x, y), evenOdd=False):
+        """
+        Returns a boolean indicating if **(x, y)** is in the
+        "black" area of the contour.
+        """
+        from fontTools.pens.pointInsidePen import PointInsidePen
+        pen = PointInsidePen(glyphSet=None, testPoint=(x, y), evenOdd=evenOdd)
+        self.draw(pen)
+        return pen.getResult()
+
+    # ---------
+    # Splitting
+    # ---------
+
+    def positionForProspectivePointInsertionAtSegmentAndT(self, segmentIndex, t):
+        """
+        Get the precise coordinates and a boolean indicating
+        if the point will be smooth for the given **segmentIndex**
+        and **t**.
+        """
+        return self._splitAndInsertAtSegmentAndT(segmentIndex, t, False)
+
+    def splitAndInsertPointAtSegmentAndT(self, segmentIndex, t):
+        """
+        Insert a point into the contour for the given
+        **segmentIndex** and **t**.
+
+        This posts a *Contour.Changed* notification.
+        """
+        self._splitAndInsertAtSegmentAndT(segmentIndex, t, True)
+
+    def _splitAndInsertAtSegmentAndT(self, segmentIndex, t, insert):
+        segments = self.segments
+        segment = segments[segmentIndex]
+        segment.insert(0, segments[segmentIndex-1][-1])
+        firstPoint = segment[0]
+        lastPoint = segment[-1]
+        segmentType = lastPoint.segmentType
+        segment = [(point.x, point.y) for point in segment]
+        if segmentType == "line":
+            (x1, y1), (x2, y2) = segment
+            x = x1 + (x2 - x1) * t
+            y = y1 + (y2 - y1) * t
+            pointsToInsert = [((x, y), "line", False)]
+            insertionPoint =  (x, y)
+            pointWillBeSmooth = False
+        elif segmentType == "curve":
+            pt1, pt2, pt3, pt4 = segment
+            (pt1, pt2, pt3, pt4), (pt5, pt6, pt7, pt8) = bezierTools.splitCubicAtT(pt1, pt2, pt3, pt4, t)
+            pointsToInsert = [(pt2, None, False), (pt3, None, False), (pt4, "curve", True), (pt6, None, False), (pt7, None, False)]
+            insertionPoint = tuple(pt4)
+            pointWillBeSmooth = True
+        else:
+            # XXX could be a quad. in that case, we could handle it.
+            raise NotImplementedError("unknown segment type: %s" % segmentType)
+        if insert:
+            firstPointIndex = self._points.index(firstPoint)
+            lastPointIndex = self._points.index(lastPoint)
+            firstPoints = self._points[:firstPointIndex + 1]
+            if firstPointIndex == len(self._points) - 1:
+                firstPoints = firstPoints[lastPointIndex:]
+                lastPoints = []
+            elif lastPointIndex == 0:
+                lastPoints = []
+            else:
+                lastPoints = self._points[lastPointIndex:]
+            newPoints = [self._pointClass(pos, segmentType=segmentType, smooth=smooth) for pos, segmentType, smooth in pointsToInsert]
+            self._points = firstPoints + newPoints + lastPoints
+            self.dirty = True
+        return insertionPoint, pointWillBeSmooth
+
     # -----------
     # Pen methods
@@ -577 +625 @@
         point.identifier = identifier
         self.dirty = True
+
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Contour, self).endSelfNotificationObservation()
+        self._glyph = None
+
 
 # -----

packages/defcon/branches/ufo3/Lib/defcon/objects/dataSet.py

@@ -1 +1 @@
 import os
+import weakref
 from ufoLib import UFOReader, UFOLibError
 from defcon.objects.base import BaseObject
@@ -21 +22 @@
     """
 
+    changeNotificationName = "DataSet.Changed"
     representationFactories = {}
 
-    def __init__(self, fileNames=None):
+    def __init__(self, font=None):
+        self._font = None
+        if font is not None:
+            self._font = weakref.ref(font)
         super(DataSet, self).__init__()
+        self.beginSelfNotificationObservation()
         self._data = {}
         self._scheduledForDeletion = {}
 
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
+
     def _get_font(self):
-        return self.getParent()
+        if self._font is not None:
+            return self._font()
+        return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
+
+    # ----------
+    # File Names
+    # ----------
 
     def _get_fileNames(self):
@@ -77 +96 @@
         self.dirty = True
 
-    # ---------------
-    # File Management
-    # ---------------
+    # ----
+    # Save
+    # ----
 
     def getSaveProgressBarTickCount(self, formatVersion):
@@ -170 +189 @@
             data = self[fileName]
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(DataSet, self).endSelfNotificationObservation()
+        self._font = None
+
 
 def _dataDict(data=None, dirty=False, onDisk=True, onDiskModTime=None):

packages/defcon/branches/ufo3/Lib/defcon/objects/features.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseObject
 
@@ -20 +21 @@
     representationFactories = {}
 
-    def __init__(self):
+    def __init__(self, font=None):
+        self._font = None
+        if font is not None:
+            self._font = weakref.ref(font)
         super(Features, self).__init__()
+        self.beginSelfNotificationObservation()
         self._dirty = False
         self._text = None
 
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
+
     def _get_font(self):
-        return self.getParent()
+        if self._font is not None:
+            return self._font()
+        return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
+
+    # ----
+    # Text
+    # ----
 
     def _set_text(self, value):
@@ -43 +61 @@
     text = property(_get_text, _set_text, doc="The raw feature text. Setting this post *Features.TextChanged* and *Features.Changed* notifications.")
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Features, self).endSelfNotificationObservation()
+        self._font = None

packages/defcon/branches/ufo3/Lib/defcon/objects/font.py

@@ -70 +70 @@
                     layerSetClass=None, layerClass=None, imageSetClass=None, dataSetClass=None,
                     guidelineClass=None,
-                    glyphClass=None, glyphContourClass=None, glyphPointClass=None, glyphComponentClass=None, glyphAnchorClass=None):
+                    glyphClass=None, glyphContourClass=None, glyphPointClass=None, glyphComponentClass=None, glyphAnchorClass=None, glyphImageClass=None):
+
         super(Font, self).__init__()
+        self._dispatcher = NotificationCenter()
+        self.beginSelfNotificationObservation()
+
         if infoClass is None:
             infoClass = Info
@@ -88 +92 @@
         if dataSetClass is None:
             dataSetClass = DataSet
-
-        self._dispatcher = NotificationCenter()
-
+        self._unicodeDataClass = unicodeDataClass
+        self._layerSetClass = layerSetClass
+        self._layerClass = layerClass
+        self._glyphClass = glyphClass
+        self._glyphContourClass = glyphContourClass
+        self._glyphPointClass = glyphPointClass
+        self._glyphComponentClass = glyphComponentClass
+        self._glyphAnchorClass = glyphAnchorClass
+        self._glyphImageClass = glyphImageClass
         self._kerningClass = kerningClass
         self._infoClass = infoClass
@@ -97 +107 @@
         self._libClass = libClass
         self._guidelineClass = guidelineClass
+        self._imageSetClass = imageSetClass
+        self._dataSetClass = dataSetClass
 
         self._path = path
@@ -107 +119 @@
         self._lib = None
 
-        self._layers = layerSetClass(
-            libClass=libClass, unicodeDataClass=unicodeDataClass, guidelineClass=guidelineClass,
-            layerClass=layerClass, glyphClass=glyphClass,
-            glyphContourClass=glyphContourClass, glyphPointClass=glyphPointClass,
-            glyphComponentClass=glyphComponentClass, glyphAnchorClass=glyphAnchorClass
-        )
-        self._layers.setParent(self)
-        self._layers.addObserver(self, "_objectDirtyStateChange", "LayerSet.Changed")
-        self._layers.addObserver(self, "_layerAddedNotificationCallback", "LayerSet.LayerAdded")
-        self._layers.addObserver(self, "_layerWillBeDeletedNotificationCallback", "LayerSet.LayerWillBeDeleted")
-
-        self._images = imageSetClass()
-        self._images.setParent(self)
-
-        self._data = dataSetClass()
-        self._data.setParent(self)
+        self._layers = self.instantiateLayerSet()
+        self.beginSelfLayerSetNotificationObservation()
+        self._images = self.instantiateImageSet()
+        self.beginSelfImageSetNotificationObservation()
+        self._data = self.instantiateDataSet()
+        self.beginSelfDataSetNotificationObservation()
 
         self._dirty = False
@@ -272 +274 @@
     # -----------
 
+    # layers
+
+    def instantiateLayerSet(self):
+        layers = self._layerSetClass(
+            font=self,
+            libClass=self._libClass,
+            unicodeDataClass=self._unicodeDataClass,
+            guidelineClass=self._guidelineClass,
+            layerClass=self._layerClass,
+            glyphClass=self._glyphClass,
+            glyphContourClass=self._glyphContourClass,
+            glyphPointClass=self._glyphPointClass,
+            glyphComponentClass=self._glyphComponentClass,
+            glyphAnchorClass=self._glyphAnchorClass,
+            glyphImageClass=self._glyphImageClass
+        )
+        return layers
+
+    def beginSelfLayerSetNotificationObservation(self):
+        layers = self.layers
+        layers.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="LayerSet.Changed")
+        layers.addObserver(observer=self, methodName="_layerAddedNotificationCallback", notification="LayerSet.LayerAdded")
+        layers.addObserver(observer=self, methodName="_layerWillBeDeletedNotificationCallback", notification="LayerSet.LayerWillBeDeleted")
+
+    def endSelfLayerSetNotificationObservation(self):
+        layers = self.layers
+        if layers.dispatcher is None:
+            return
+        layers.removeObserver(observer=self, notification="LayerSet.Changed")
+        layers.removeObserver(observer=self, notification="LayerSet.LayerAdded")
+        layers.removeObserver(observer=self, notification="LayerSet.LayerWillBeDeleted")
+        layers.endSelfNotificationObservation()
+
     def _get_layers(self):
         return self._layers
@@ -277 +312 @@
     layers = property(_get_layers, doc="The font's :class:`LayerSet` object.")
 
+    # info
+
+    def instantiateInfo(self):
+        info = self._infoClass(
+            font=self,
+            guidelineClass=self._guidelineClass
+        )
+        return info
+
+    def beginSelfInfoSetNotificationObservation(self):
+        info = self.info
+        info.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Info.Changed")
+
+    def endSelfInfoSetNotificationObservation(self):
+        if self._info is None:
+            return
+        if self._info.dispatcher is None:
+            return
+        self._info.removeObserver(observer=self, notification="Info.Changed")
+        self._info.endSelfNotificationObservation()
+
     def _get_info(self):
         if self._info is None:
-            self._info = self._infoClass(guidelineClass=self._guidelineClass)
-            self._info.setParent(self)
+            self._info = self.instantiateInfo()
+            self.beginSelfInfoSetNotificationObservation()
             reader = None
             if self._path is not None:
+                self._info.disableNotifications()
                 reader = UFOReader(self._path)
                 reader.readInfo(self._info)
                 self._info.dirty = False
-            self._info.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Info.Changed")
+                self._info.enableNotifications()
             self._stampInfoDataState(reader)
         return self._info
@@ -292 +349 @@
     info = property(_get_info, doc="The font's :class:`Info` object.")
 
+    # kerning
+
+    def instantiateKerning(self):
+        kerning = self._kerningClass(
+            font=self
+        )
+        return kerning
+
+    def beginSelfKerningNotificationObservation(self):
+        kerning = self.kerning
+        kerning.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Kerning.Changed")
+
+    def endSelfKerningNotificationObservation(self):
+        if self._kerning is None:
+            return
+        if self._kerning.dispatcher is None:
+            return
+        self._kerning.addObserver(observer=self, notification="Kerning.Changed")
+        self._kerning.endSelfNotificationObservation()
+
     def _get_kerning(self):
         if self._kerning is None:
-            self._kerning = self._kerningClass()
-            self._kerning.setParent(self)
+            self._kerning = self.instantiateKerning()
+            self.beginSelfKerningNotificationObservation()
             reader = None
             if self._path is not None:
+                self._kerning.disableNotifications()
                 # the _reader attribute may be present during __init__
                 # but only under certain conditions.
@@ -307 +385 @@
                 self._kerning.update(d)
                 self._kerning.dirty = False
-            self._kerning.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Kerning.Changed")
+                self._kerning.enableNotifications()
             self._stampKerningDataState(reader)
         return self._kerning
@@ -313 +391 @@
     kerning = property(_get_kerning, doc="The font's :class:`Kerning` object.")
 
+    # groups
+
+    def instantiateGroups(self):
+        groups = self._groupsClass(
+            font=self
+        )
+        return groups
+
+    def beginSelfGroupsNotificationObservation(self):
+        groups = self.groups
+        groups.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Groups.Changed")
+
+    def endSelfGroupsNotificationObservation(self):
+        if self._groups is None:
+            return
+        if self._groups.dispatcher is None:
+            return
+        self._groups.addObserver(observer=self, notification="Groups.Changed")
+        self._groups.endSelfNotificationObservation()
+
     def _get_groups(self):
         if self._groups is None:
-            self._groups = self._groupsClass()
-            self._groups.setParent(self)
+            self._groups = self.instantiateGroups()
+            self.beginSelfGroupsNotificationObservation()
             reader = None
             if self._path is not None:
+                self._groups.disableNotifications()
                 # the _reader attribute may be present during __init__
                 # but only under certain conditions.
@@ -328 +427 @@
                 self._groups.update(d)
                 self._groups.dirty = False
-            self._groups.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Groups.Changed")
+                self._groups.enableNotifications()
             self._stampGroupsDataState(reader)
         return self._groups
@@ -334 +433 @@
     groups = property(_get_groups, doc="The font's :class:`Groups` object.")
 
+    # features
+
+    def instantiateFeatures(self):
+        features = self._featuresClass(
+            font=self
+        )
+        return features
+
+    def beginSelfFeaturesNotificationObservation(self):
+        features = self.features
+        features.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Features.Changed")
+
+    def endSelfFeaturesNotificationObservation(self):
+        if self._features is None:
+            return
+        if self._features.dispatcher is None:
+            return
+        self._features.addObserver(observer=self, notification="Features.Changed")
+        self._features.endSelfNotificationObservation()
+
     def _get_features(self):
         if self._features is None:
-            self._features = self._featuresClass()
-            self._features.setParent(self)
+            self._features = self.instantiateFeatures()
+            self.beginSelfFeaturesNotificationObservation()
             reader = None
             if self._path is not None:
+                self._features.disableNotifications()
                 reader = UFOReader(self._path)
                 t = reader.readFeatures()
                 self._features.text = t
                 self._features.dirty = False
-            self._features.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Features.Changed")
+                self._features.enableNotifications()
             self._stampFeaturesDataState(reader)
         return self._features
@@ -350 +470 @@
     features = property(_get_features, doc="The font's :class:`Features` object.")
 
+    # lib
+
+    def instantiateLib(self):
+        lib = self._libClass(
+            font=self
+        )
+        return lib
+
+    def beginSelfLibNotificationObservation(self):
+        self._lib.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Lib.Changed")
+
+    def endSelfLibNotificationObservation(self):
+        if self._lib is None:
+            return
+        if self._lib.dispatcher is None:
+            return
+        self._lib.removeObserver(observer=self, notification="Lib.Changed")
+        self._lib.endSelfNotificationObservation()
+
     def _get_lib(self):
         if self._lib is None:
-            self._lib = self._libClass()
-            self._lib.setParent(self)
+            self._lib = self.instantiateLib()
+            self.beginSelfLibNotificationObservation()
             reader = None
             if self._path is not None:
+                self._lib.disableNotifications()
                 reader = UFOReader(self._path)
                 d = reader.readLib()
                 self._lib.update(d)
-            self._lib.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="Lib.Changed")
+                self._lib.enableNotifications()
             self._stampLibDataState(reader)
         return self._lib
@@ -365 +505 @@
     lib = property(_get_lib, doc="The font's :class:`Lib` object.")
 
+    # images
+
+    def instantiateImageSet(self):
+        imageSet = self._imageSetClass(
+            font=self
+        )
+        return imageSet
+
+    def beginSelfImageSetNotificationObservation(self):
+        self._images.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="ImageSet.Changed")
+
+    def endSelfImageSetNotificationObservation(self):
+        if self._images.dispatcher is None:
+            return
+        self._images.removeObserver(observer=self, notification="ImageSet.Changed")
+        self._images.endSelfNotificationObservation()
+
+    def _get_images(self):
+        return self._images
+
+    images = property(_get_images, doc="The font's :class:`ImageSet` object.")
+
+    # data
+
+    def instantiateDataSet(self):
+        dataSet = self._dataSetClass(
+            font=self
+        )
+        return dataSet
+
+    def beginSelfDataSetNotificationObservation(self):
+        self._data.addObserver(observer=self, methodName="_objectDirtyStateChange", notification="DataSet.Changed")
+
+    def endSelfDataSetNotificationObservation(self):
+        if self._data.dispatcher is None:
+            return
+        self._data.removeObserver(observer=self, notification="DataSet.Changed")
+        self._data.endSelfNotificationObservation()
+
+    def _get_data(self):
+        return self._data
+
+    data = property(_get_data, doc="The font's :class:`DataSet` object.")
+
+    # unicode data (legacy)
+
     def _get_unicodeData(self):
         return self._glyphSet._unicodeData
 
     unicodeData = property(_get_unicodeData, doc="The font's :class:`UnicodeData` object.")
-
-    def _get_images(self):
-        return self._images
-
-    images = property(_get_images, doc="The font's :class:`ImageSet` object.")
-
-    def _get_data(self):
-        return self._data
-
-    data = property(_get_data, doc="The font's :class:`DataSet` object.")
 
     # glyph order
@@ -627 +803 @@
             progressBar.update()
 
-    # ----------------------
-    # Notification Callbacks
-    # ----------------------
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        self.endSelfLayerSetNotificationObservation()
+        #self.endSelfInfoSetNotificationObservation()
+        #self.endSelfKerningNotificationObservation()
+        #self.endSelfGroupsNotificationObservation()
+        #self.endSelfLibNotificationObservation()
+        #self.endSelfFeaturesNotificationObservation()
+        #self.endSelfImageSetNotificationObservation()
+        #self.endSelfDataSetNotificationObservation()
+        super(Font, self).endSelfNotificationObservation()
 
     def _objectDirtyStateChange(self, notification):

packages/defcon/branches/ufo3/Lib/defcon/objects/glyph.py

@@ -73 +73 @@
     representationFactories = {}
 
-    def __init__(self, contourClass=None, pointClass=None, componentClass=None, anchorClass=None, guidelineClass=None, libClass=None):
+    def __init__(self, layer=None,
+        contourClass=None, pointClass=None, componentClass=None, anchorClass=None,
+        guidelineClass=None, libClass=None, imageClass=None):
+
+        if layer is not None:
+            layer = weakref.ref(layer)
+        self._layer = layer
         super(Glyph, self).__init__()
-
-        self._layer = None
-        self._parent = None
+        self.beginSelfNotificationObservation()
+
         self._dirty = False
         self._name = None
@@ -106 +111 @@
         if libClass is None:
             libClass = Lib
-
+        if imageClass is None:
+            imageClass = Image
         self._contourClass = contourClass
         self._pointClass = pointClass
@@ -112 +118 @@
         self._anchorClass = anchorClass
         self._guidelineClass = Guideline
-        self._lib = libClass()
-
-    def setParent(self, obj):
-        if obj is None:
-            if self.getParent() is not None:
-                for contour in self._contours:
-                    self._removeParentDataInContour(contour)
-                for component in self._components:
-                    self._removeParentDataInComponent(component)
-                for anchor in self._anchors:
-                    self._removeParentDataInAnchor(anchor)
-                for guideline in self._guidelines:
-                    self._removeParentDataInGuideline(guideline)
-                self._removeParentDataInLib()
-                self._removeParentDataInImage()
-                self.removeObserver(observer=self, notification="Glyph.Changed")
-                super(Glyph, self).setParent(obj)
-        else:
-            assert self.getParent() is None
-            super(Glyph, self).setParent(obj)
-            for contour in self._contours:
-                self._setParentDataInContour(contour)
-            for component in self._components:
-                self._setParentDataInComponent(component)
-            for anchor in self._anchors:
-                self._setParentDataInAnchor(anchor)
-            for guideline in self._guidelines:
-                self._setParentDataInGuideline(guideline)
-            self._setParentDataInLib()
-            self._setParentDataInImage()
-            self.addObserver(observer=self, methodName="destroyAllRepresentations", notification="Glyph.Changed")
+        self._libClass = libClass
+        self._imageClass = imageClass
+
+        self._lib = self.instantiateLib()
+        self.beginSelfLibNotificationObservation()
 
     def _destroyBoundsCache(self):
@@ -148 +128 @@
         self._controlPointBoundsCache = None
 
-    # ----------
-    # Attributes
-    # ----------
+    def __del__(self):
+        super(Glyph, self).__del__()
+        self._contours = None
+        self._components = None
+        self._anchors = None
+        self._guidelines = None
+        self._lib = None
+        self._image = None
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
 
     def _get_font(self):
-        return self.getParent()
+        layerSet = self.layerSet
+        if layerSet is None:
+            return None
+        return layerSet.font
 
     font = property(_get_font, doc="The :class:`Font` that this glyph belongs to.")
@@ -170 +165 @@
         return self._layer()
 
-    def _set_layer(self, value):
-        if value is not None:
-            value = weakref.ref(value)
-        self._layer = value
-
-    layer = property(_get_layer, _set_layer, doc="The :class:`Layer` that this glyph belongs to. This should not be set externally.")
-
-    # classes
-
-    def _get_contourClass(self):
-        return self._contourClass
-
-    contourClass = property(_get_contourClass, doc="The class used for contours.")
-
-    def _get_pointClass(self):
-        return self._pointClass
-
-    pointClass = property(_get_pointClass, doc="The class used for points.")
-
-    def _get_componentClass(self):
-        return self._componentClass
-
-    componentClass = property(_get_componentClass, doc="The class used for components.")
-
-    def _get_anchorClass(self):
-        return self._anchorClass
-
-    anchorClass = property(_get_anchorClass, doc="The class used for anchors.")
-
-    def _get_guidelineClass(self):
-        return self._guidelineClass
-
-    guidelineClass = property(_get_guidelineClass, doc="The class used for guidelines.")
+    layer = property(_get_layer, doc="The :class:`Layer` that this glyph belongs to.")
+
+    # ----------------
+    # Basic Attributes
+    # ----------------
 
     # identifiers
@@ -255 +222 @@
 
     unicode = property(_get_unicode, _set_unicode, doc="The primary unicode value for the glyph. This is the equivalent of ``glyph.unicodes[0]``. This is a convenience attribute that works with the ``unicodes`` attribute.")
+
+    # -------
+    # Metrics
+    # -------
 
     # bounds
@@ -348 +319 @@
     height = property(_get_height, _set_height, doc="The height of the glyph. Setting this posts *Glyph.HeightChanged* and *Glyph.Changed* notifications.")
 
-    # sub-object collections
-
-    def _get_components(self):
-        return list(self._components)
-
-    components = property(_get_components, doc="An ordered list of :class:`Component` objects stored in the glyph.")
-
-    def _get_anchors(self):
-        return list(self._anchors)
-
-    def _set_anchors(self, value):
-        self.clearAnchors()
-        self.holdNotifications()
-        for anchor in value:
-            self.appendAnchor(anchor)
-        self.releaseHeldNotifications()
-
-    anchors = property(_get_anchors, _set_anchors, doc="An ordered list of :class:`Anchor` objects stored in the glyph.")
-
-    def _get_guidelines(self):
-        return list(self._guidelines)
-
-    def _set_guidelines(self, value):
-        self.clearGuidelines()
-        self.holdNotifications()
-        for guideline in value:
-            self.appendGuideline(guideline)
-        self.releaseHeldNotifications()
-
-    guidelines = property(_get_guidelines, _set_guidelines, doc="An ordered list of :class:`Guideline` objects stored in the glyph. Setting this will post a *Glyph.Changed* notification along with any notifications posted by the :py:meth:`Glyph.appendGuideline` and :py:meth:`Glyph.clearGuidelines` methods.")
-
-    # note
-
-    def _get_note(self):
-        return self._note
-
-    def _set_note(self, value):
-        if value is not None:
-            assert isinstance(value, basestring)
-        oldValue = self._note
-        if oldValue != value:
-            self._note = value
-            self.postNotification(notification="Glyph.NoteChanged", data=dict(oldValue=oldValue, newValue=value))
-            self.dirty = True
-
-    note = property(_get_note, _set_note, doc="An arbitrary note for the glyph. Setting this will post a *Glyph.Changed* notification.")
-
-    # lib
-
-    def _get_lib(self):
-        return self._lib
-
-    def _set_lib(self, value):
-        self._lib.clear()
-        self._lib.update(value)
-        self.dirty = True
-
-    lib = property(_get_lib, _set_lib, doc="The glyph's :class:`Lib` object. Setting this will clear any existing lib data and post a *Glyph.Changed* notification if data was replaced.")
-
-    # image
-
-    def _get_image(self):
-        return self._image
-
-    def _set_image(self, image):
-        if image is None:
-            if self._image is not None:
-                self.postNotification(notification="Glyph.ImageWillBeDeleted")
-                self._removeParentDataInImage()
-                self._image = None
-                self.postNotification(notification="Glyph.ImageChanged")
-                self.dirty = True
-        else:
-            if self._image is None:
-                self._image = Image()
-                self._setParentDataInImage()
-            if set(self.image.items()) != set(image.items()):
-                for key in self._image.keys():
-                    self._image[key] = image.get(key)
-                self.postNotification(notification="Glyph.ImageChanged")
-                self.dirty = True
-
-    image = property(_get_image, _set_image, doc="The glyph's :class:`Image` object. Setting this posts *Glyph.ImageChanged* and *Glyph.Changed* notifications.")
+    # ----------------------
+    # Lib Wrapped Attributes
+    # ----------------------
 
     # mark color
@@ -461 +352 @@
     markColor = property(_get_markColor, _set_markColor, doc="The glyph's mark color. When setting, the value can be a UFO color string, a sequence of (r, g, b, a) or a :class:`Color` object. Setting this posts *Glyph.MarkColorChanged* and *Glyph.Changed* notifications.")
 
-    # -----------
-    # Pen Methods
-    # -----------
+    # -------
+    # Pen API
+    # -------
 
     def draw(self, pen):
@@ -496 +387 @@
         return GlyphObjectPointPen(self)
 
-    # --------------------------
-    # Parent Setting and Removal
-    # --------------------------
-
-    def _setParentDataInLib(self):
-        self._lib.setParent(self)
-        if self.dispatcher is not None and not self._lib.hasObserver(observer=self, notification="Lib.Changed"):
-            self._lib.addObserver(observer=self, methodName="_libContentChanged", notification="Lib.Changed")
-
-    def _removeParentDataInLib(self):
-        if self.dispatcher is not None:
-            self._lib.removeObserver(observer=self, notification="Lib.Changed")
-        self._lib.setParent(None)
-
-    def _setParentDataInContour(self, contour):
-        contour.setParent(self)
-        if self.dispatcher is not None and not contour.hasObserver(observer=self, notification="Contour.Changed"):
-            contour.addObserver(observer=self, methodName="_contourChanged", notification="Contour.Changed")
-
-    def _removeParentDataInContour(self, contour):
-        if self.dispatcher is not None:
-            contour.removeObserver(observer=self, notification="Contour.Changed")
-        contour.setParent(None)
-
-    def _setParentDataInComponent(self, component):
-        component.setParent(self)
-        if self.dispatcher is not None and not component.hasObserver(observer=self, notification="Component.Changed"):
-            component.addObserver(observer=self, methodName="_componentChanged", notification="Component.Changed")
-
-    def _removeParentDataInComponent(self, component):
-        if self.dispatcher is not None:
-            component.removeObserver(observer=self, notification="Component.Changed")
-        component.setParent(None)
-
-    def _setParentDataInAnchor(self, anchor):
-        anchor.setParent(self)
-        if self.dispatcher is not None and not anchor.hasObserver(observer=self, notification="Anchor.Changed"):
-            anchor.addObserver(observer=self, methodName="_anchorChanged", notification="Anchor.Changed")
-
-    def _removeParentDataInAnchor(self, anchor):
-        if self.dispatcher is not None:
-            anchor.removeObserver(observer=self, notification="Anchor.Changed")
-        anchor.setParent(None)
-
-    def _setParentDataInGuideline(self, guideline):
-        guideline.setParent(self)
-        if self.dispatcher is not None and not guideline.hasObserver(observer=self, notification="Guideline.Changed"):
-            guideline.addObserver(observer=self, methodName="_guidelineChanged", notification="Guideline.Changed")
-
-    def _removeParentDataInGuideline(self, guideline):
-        if self.dispatcher is not None:
-            guideline.removeObserver(observer=self, notification="Guideline.Changed")
-        guideline.setParent(None)
-
-    def _setParentDataInImage(self):
+    # --------
+    # Contours
+    # --------
+
+    def _get_contourClass(self):
+        return self._contourClass
+
+    contourClass = property(_get_contourClass, doc="The class used for contours.")
+
+    def _get_pointClass(self):
+        return self._pointClass
+
+    pointClass = property(_get_pointClass, doc="The class used for points.")
+
+    def instantiateContour(self):
+        contour = self._contourClass(
+            glyph=self,
+            pointClass=self.pointClass
+        )
+        return contour
+
+    def beginSelfContourNotificationObservation(self, contour):
+        if contour.dispatcher is None:
+            return
+        contour.addObserver(observer=self, methodName="_contourChanged", notification="Contour.Changed")
+
+    def endSelfContourNotificationObservation(self, contour):
+        if contour.dispatcher is None:
+            return
+        contour.removeObserver(observer=self, notification="Contour.Changed")
+        contour.endSelfNotificationObservation()
+
+    def appendContour(self, contour):
+        """
+        Append **contour** to the glyph. The contour must be a defcon
+        :class:`Contour` object or a subclass of that object. An error
+        will be raised if the contour's identifier or a point identifier
+        conflicts with any of the identifiers within the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert contour not in self._contours
+        self.insertContour(len(self._contours), contour)
+
+    def insertContour(self, index, contour):
+        """
+        Insert **contour** into the glyph at index. The contour
+        must be a defcon :class:`Contour` object or a subclass
+        of that object. An error will be raised if the contour's
+        identifier or a point identifier conflicts with any of
+        the identifiers within the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert contour not in self._contours
+        assert contour.glyph in (self, None), "This contour belongs to another glyph."
+        if contour.glyph is None:
+            identifiers = self._identifiers
+            if contour.identifier is not None:
+                assert contour.identifier not in identifiers
+                identifiers.add(contour.identifier)
+            for point in contour:
+                if point.identifier is not None:
+                    assert point.identifier not in identifiers
+                    identifiers.add(point.identifier)
+            contour.glyph = self
+            contour.beginSelfNotificationObservation()
+        self.beginSelfContourNotificationObservation(contour)
+        self._contours.insert(index, contour)
+        self._destroyBoundsCache()
+        self.postNotification(notification="Glyph.ContoursChanged")
+        self.dirty = True
+
+    def removeContour(self, contour):
+        """
+        Remove **contour** from the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        self.postNotification(notification="Glyph.ContourWillBeDeleted", data=dict(object=contour))
+        identifiers = self._identifiers
+        if contour.identifier is not None:
+            identifiers.remove(contour.identifier)
+        for point in contour:
+            if point.identifier is not None:
+                identifiers.remove(point.identifier)
+        self._contours.remove(contour)
+        self.endSelfContourNotificationObservation(contour)
+        self._destroyBoundsCache()
+        self.postNotification(notification="Glyph.ContoursChanged")
+        self.dirty = True
+
+    def contourIndex(self, contour):
+        """
+        Get the index for **contour**.
+        """
+        return self._contours.index(contour)
+
+    def clearContours(self):
+        """
+        Clear all contours from the glyph.
+
+        This posts a *Glyph.Changed* notification.
+        """
+        self.holdNotifications()
+        for contour in reversed(self._contours):
+            self.removeContour(contour)
+        self.releaseHeldNotifications()
+
+    # ----------
+    # Components
+    # ----------
+
+    def _get_componentClass(self):
+        return self._componentClass
+
+    componentClass = property(_get_componentClass, doc="The class used for components.")
+
+    def _get_components(self):
+        return list(self._components)
+
+    components = property(_get_components, doc="An ordered list of :class:`Component` objects stored in the glyph.")
+
+    def instantiateComponent(self):
+        component = self._componentClass(
+            glyph=self
+        )
+        return component
+
+    def beginSelfComponentNotificationObservation(self, component):
+        if component.dispatcher is None:
+            return
+        component.addObserver(observer=self, methodName="_componentChanged", notification="Component.Changed")
+
+    def endSelfComponentNotificationObservation(self, component):
+        if component.dispatcher is None:
+            return
+        component.removeObserver(observer=self, notification="Component.Changed")
+        component.endSelfNotificationObservation()
+
+    def appendComponent(self, component):
+        """
+        Append **component** to the glyph. The component must be a defcon
+        :class:`Component` object or a subclass of that object. An error
+        will be raised if the component's identifier conflicts with any of
+        the identifiers within the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert component not in self._components
+        self.insertComponent(len(self._components), component)
+
+    def insertComponent(self, index, component):
+        """
+        Insert **component** into the glyph at index. The component
+        must be a defcon :class:`Component` object or a subclass
+        of that object. An error will be raised if the component's
+        identifier conflicts with any of the identifiers within
+        the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert component not in self._components
+        assert component.glyph in (self, None), "This component belongs to another glyph."
+        if component.glyph is None:
+            if component.identifier is not None:
+                identifiers = self._identifiers
+                assert component.identifier not in identifiers
+                identifiers.add(component.identifier)
+            component.glyph = self
+            component.beginSelfNotificationObservation()
+        self.beginSelfComponentNotificationObservation(component)
+        self._components.insert(index, component)
+        self._destroyBoundsCache()
+        self.postNotification(notification="Glyph.ComponentsChanged")
+        self.dirty = True
+
+    def removeComponent(self, component):
+        """
+        Remove **component** from the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        self.postNotification(notification="Glyph.ComponentWillBeDeleted", data=dict(object=component))
+        if component.identifier is not None:
+            self._identifiers.remove(component.identifier)
+        self._components.remove(component)
+        self.endSelfComponentNotificationObservation(component)
+        self._destroyBoundsCache()
+        self.postNotification(notification="Glyph.ComponentsChanged")
+        self.dirty = True
+
+    def componentIndex(self, component):
+        """
+        Get the index for **component**.
+        """
+        return self._components.index(component)
+
+    def clearComponents(self):
+        """
+        Clear all components from the glyph.
+
+        This posts a *Glyph.Changed* notification.
+        """
+        self.holdNotifications()
+        for component in reversed(self._components):
+            self.removeComponent(component)
+        self.releaseHeldNotifications()
+
+    # -------
+    # Anchors
+    # -------
+
+    def _get_anchorClass(self):
+        return self._anchorClass
+
+    anchorClass = property(_get_anchorClass, doc="The class used for anchors.")
+
+    def _get_anchors(self):
+        return list(self._anchors)
+
+    def _set_anchors(self, value):
+        self.clearAnchors()
+        self.holdNotifications()
+        for anchor in value:
+            self.appendAnchor(anchor)
+        self.releaseHeldNotifications()
+
+    anchors = property(_get_anchors, _set_anchors, doc="An ordered list of :class:`Anchor` objects stored in the glyph.")
+
+    def instantiateAnchor(self, anchorDict=None):
+        anchor = self._anchorClass(
+            glyph=self,
+            anchorDict=anchorDict
+        )
+        return anchor
+
+    def beginSelfAnchorNotificationObservation(self, anchor):
+        if anchor.dispatcher is None:
+            return
+        anchor.addObserver(observer=self, methodName="_anchorChanged", notification="Anchor.Changed")
+
+    def endSelfAnchorNotificationObservation(self, anchor):
+        if anchor.dispatcher is None:
+            return
+        anchor.removeObserver(observer=self, notification="Anchor.Changed")
+        anchor.endSelfNotificationObservation()
+
+    def appendAnchor(self, anchor):
+        """
+        Append **anchor** to the glyph. The anchor must be a defcon
+        :class:`Anchor` object or a subclass of that object. An error
+        will be raised if the anchor's identifier conflicts with any of
+        the identifiers within the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert anchor not in self._anchors
+        self.insertAnchor(len(self._anchors), anchor)
+
+    def insertAnchor(self, index, anchor):
+        """
+        Insert **anchor** into the glyph at index. The anchor
+        must be a defcon :class:`Anchor` object or a subclass
+        of that object. An error will be raised if the anchor's
+        identifier conflicts with any of the identifiers within
+        the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert anchor not in self._anchors
+        if not isinstance(anchor, self._anchorClass):
+            anchor = self.instantiateAnchor(anchorDict=anchor)
+        assert anchor.glyph in (self, None), "This anchor belongs to another glyph."
+        if anchor.glyph is None:
+            if anchor.identifier is not None:
+                identifiers = self._identifiers
+                assert anchor.identifier not in identifiers
+                identifiers.add(anchor.identifier)
+            anchor.glyph = self
+            anchor.beginSelfNotificationObservation()
+        self.beginSelfAnchorNotificationObservation(anchor)
+        self._anchors.insert(index, anchor)
+        self.postNotification(notification="Glyph.AnchorsChanged")
+        self.dirty = True
+
+    def removeAnchor(self, anchor):
+        """
+        Remove **anchor** from the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        self.postNotification(notification="Glyph.AnchorWillBeDeleted", data=dict(object=anchor))
+        if anchor.identifier is not None:
+            self._identifiers.remove(anchor.identifier)
+        self._anchors.remove(anchor)
+        self.endSelfAnchorNotificationObservation(anchor)
+        self.postNotification(notification="Glyph.AnchorsChanged")
+        self.dirty = True
+
+    def anchorIndex(self, anchor):
+        """
+        Get the index for **anchor**.
+        """
+        return self._anchors.index(anchor)
+
+    def clearAnchors(self):
+        """
+        Clear all anchors from the glyph.
+
+        This posts a *Glyph.Changed* notification.
+        """
+        self.holdNotifications()
+        for anchor in reversed(self._anchors):
+            self.removeAnchor(anchor)
+        self.releaseHeldNotifications()
+
+    # ----------
+    # Guidelines
+    # ----------
+
+    def _get_guidelineClass(self):
+        return self._guidelineClass
+
+    guidelineClass = property(_get_guidelineClass, doc="The class used for guidelines.")
+
+    def _get_guidelines(self):
+        return list(self._guidelines)
+
+    def _set_guidelines(self, value):
+        self.clearGuidelines()
+        self.holdNotifications()
+        for guideline in value:
+            self.appendGuideline(guideline)
+        self.releaseHeldNotifications()
+
+    guidelines = property(_get_guidelines, _set_guidelines, doc="An ordered list of :class:`Guideline` objects stored in the glyph. Setting this will post a *Glyph.Changed* notification along with any notifications posted by the :py:meth:`Glyph.appendGuideline` and :py:meth:`Glyph.clearGuidelines` methods.")
+
+    def instantiateGuideline(self, guidelineDict=None):
+        guideline = self._guidelineClass(
+            glyph=self,
+            guidelineDict=guidelineDict
+        )
+        return guideline
+
+    def beginSelfGuidelineNotificationObservation(self, guideline):
+        if guideline.dispatcher is None:
+            return
+        guideline.addObserver(observer=self, methodName="_guidelineChanged", notification="Guideline.Changed")
+
+    def endSelfGuidelineNotificationObservation(self, guideline):
+        if guideline.dispatcher is None:
+            return
+        guideline.removeObserver(observer=self, notification="Guideline.Changed")
+        guideline.endSelfNotificationObservation()
+
+    def appendGuideline(self, guideline):
+        """
+        Append **guideline** to the glyph. The guideline must be a defcon
+        :class:`Guideline` object or a subclass of that object. An error
+        will be raised if the guideline's identifier conflicts with any of
+        the identifiers within the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert guideline not in self._guidelines
+        self.insertGuideline(len(self._guidelines), guideline)
+
+    def insertGuideline(self, index, guideline):
+        """
+        Insert **guideline** into the glyph at index. The guideline
+        must be a defcon :class:`Guideline` object or a subclass
+        of that object. An error will be raised if the guideline's
+        identifier conflicts with any of the identifiers within
+        the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        assert guideline not in self._guidelines
+        if not isinstance(guideline, self._guidelineClass):
+            guideline = self.instantiateGuideline(guidelineDict=guideline)
+        assert guideline.glyph in (self, None), "This guideline belongs to another glyph."
+        if guideline.glyph is None:
+            assert guideline.fontInfo is None, "This guideline belongs to a font."
+        if guideline.glyph is None:
+            if guideline.identifier is not None:
+                identifiers = self._identifiers
+                assert guideline.identifier not in identifiers
+                if guideline.identifier is not None:
+                    identifiers.add(guideline.identifier)
+            guideline.glyph = self
+            guideline.beginSelfNotificationObservation()
+        self.beginSelfGuidelineNotificationObservation(guideline)
+        self._guidelines.insert(index, guideline)
+        self.postNotification(notification="Glyph.GuidelinesChanged")
+        self.dirty = True
+
+    def removeGuideline(self, guideline):
+        """
+        Remove **guideline** from the glyph.
+
+        This will post a *Glyph.Changed* notification.
+        """
+        self.postNotification(notification="Glyph.GuidelineWillBeDeleted", data=dict(object=guideline))
+        if guideline.identifier is not None:
+            self._identifiers.remove(guideline.identifier)
+        self._guidelines.remove(guideline)
+        self.endSelfGuidelineNotificationObservation(guideline)
+        self.postNotification(notification="Glyph.GuidelinesChanged")
+        self.dirty = True
+
+    def guidelineIndex(self, guideline):
+        """
+        Get the index for **guideline**.
+        """
+        return self._guidelines.index(guideline)
+
+    def clearGuidelines(self):
+        """
+        Clear all guidelines from the glyph.
+
+        This posts a *Glyph.Changed* notification.
+        """
+        self.holdNotifications()
+        for guideline in reversed(self._guidelines):
+            self.removeGuideline(guideline)
+        self.releaseHeldNotifications()
+
+    # ----
+    # Note
+    # ----
+
+    def _get_note(self):
+        return self._note
+
+    def _set_note(self, value):
+        if value is not None:
+            assert isinstance(value, basestring)
+        oldValue = self._note
+        if oldValue != value:
+            self._note = value
+            self.postNotification(notification="Glyph.NoteChanged", data=dict(oldValue=oldValue, newValue=value))
+            self.dirty = True
+
+    note = property(_get_note, _set_note, doc="An arbitrary note for the glyph. Setting this will post a *Glyph.Changed* notification.")
+
+    # ---
+    # Lib
+    # ---
+
+    def instantiateLib(self):
+        lib = self._libClass(
+            glyph=self
+        )
+        return lib
+
+    def _get_lib(self):
+        return self._lib
+
+    def _set_lib(self, value):
+        self._lib.clear()
+        self._lib.update(value)
+        self.dirty = True
+
+    lib = property(_get_lib, _set_lib, doc="The glyph's :class:`Lib` object. Setting this will clear any existing lib data and post a *Glyph.Changed* notification if data was replaced.")
+
+    def beginSelfLibNotificationObservation(self):
+        if self._lib.dispatcher is None:
+            return
+        self._lib.addObserver(observer=self, methodName="_libContentChanged", notification="Lib.Changed")
+
+    def endSelfLibNotificationObservation(self):
+        if self._lib.dispatcher is None:
+            return
+        self._lib.removeObserver(observer=self, notification="Lib.Changed")
+        self._lib.endSelfNotificationObservation()
+
+    # -----
+    # Image
+    # -----
+
+    def instantiateImage(self):
+        image = self._imageClass(
+            glyph=self
+        )
+        return image
+
+    def _get_image(self):
+        return self._image
+
+    def _set_image(self, image):
+        # removing image
+        if image is None:
+            if self._image is not None:
+                self.postNotification(notification="Glyph.ImageWillBeDeleted")
+                self.endSelfImageNotificationObservation()
+                self._image = None
+                self.postNotification(notification="Glyph.ImageChanged")
+                self.dirty = True
+        # adding image
+        else:
+            if self._image is None:
+                self._image = self.instantiateImage()
+                self.beginSelfImageNotificationObservation()
+            if set(self.image.items()) != set(image.items()):
+                for key in self._image.keys():
+                    self._image[key] = image.get(key)
+                self.postNotification(notification="Glyph.ImageChanged")
+                self.dirty = True
+
+    image = property(_get_image, _set_image, doc="The glyph's :class:`Image` object. Setting this posts *Glyph.ImageChanged* and *Glyph.Changed* notifications.")
+
+    def beginSelfImageNotificationObservation(self):
+        if self._image.dispatcher is None:
+            return
+        self._image.addObserver(observer=self, methodName="_imageChanged", notification="Image.Changed")
+
+    def endSelfImageNotificationObservation(self):
         if self._image is None:
             return
-        self._image.setParent(self)
-        if self.dispatcher is not None and not self._image.hasObserver(observer=self, notification="Image.Changed"):
-            self._image.addObserver(observer=self, methodName="_imageChanged", notification="Image.Changed")
-
-    def _removeParentDataInImage(self):
-        if self._image is None:
+        if self._image.dispatcher is None:
             return
-        if self.dispatcher is not None:
-            self._image.removeObserver(observer=self, notification="Image.Changed")
-        self._image.setParent(None)
-
-    # -------
-    # Methods
-    # -------
+        self._image.removeObserver(observer=self, notification="Image.Changed")
+        self._image.endSelfNotificationObservation()
+
+    # -------------
+    # List Behavior
+    # -------------
 
     def __len__(self):
@@ -584 +932 @@
     def _getContourIndex(self, contour):
         return self._contours.index(contour)
+
+    # ----------------
+    # Glyph Absorption
+    # ----------------
 
     def copyDataFromGlyph(self, glyph):
@@ -609 +961 @@
         self.unicodes = list(glyph.unicodes)
         self.note = glyph.note
-        self.guidelines = glyph.guidelines
-        self.anchors = glyph.anchors
+        self.guidelines = [self.instantiateGuideline(g) for g in glyph.guidelines]
+        self.anchors = [self.instantiateAnchor(a) for a in glyph.anchors]
         self.image = glyph.image
         pointPen = self.getPointPen()
@@ -616 +968 @@
         self.lib = deepcopy(glyph.lib)
 
-    def appendContour(self, contour):
-        """
-        Append **contour** to the glyph. The contour must be a defcon
-        :class:`Contour` object or a subclass of that object. An error
-        will be raised if the contour's identifier or a point identifier
-        conflicts with any of the identifiers within the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert contour not in self._contours
-        self.insertContour(len(self._contours), contour)
-
-    def appendComponent(self, component):
-        """
-        Append **component** to the glyph. The component must be a defcon
-        :class:`Component` object or a subclass of that object. An error
-        will be raised if the component's identifier conflicts with any of
-        the identifiers within the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert component not in self._components
-        self.insertComponent(len(self._components), component)
-
-    def appendAnchor(self, anchor):
-        """
-        Append **anchor** to the glyph. The anchor must be a defcon
-        :class:`Anchor` object or a subclass of that object. An error
-        will be raised if the anchor's identifier conflicts with any of
-        the identifiers within the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert anchor not in self._anchors
-        self.insertAnchor(len(self._anchors), anchor)
-
-    def appendGuideline(self, guideline):
-        """
-        Append **guideline** to the glyph. The guideline must be a defcon
-        :class:`Guideline` object or a subclass of that object. An error
-        will be raised if the guideline's identifier conflicts with any of
-        the identifiers within the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert guideline not in self._guidelines
-        self.insertGuideline(len(self._guidelines), guideline)
-
-    def insertContour(self, index, contour):
-        """
-        Insert **contour** into the glyph at index. The contour
-        must be a defcon :class:`Contour` object or a subclass
-        of that object. An error will be raised if the contour's
-        identifier or a point identifier conflicts with any of
-        the identifiers within the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert contour not in self._contours
-        identifiers = self._identifiers
-        if contour.identifier is not None:
-            assert contour.identifier not in identifiers
-            if contour.identifier is not None:
-                identifiers.add(contour.identifier)
-        for point in contour:
-            if point.identifier is not None:
-                assert point.identifier not in identifiers
-                self._identifiers.add(point.identifier)
-        if contour.glyph != self:
-            self._setParentDataInContour(contour)
-        self._contours.insert(index, contour)
-        self._destroyBoundsCache()
-        self.postNotification(notification="Glyph.ContoursChanged")
-        self.dirty = True
-
-    def insertComponent(self, index, component):
-        """
-        Insert **component** into the glyph at index. The component
-        must be a defcon :class:`Component` object or a subclass
-        of that object. An error will be raised if the component's
-        identifier conflicts with any of the identifiers within
-        the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert component not in self._components
-        if component.identifier is not None:
-            identifiers = self._identifiers
-            assert component.identifier not in identifiers
-            if component.identifier is not None:
-                identifiers.add(component.identifier)
-        if component.glyph != self:
-            self._setParentDataInComponent(component)
-        self._components.insert(index, component)
-        self._destroyBoundsCache()
-        self.postNotification(notification="Glyph.ComponentsChanged")
-        self.dirty = True
-
-    def insertAnchor(self, index, anchor):
-        """
-        Insert **anchor** into the glyph at index. The anchor
-        must be a defcon :class:`Anchor` object or a subclass
-        of that object. An error will be raised if the anchor's
-        identifier conflicts with any of the identifiers within
-        the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert anchor not in self._anchors
-        if not isinstance(anchor, self._anchorClass):
-            anchor = self._anchorClass(anchor)
-        if anchor.identifier is not None:
-            identifiers = self._identifiers
-            assert anchor.identifier not in identifiers
-            if anchor.identifier is not None:
-                identifiers.add(anchor.identifier)
-        if anchor.glyph != self:
-            self._setParentDataInAnchor(anchor)
-        self._anchors.insert(index, anchor)
-        self.postNotification(notification="Glyph.AnchorsChanged")
-        self.dirty = True
-
-    def insertGuideline(self, index, guideline):
-        """
-        Insert **guideline** into the glyph at index. The guideline
-        must be a defcon :class:`Guideline` object or a subclass
-        of that object. An error will be raised if the guideline's
-        identifier conflicts with any of the identifiers within
-        the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        assert guideline not in self._guidelines
-        if not isinstance(guideline, self._guidelineClass):
-            guideline = self._guidelineClass(guideline)
-        if guideline.identifier is not None:
-            identifiers = self._identifiers
-            assert guideline.identifier not in identifiers
-            if guideline.identifier is not None:
-                identifiers.add(guideline.identifier)
-        if guideline.glyph != self:
-            self._setParentDataInGuideline(guideline)
-        self._guidelines.insert(index, guideline)
-        self.postNotification(notification="Glyph.GuidelinesChanged")
-        self.dirty = True
-
-    def removeContour(self, contour):
-        """
-        Remove **contour** from the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        self.postNotification(notification="Glyph.ContourWillBeDeleted", data=dict(object=contour))
-        identifiers = self._identifiers
-        if contour.identifier is not None:
-            identifiers.remove(contour.identifier)
-        for point in contour:
-            if point.identifier is not None:
-                identifiers.remove(point.identifier)
-        self._contours.remove(contour)
-        self._removeParentDataInContour(contour)
-        self._destroyBoundsCache()
-        self.postNotification(notification="Glyph.ContoursChanged")
-        self.dirty = True
-
-    def removeComponent(self, component):
-        """
-        Remove **component** from the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        self.postNotification(notification="Glyph.ComponentWillBeDeleted", data=dict(object=component))
-        if component.identifier is not None:
-            self._identifiers.remove(component.identifier)
-        self._components.remove(component)
-        self._removeParentDataInComponent(component)
-        self._destroyBoundsCache()
-        self.postNotification(notification="Glyph.ComponentsChanged")
-        self.dirty = True
-
-    def removeAnchor(self, anchor):
-        """
-        Remove **anchor** from the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        self.postNotification(notification="Glyph.AnchorWillBeDeleted", data=dict(object=anchor))
-        if anchor.identifier is not None:
-            self._identifiers.remove(anchor.identifier)
-        self._anchors.remove(anchor)
-        self._removeParentDataInAnchor(anchor)
-        self.postNotification(notification="Glyph.AnchorsChanged")
-        self.dirty = True
-
-    def removeGuideline(self, guideline):
-        """
-        Remove **guideline** from the glyph.
-
-        This will post a *Glyph.Changed* notification.
-        """
-        self.postNotification(notification="Glyph.GuidelineWillBeDeleted", data=dict(object=guideline))
-        if guideline.identifier is not None:
-            self._identifiers.remove(guideline.identifier)
-        self._guidelines.remove(guideline)
-        self._removeParentDataInGuideline(guideline)
-        self.postNotification(notification="Glyph.GuidelinesChanged")
-        self.dirty = True
-
-    def contourIndex(self, contour):
-        """
-        Get the index for **contour**.
-        """
-        return self._contours.index(contour)
-
-    def componentIndex(self, component):
-        """
-        Get the index for **component**.
-        """
-        return self._components.index(component)
-
-    def anchorIndex(self, anchor):
-        """
-        Get the index for **anchor**.
-        """
-        return self._anchors.index(anchor)
-
-    def guidelineIndex(self, guideline):
-        """
-        Get the index for **guideline**.
-        """
-        return self._guidelines.index(guideline)
+    # -----
+    # Clear
+    # -----
 
     def clear(self):
@@ -861 +985 @@
         self.releaseHeldNotifications()
 
-    def clearContours(self):
-        """
-        Clear all contours from the glyph.
-
-        This posts a *Glyph.Changed* notification.
-        """
-        self.holdNotifications()
-        for contour in reversed(self._contours):
-            self.removeContour(contour)
-        self.releaseHeldNotifications()
-
-    def clearComponents(self):
-        """
-        Clear all components from the glyph.
-
-        This posts a *Glyph.Changed* notification.
-        """
-        self.holdNotifications()
-        for component in reversed(self._components):
-            self.removeComponent(component)
-        self.releaseHeldNotifications()
-
-    def clearAnchors(self):
-        """
-        Clear all anchors from the glyph.
-
-        This posts a *Glyph.Changed* notification.
-        """
-        self.holdNotifications()
-        for anchor in reversed(self._anchors):
-            self.removeAnchor(anchor)
-        self.releaseHeldNotifications()
-
-    def clearGuidelines(self):
-        """
-        Clear all guidelines from the glyph.
-
-        This posts a *Glyph.Changed* notification.
-        """
-        self.holdNotifications()
-        for guideline in reversed(self._guidelines):
-            self.removeGuideline(guideline)
-        self.releaseHeldNotifications()
+    # ----
+    # Move
+    # ----
 
     def move(self, (x, y)):
@@ -935 +1019 @@
             self._controlPointBoundsCache = (xMin, yMin, xMax, yMax)
 
+    # ------------
+    # Point Inside
+    # ------------
+
     def pointInside(self, (x, y), evenOdd=False):
         """
@@ -948 +1036 @@
     # Notification Callbacks
     # ----------------------
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        for contour in self:
+            self.endSelfContourNotificationObservation(contour)
+        for component in self.components:
+            self.endSelfComponentNotificationObservation(component)
+        for anchor in self.anchors:
+            self.endSelfAnchorNotificationObservation(anchor)
+        for guideline in self.guidelines:
+            self.endSelfGuidelinesNotificationObservation(guideline)
+        self.endSelfLibNotificationObservation()
+        self.endSelfImageNotificationObservation()
+        super(Glyph, self).endSelfNotificationObservation()
+        self._font = None
 
     def _imageChanged(self, notification):
@@ -1041 +1145 @@
     >>> glyph.bounds
     (0, 0, 700, 700)
+
     >>> glyph = font['B']
     >>> glyph.bounds
@@ -1571 +1676 @@
 
     >>> pointPen.beginPath(identifier="contour 1")
-    >>> pointPen.endPath()
     Traceback (most recent call last):
         ...
     AssertionError
+    >>> pointPen.endPath()
 
     >>> pointPen.beginPath()
     >>> pointPen.addPoint((0, 0))
     >>> pointPen.addPoint((0, 0), identifier="point 1")
-    >>> pointPen.endPath()
     Traceback (most recent call last):
         ...
     AssertionError
+    >>> pointPen.endPath()
 
     >>> pointPen.addComponent("A", (1, 1, 1, 1, 1, 1), identifier="component 1")

packages/defcon/branches/ufo3/Lib/defcon/objects/groups.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseDictObject
 
@@ -68 +69 @@
     representationFactories = {}
 
+    def __init__(self, font=None):
+        self._font = None
+        if font is not None:
+            self._font = weakref.ref(font)
+        super(Groups, self).__init__()
+        self.beginSelfNotificationObservation()
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
+
     def _get_font(self):
-        return self.getParent()
+        if self._font is not None:
+            return self._font()
+        return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
+
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Groups, self).endSelfNotificationObservation()
+        self._font = None
 
 

packages/defcon/branches/ufo3/Lib/defcon/objects/guideline.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseDictObject
 from defcon.objects.color import Color
@@ -30 +31 @@
     representationFactories = {}
 
-    def __init__(self, guidelineDict=None):
+    def __init__(self, fontInfo=None, glyph=None, guidelineDict=None):
+        self._fontInfo = None
+        self._glyph = None
+        if fontInfo is not None:
+            self.fontInfo = fontInfo
+        if glyph is not None:
+            self.glyph = glyph
         super(Guideline, self).__init__()
+        self.beginSelfNotificationObservation()
         self._dirty = False
         if guidelineDict is not None:
@@ -41 +49 @@
             self.identifier = guidelineDict.get("identifier")
 
-    # ----------
-    # Properties
-    # ----------
-
-    # parents
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        if self._fontInfo is not None:
+            return self.fontInfo
+        elif self._glyph is not None:
+            return self.glyph
+        return None
 
     def _get_font(self):
-        glyph = self.glyph
-        if glyph is not None:
-            return glyph.font
-        info = self.info
-        if info is not None:
-            return info.font
+        if self._fontInfo is not None:
+            return self.fontInfo.font
+        elif self._glyph is not None:
+            return self.glyph.font
         return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
 
-    def _get_info(self):
-        from defcon.objects.info import Info
-        parent = self.getParent()
-        if not isinstance(parent, Info):
-            return None
-        return parent
-
-    info = property(_get_info, doc="The :class:`Info` that this object belongs to (if it is a font info guideline).")
+    def _get_fontInfo(self):
+        if self._fontInfo is not None:
+            return self._fontInfo()
+        return None
+
+    def _set_fontInfo(self, fontInfo):
+        assert self._fontInfo is None
+        assert self._glyph is None
+        if fontInfo is not None:
+            fontInfo = weakref.ref(fontInfo)
+        self._fontInfo = fontInfo
+
+    fontInfo = property(_get_fontInfo, _set_fontInfo, doc="The :class:`Info` that this object belongs to (if it is a font info guideline). This should not be set externally.")
 
     def _get_layerSet(self):
@@ -73 +89 @@
         return glyph.layerSet
 
-    layerSet = property(_get_layerSet, doc="The :class:`LayerSet` that this object belongs to (if it isn't a font a guideline).")
+    layerSet = property(_get_layerSet, doc="The :class:`LayerSet` that this object belongs to (if it isn't a font info guideline).")
 
     def _get_layer(self):
@@ -81 +97 @@
         return glyph.layer
 
-    layer = property(_get_layer, doc="The :class:`Layer` that this object belongs to (if it isn't a font a guideline).")
+    layer = property(_get_layer, doc="The :class:`Layer` that this object belongs to (if it isn't a font info guideline).")
 
     def _get_glyph(self):
-        from defcon.objects.glyph import Glyph
-        parent = self.getParent()
-        if not isinstance(parent, Glyph):
-            return None
-        return parent
-
-    glyph = property(_get_glyph, doc="The :class:`Glyph` that this object belongs to (if it isn't a font a guideline).")
+        if self._glyph is not None:
+            return self._glyph()
+        return None
+
+    def _set_glyph(self, glyph):
+        assert self._fontInfo is None
+        assert self._glyph is None
+        if glyph is not None:
+            glyph = weakref.ref(glyph)
+        self._glyph = glyph
+
+    glyph = property(_get_glyph, _set_glyph, doc="The :class:`Glyph` that this object belongs to (if it isn't a font info guideline). This should not be set externally.")
+
+    # ----------
+    # Attributes
+    # ----------
+
+    # x
 
     def _get_x(self):
@@ -104 +131 @@
     x = property(_get_x, _set_x, doc="The x coordinate. Setting this will post *Guideline.XChanged* and *Guideline.Changed* notifications.")
 
+    # y
+
     def _get_y(self):
         return self.get("y")
@@ -116 +145 @@
     y = property(_get_y, _set_y, doc="The y coordinate. Setting this will post *Guideline.YChanged* and *Guideline.Changed* notifications.")
 
+    # angle
+
     def _get_angle(self):
         return self.get("angle")
@@ -128 +159 @@
     angle = property(_get_angle, _set_angle, doc="The angle. Setting this will post *Guideline.AngleChanged* and *Guideline.Changed* notifications.")
 
+    # name
+
     def _get_name(self):
         return self.get("name")
@@ -139 +172 @@
 
     name = property(_get_name, _set_name, doc="The name. Setting this will post *Guideline.NameChanged* and *Guideline.Changed* notifications.")
+
+    # color
 
     def _get_color(self):
@@ -156 +191 @@
     color = property(_get_color, _set_color, doc="The guideline's :class:`Color` object. When setting, the value can be a UFO color string, a sequence of (r, g, b, a) or a :class:`Color` object. Setting this posts *Guideline.ColorChanged* and *Guideline.Changed* notifications.")
 
-    # -------
-    # Methods
-    # -------
+    # ----------
+    # Identifier
+    # ----------
 
     def _get_identifiers(self):
@@ -164 +199 @@
         parent = self.glyph
         if parent is None:
-            parent = self.info
+            parent = self.fontInfo
         if parent is not None:
             identifiers = parent.identifiers
@@ -203 +238 @@
         self.identifier = identifier
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Guideline, self).endSelfNotificationObservation()
+        self._fontInfo = None
+        self._glyph = None
+
 
 def _test():
@@ -267 +311 @@
     False
 
-    >>> g = Guideline(dict(x=1, y=2, angle=3, name="4", identifier="5", color="1,1,1,1"))
+    >>> g = Guideline(guidelineDict=dict(x=1, y=2, angle=3, name="4", identifier="5", color="1,1,1,1"))
     >>> g.x, g.y, g.angle, g.name, g.identifier, g.color
     (1, 2, 3, '4', '5', '1,1,1,1')

packages/defcon/branches/ufo3/Lib/defcon/objects/image.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseDictObject
 from defcon.objects.color import Color
@@ -36 +37 @@
     representationFactories = {}
 
-    def __init__(self, imageDict=None):
+    def __init__(self, glyph=None, imageDict=None):
+        self._glyph = None
+        self.glyph = glyph
         super(Image, self).__init__()
+        self.beginSelfNotificationObservation()
         self["fileName"] = None
         self["color"] = None
@@ -47 +51 @@
         self._dirty = False
 
-    # ----------
-    # Properties
-    # ----------
-
-    # parents
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.glyph
 
     def _get_font(self):
@@ -78 +83 @@
 
     def _get_glyph(self):
-        return self.getParent()
-
-    glyph = property(_get_glyph, doc="The :class:`Glyph` that this image belongs to.")
+        if self._glyph is None:
+            return None
+        return self._glyph()
+
+    def _set_glyph(self, glyph):
+        assert self._glyph is None
+        if glyph is not None:
+            glyph = weakref.ref(glyph)
+        self._glyph = glyph
+
+    glyph = property(_get_glyph, _set_glyph, doc="The :class:`Glyph` that this image belongs to. This should not be set externally.")
+
+    # ----------
+    # Attributes
+    # ----------
+
+    # file name
 
     def _get_fileName(self):
@@ -93 +112 @@
 
     fileName = property(_get_fileName, _set_fileName, doc="The file name the image. Setting this will posts *Image.Changed* and *Image.FileNameChanged* notifications.")
+
+    # transformation
 
     def _get_transformation(self):
@@ -117 +138 @@
     transformation = property(_get_transformation, _set_transformation, doc="The transformation matrix for the image. Setting this will posts *Image.Changed* and *Image.TransformationChanged* notifications.")
 
+    # color
+
     def _get_color(self):
         return self.get("color")
@@ -133 +156 @@
     color = property(_get_color, _set_color, doc="The image's :class:`Color` object. When setting, the value can be a UFO color string, a sequence of (r, g, b, a) or a :class:`Color` object. Setting this posts *Image.ColorChanged* and *Image.Changed* notifications.")
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Image, self).endSelfNotificationObservation()
+        self._glyph = None
+
 
 def _testAttributes():
@@ -160 +191 @@
     True
 
-    >>> i = Image(dict(fileName="foo.png", xScale="1", xyScale="2", yxScale="3", yScale="4", xOffset="5", yOffset="6", color="0,0,0,0"))
+    >>> i = Image(imageDict=dict(fileName="foo.png", xScale="1", xyScale="2", yxScale="3", yScale="4", xOffset="5", yOffset="6", color="0,0,0,0"))
     >>> i.fileName, i.transformation, i.color
     ('foo.png', ('1', '2', '3', '4', '5', '6'), '0,0,0,0')
@@ -187 +218 @@
     >>> font = Font(path)
     >>> glyph = font.layers[None]["A"]
-    >>> glyph.image = Image()
+    >>> glyph.image = glyph.instantiateImage()
     >>> glyph.image.color = "1,1,1,1"
     >>> glyph.image.fileName = "foo.png"

packages/defcon/branches/ufo3/Lib/defcon/objects/imageSet.py

@@ -1 +1 @@
 import os
 import hashlib
+import weakref
 from ufoLib import UFOReader, UFOLibError
 from defcon.objects.base import BaseObject
@@ -18 +19 @@
     Name
     ===========================
+    ImageSet.Changed
     ImageSet.FileNamesChanged
     ImageSet.ImageChanged
@@ -49 +51 @@
     """
 
+    changeNotificationName = "ImageSet.Changed"
     representationFactories = {}
 
-    def __init__(self, fileNames=None):
+    def __init__(self, font=None):
+        self._font = None
+        if font is not None:
+            self._font = weakref.ref(font)
         super(ImageSet, self).__init__()
+        self.beginSelfNotificationObservation()
         self._data = {}
         self._scheduledForDeletion = {}
 
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
+
     def _get_font(self):
-        return self.getParent()
+        if self._font is not None:
+            return self._font()
+        return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
+
+    # ----------
+    # File Names
+    # ----------
 
     def _get_fileNames(self):
@@ -126 +146 @@
         self.dirty = True
 
-    # ---------------
-    # File Management
-    # ---------------
+    # ----
+    # Save
+    # ----
 
     def getSaveProgressBarTickCount(self, formatVersion):
@@ -178 +198 @@
         self.dirty = False
 
+    # ---------------
+    # File Management
+    # ---------------
+
     def makeFileName(self, fileName):
         """
@@ -258 +282 @@
             image = self[fileName]
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(ImageSet, self).endSelfNotificationObservation()
+        self._font = None
+
 
 def _imageDict(data=None, dirty=False, digest=None, onDisk=True, onDiskModTime=None):

packages/defcon/branches/ufo3/Lib/defcon/objects/info.py

@@ -2 +2 @@
 # this file should not be edited by hand.
 
+import weakref
 from warnings import warn
 import ufoLib
@@ -31 +32 @@
     representationFactories = {}
 
-    def __init__(self, guidelineClass=None):
+    def __init__(self, font=None, guidelineClass=None):
+        if font is not None:
+            font = weakref.ref(font)
+        self._font = font
         super(Info, self).__init__()
+        self.beginSelfNotificationObservation()
         self._identifiers = set()
         if guidelineClass is None:
@@ -146 +151 @@
         self._year = None
 
+    def __del__(self):
+        super(Info, self).__del__()
+        self._guidelines = None
+
+    def getParent(self):
+        return self.font
+
 
     def _get_font(self):
-        return self.getParent()
+        if self._font is not None:
+            return self._font()
+        return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
@@ -2321 +2335 @@
     guidelines = property(_get_guidelines, _set_guidelines, doc="An ordered list of :class:`Guideline` objects stored in the info. Setting this will post a *Info.Changed* notification along with any notifications posted by the :py:meth:`Info.appendGuideline` and :py:meth:`Info.clearGuidelines` methods.")
 
-    def _setParentDataInGuideline(self, guideline):
-        guideline.setParent(self)
-        if self.dispatcher is not None:
-            guideline.addObserver(observer=self, methodName="_guidelineChanged", notification="Guideline.Changed")
-
-    def _removeParentDataInGuideline(self, guideline):
-        if self.dispatcher is not None:
-            guideline.removeObserver(observer=self, notification="Guideline.Changed")
-        guideline.setParent(None)
+    def instantiateGuideline(self, guidelineDict=None):
+        guideline = self._guidelineClass(
+            fontInfo=self,
+            guidelineDict=guidelineDict
+        )
+        return guideline
+
+    def beginSelfGuidelineNotificationObservation(self, guideline):
+        if guideline.dispatcher is None:
+            return
+        guideline.addObserver(observer=self, methodName="_guidelineChanged", notification="Guideline.Changed")
+
+    def endSelfGuidelineNotificationObservation(self, guideline):
+        if guideline.dispatcher is None:
+            return
+        guideline.endSelfNotificationObservation()
+        guideline.removeObserver(observer=self, notification="Guideline.Changed")
 
     def appendGuideline(self, guideline):
@@ -2355 +2377 @@
         assert guideline not in self._guidelines
         if not isinstance(guideline, self._guidelineClass):
-            guideline = self._guidelineClass(guideline)
-        if guideline.identifier is not None:
-            identifiers = self._identifiers
-            assert guideline.identifier not in identifiers
+            guideline = self.instantiateGuideline(guidelineDict=guideline)
+        assert guideline.fontInfo in (self, None), "This guideline belongs to another font."
+        if guideline.fontInfo is None:
+            assert guideline.glyph is None, "This guideline belongs to a glyph."
+        if guideline.fontInfo is None:
             if guideline.identifier is not None:
-                identifiers.add(guideline.identifier)
-        if guideline.info != self:
-            self._setParentDataInGuideline(guideline)
+                identifiers = self._identifiers
+                assert guideline.identifier not in identifiers
+                if guideline.identifier is not None:
+                    identifiers.add(guideline.identifier)
+            guideline.fontInfo = self
+            guideline.beginSelfNotificationObservation()
+        self.beginSelfGuidelineNotificationObservation(guideline)
         self._guidelines.insert(index, guideline)
         self.postNotification("Info.GuidelinesChanged")
@@ -2377 +2404 @@
             self._identifiers.remove(guideline.identifier)
         self._guidelines.remove(guideline)
-        self._removeParentDataInGuideline(guideline)
+        self.endSelfGuidelineNotificationObservation(guideline)
         self.postNotification("Info.GuidelinesChanged")
         self.dirty = True
@@ -2398 +2425 @@
         self.releaseHeldNotifications()
 
-    # ----------------------
-    # Notification Callbacks
-    # ----------------------
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        for guideline in self.guidelines:
+            self.endSelfGuidelinesNotificationObservation(guideline)
+        super(Info, self).endSelfNotificationObservation()
+        self._font = None
 
     def _guidelineChanged(self, notification):

packages/defcon/branches/ufo3/Lib/defcon/objects/kerning.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseDictObject
 
@@ -48 +49 @@
     representationFactories = {}
 
+    def __init__(self, font=None):
+        self._font = None
+        if font is not None:
+            self._font = weakref.ref(font)
+        super(Kerning, self).__init__()
+        self.beginSelfNotificationObservation()
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
+
     def _get_font(self):
-        return self.getParent()
+        if self._font is not None:
+            return self._font()
+        return None
 
     font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
 
+    # -------------
+    # Pair Handling
+    # -------------
+
     def get(self, pair, default=0):
         return super(Kerning, self).get(pair, default)
+
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Kerning, self).endSelfNotificationObservation()
+        self._font = None
 
 

packages/defcon/branches/ufo3/Lib/defcon/objects/layer.py

@@ -53 +53 @@
     representationFactories = {}
 
-    def __init__(self, glyphSet=None, libClass=None, unicodeDataClass=None,
+    def __init__(self, layerSet=None, glyphSet=None, libClass=None, unicodeDataClass=None,
                 guidelineClass=None, glyphClass=None,
-                glyphContourClass=None, glyphPointClass=None, glyphComponentClass=None, glyphAnchorClass=None):
+                glyphContourClass=None, glyphPointClass=None, glyphComponentClass=None, glyphAnchorClass=None, glyphImageClass=None):
+
+        if layerSet is not None:
+            layerSet = weakref.ref(layerSet)
+        self._layerSet = layerSet
         super(Layer, self).__init__()
+        self.beginSelfNotificationObservation()
 
         self._name = None
@@ -66 +71 @@
         if unicodeDataClass is None:
             unicodeDataClass = UnicodeData
-
         self._glyphClass = glyphClass
         self._glyphContourClass = glyphContourClass
@@ -72 +76 @@
         self._glyphComponentClass = glyphComponentClass
         self._glyphAnchorClass = glyphAnchorClass
+        self._glyphImageClass = glyphImageClass
         self._libClass = libClass
         self._guidelineClass = guidelineClass
-
-        self._dispatcher = None
+        self._unicodeDataClass = unicodeDataClass
+
         self._color = None
         self._lib = None
-        self._unicodeData = unicodeDataClass()
-        self._unicodeData.setParent(self)
+        self._unicodeData = self.instantiateUnicodeData()
+        self.beginSelfUnicodeDataNotificationObservation()
 
         self._directory = None
@@ -91 +96 @@
 
         if glyphSet is not None:
+            self._unicodeData.disableNotifications()
             self._keys = set(self._glyphSet.keys())
             cmap = {}
@@ -100 +106 @@
                         cmap[code] = [glyphName]
             self._unicodeData.update(cmap)
-
-    # -------------
-    # Dict Behavior
-    # -------------
-
-    def _instantiateGlyphObject(self):
+            self._unicodeData.enableNotifications()
+
+    def __del__(self):
+        super(Layer, self).__del__()
+        self._glyphs = None
+        self._lib = None
+        self._unicodeData = None
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.layerSet
+
+    def _get_font(self):
+        layerSet = self.layerSet
+        if layerSet is None:
+            return None
+        return layerSet.font
+
+    font = property(_get_font, doc="The :class:`Font` that this layer belongs to.")
+
+    def _get_layerSet(self):
+        if self._layerSet is None:
+            return None
+        return self._layerSet()
+
+    layerSet = property(_get_layerSet, doc="The :class:`LayerSet` that this layer belongs to.")
+
+    # --------------
+    # Glyph Creation
+    # --------------
+
+    def instantiateGlyphObject(self):
         glyph = self._glyphClass(
+            layer=self,
             contourClass=self._glyphContourClass,
             pointClass=self._glyphPointClass,
@@ -112 +148 @@
             anchorClass=self._glyphAnchorClass,
             guidelineClass=self._guidelineClass,
-            libClass=self._libClass
+            libClass=self._libClass,
+            imageClass=self._glyphImageClass
         )
         return glyph
 
-    def _loadGlyph(self, name):
+    def beginSelfGlyphNotificationObservation(self, glyph):
+        glyph.addObserver(observer=self, methodName="_glyphDirtyStateChange", notification="Glyph.Changed")
+        glyph.addObserver(observer=self, methodName="_glyphNameChange", notification="Glyph.NameChanged")
+        glyph.addObserver(observer=self, methodName="_glyphUnicodesChange", notification="Glyph.UnicodesChanged")
+
+    def endSelfGlyphNotificationObservation(self, glyph):
+        if glyph.dispatcher is None:
+            return
+        glyph.removeObserver(observer=self, notification="Glyph.Changed")
+        glyph.removeObserver(observer=self, notification="Glyph.NameChanged")
+        glyph.removeObserver(observer=self, notification="Glyph.UnicodesChanged")
+        glyph.endSelfNotificationObservation()
+
+    def loadGlyph(self, name):
+        """
+        Load a glyph from the glyph set. This should not be called
+        externally, but subclasses may overrode it for custom behavior.
+        """
         if self._glyphSet is None or not self._glyphSet.has_key(name):
             raise KeyError, "%s not in layer" % name
-        glyph = self._instantiateGlyphObject()
+        glyph = self.instantiateGlyphObject()
+        self.beginSelfGlyphNotificationObservation(glyph)
+        glyph.disableNotifications()
         pointPen = glyph.getPointPen()
         self._glyphSet.readGlyph(glyphName=name, glyphObject=glyph, pointPen=pointPen)
         glyph.dirty = False
+        glyph.enableNotifications()
         self._glyphs[name] = glyph
-        self._setParentDataInGlyph(glyph)
         self._stampGlyphDataState(glyph)
         return glyph
-
-    def _setParentDataInGlyph(self, glyph):
-        # the parent of a glyph is always the font, not the layer
-        font = self.font
-        if font is not None:
-            glyph.setParent(font)
-        glyph.layer = self
-        glyph.addObserver(observer=self, methodName="_glyphDirtyStateChange", notification="Glyph.Changed")
-        glyph.addObserver(observer=self, methodName="_glyphNameChange", notification="Glyph.NameChanged")
-        glyph.addObserver(observer=self, methodName="_glyphUnicodesChange", notification="Glyph.UnicodesChanged")
-
-    def _removeParentDataInGlyph(self, glyph):
-        glyph.removeObserver(observer=self, notification="Glyph.Changed")
-        glyph.removeObserver(observer=self, notification="Glyph.NameChanged")
-        glyph.removeObserver(observer=self, notification="Glyph.UnicodesChanged")
-        glyph.layer = None
-        glyph.setParent(None)
 
     def newGlyph(self, name):
@@ -155 +194 @@
         if name in self:
             self._unicodeData.removeGlyphData(name, self[name].unicodes)
-        glyph = self._instantiateGlyphObject()
+        glyph = self.instantiateGlyphObject()
+        self.beginSelfGlyphNotificationObservation(glyph)
+        glyph.disableNotifications()
         glyph.name = name
+        glyph.enableNotifications()
         self._glyphs[name] = glyph
-        self._setParentDataInGlyph(glyph)
         if name in self._scheduledForDeletion:
             del self._scheduledForDeletion[name]
@@ -194 +235 @@
         return dest
 
+    # -------------
+    # Dict Behavior
+    # -------------
+
     def __iter__(self):
         names = self.keys()
@@ -203 +248 @@
     def __getitem__(self, name):
         if name not in self._glyphs:
-            self._loadGlyph(name)
+            self.loadGlyph(name)
         return self._glyphs[name]
 
@@ -215 +260 @@
         if name in self._glyphs:
             glyph = self._glyphs.pop(name)
-            self._removeParentDataInGlyph(glyph)
+            self.endSelfGlyphNotificationObservation(glyph)
             dataOnDiskTimeStamp = glyph._dataOnDiskTimeStamp
             dataOnDisk = glyph._dataOnDisk
@@ -245 +290 @@
     # ----------
 
-    def _get_font(self):
-        layerSet = self.layerSet
-        if layerSet is None:
-            return None
-        return layerSet.font
-
-    font = property(_get_font, doc="The :class:`Font` that this layer belongs to.")
-
-    def _get_layerSet(self):
-        return self.getParent()
-
-    layerSet = property(_get_layerSet, doc="The :class:`LayerSet` that this layer belongs to.")
+    # name
 
     def _set_name(self, value):
@@ -270 +304 @@
 
     name = property(_get_name, _set_name, doc="The name of the layer. Setting this posts *Layer.NameChanged* and *Layer.Changed* notifications.")
+
+    # color
 
     def _get_color(self):
@@ -287 +323 @@
 
     color = property(_get_color, _set_color, doc="The layer's :class:`Color` object. When setting, the value can be a UFO color string, a sequence of (r, g, b, a) or a :class:`Color` object. Setting this posts *Layer.ColorChanged* and *Layer.Changed* notifications.")
+
+    # -------------
+    # Data Skimmers
+    # -------------
+
+    # outlines
 
     def _get_glyphsWithOutlines(self):
@@ -308 +350 @@
 
     glyphsWithOutlines = property(_get_glyphsWithOutlines, doc="A list of glyphs containing outlines.")
+
+    # component references
 
     def _get_componentReferences(self):
@@ -334 +378 @@
     componentReferences = property(_get_componentReferences, doc="A dict of describing the component relationships in the layer. The dictionary is of form ``{base glyph : [references]}``.")
 
+    # image references
+
     def _get_imageReferences(self):
         found = {}
@@ -357 +403 @@
     imageReferences = property(_get_imageReferences, doc="A dict of describing the image file references in the layer. The dictionary is of form ``{image file name : [references]}``.")
 
+    # bounds
+
     def _get_bounds(self):
         fontRect = None
@@ -370 +418 @@
 
     bounds = property(_get_bounds, doc="The bounds of all glyphs in the layer. This can be an expensive operation.")
+
+    # control point bounds
 
     def _get_controlPointBounds(self):
@@ -437 +487 @@
     # -----------
 
+    # lib
+
+    def instantiateLib(self):
+        lib = self._libClass(
+            layer=self
+        )
+        return lib
+
+    def beginSelfLibNotificationObservation(self):
+        self._lib.addObserver(observer=self, methodName="_libDirtyStateChange", notification="Lib.Changed")
+
+    def endSelfLibNotificationObservation(self):
+        if self._lib is None:
+            return
+        if self._lib.dispatcher is None:
+            return
+        self._lib.removeObserver(observer=self, notification="Lib.Changed")
+        self._lib.endSelfNotificationObservation()
+
     def _get_lib(self):
         if self._lib is None:
-            self._lib = self._libClass()
-            self._lib.setParent(self)
-            self._lib.addObserver(observer=self, methodName="_libDirtyStateChange", notification="Lib.Changed")
+            self._lib = self.instantiateLib()
+            self.beginSelfLibNotificationObservation()
         return self._lib
 
@@ -451 +519 @@
     lib = property(_get_lib, _set_lib, doc="The layer's :class:`Lib` object.")
 
+    # unicode data
+
+    def instantiateUnicodeData(self):
+        unicodeData = self._unicodeDataClass(
+            layer=self
+        )
+        return unicodeData
+
+    def beginSelfUnicodeDataNotificationObservation(self):
+        pass
+
+    def endSelfUnicodeDataNotificationObservation(self):
+        if self._unicodeData.dispatcher is None:
+            return
+        self._unicodeData.endSelfNotificationObservation()
+
     def _get_unicodeData(self):
         return self._unicodeData
@@ -456 +540 @@
     unicodeData = property(_get_unicodeData, doc="The layer's :class:`UnicodeData` object.")
 
-    # -------
-    # Methods
-    # -------
+    # ----
+    # Save
+    # ----
 
     def getSaveProgressBarTickCount(self, formatVersion):
@@ -566 +650 @@
         for glyphName in glyphNames:
             if glyphName not in self._glyphs:
-                self._loadGlyph(glyphName)
+                self.loadGlyph(glyphName)
             else:
                 glyph = self._glyphs[glyphName]
@@ -595 +679 @@
                 referenceChanges.add(reference)
 
-    # ----------------------
-    # Notification Callbacks
-    # ----------------------
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        for glyph in self._glyphs.values():
+            self.endSelfGlyphNotificationObservation(glyph)
+        self.endSelfLibNotificationObservation()
+        self.endSelfUnicodeDataNotificationObservation()
+        super(Layer, self).endSelfNotificationObservation()
+        self._layerSet = None
 
     def _glyphDirtyStateChange(self, notification):
@@ -853 +947 @@
     >>> glyph = layer['A']
     >>> del layer['A']
-    >>> glyph.getParent()
     >>> layer.dirty
     True

packages/defcon/branches/ufo3/Lib/defcon/objects/layerSet.py

@@ +1 @@
+import weakref
 from ufoLib import UFOReader
 from defcon.objects.base import BaseObject
@@ -38 +39 @@
     representationFactories = {}
 
-    def __init__(self, layerClass=None, libClass=None, unicodeDataClass=None, 
+    def __init__(self, font=None, layerClass=None, libClass=None, unicodeDataClass=None, 
             guidelineClass=None, glyphClass=None,
-            glyphContourClass=None, glyphPointClass=None, glyphComponentClass=None, glyphAnchorClass=None):
+            glyphContourClass=None, glyphPointClass=None, glyphComponentClass=None, glyphAnchorClass=None,
+            glyphImageClass=None):
+
+        if font is not None:
+            font = weakref.ref(font)
+        self._font = font
         super(LayerSet, self).__init__()
+        self.beginSelfNotificationObservation()
+
         if layerClass is None:
             layerClass = Layer
-
         self._layerClass = layerClass
         self._libClass = libClass
@@ -53 +60 @@
         self._glyphComponentClass = glyphComponentClass
         self._glyphAnchorClass = glyphAnchorClass
+        self._glyphImageClass = glyphImageClass
         self._guidelineClass = guidelineClass
 
@@ -61 +69 @@
         self._layerActionHistory = []
 
+    def __del__(self):
+        super(LayerSet, self).__del__()
+        self._layers = None
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.font
+
     def _get_font(self):
-        return self.getParent()
+        if self._font is None:
+            return None
+        return self._font()
 
     font = property(_get_font, doc="The :class:`Font` that this layer set belongs to.")
+
+    # -------------
+    # Default Layer
+    # -------------
 
     def _get_defaultLayerName(self):
@@ -92 +117 @@
     defaultLayer = property(_get_defaultLayer, _set_defaultLayer, doc="The default :class:`Layer` object. Setting this will post *LayerSet.DefaultLayerChanged* and *LayerSet.Changed* notifications.")
 
+    # -----------
+    # Layer Order
+    # -----------
+
     def _get_layerOrder(self):
         return list(self._layerOrder)
@@ -108 +137 @@
 
     # -------------
-    # Dict Behavior
+    # Layer Creation
     # -------------
 
-    def _instantiateLayerObject(self, glyphSet):
+    def instantiateLayer(self, glyphSet):
         layer = self._layerClass(
+            layerSet=self,
             glyphSet=glyphSet,
             libClass=self._libClass,
@@ -121 +151 @@
             glyphComponentClass=self._glyphComponentClass,
             glyphAnchorClass=self._glyphAnchorClass,
-            guidelineClass=self._guidelineClass
+            guidelineClass=self._guidelineClass,
+            glyphImageClass=self._glyphImageClass
         )
         return layer
 
-    def _setParentDataInLayer(self, layer):
-        layer.setParent(self)
+    def beginSelfLayerNotificationObservation(self, layer):
         layer.addObserver(observer=self, methodName="_layerDirtyStateChange", notification="Layer.Changed")
         layer.addObserver(observer=self, methodName="_layerNameChange", notification="Layer.NameChanged")
 
-    def _removeParentDataInLayer(self, layer):
+    def endSelfLayerNotificationObservation(self, layer):
+        if layer.dispatcher is None:
+            return
         layer.removeObserver(observer=self, notification="Layer.Changed")
         layer.removeObserver(observer=self, notification="Layer.NameChanged")
-        layer.setParent(None)
+        layer.endSelfNotificationObservation()
 
     def newLayer(self, name, glyphSet=None):
@@ -146 +178 @@
             raise KeyError("A layer named \"%s\" already exists." % name)
         assert name is not None
-        layer = self._instantiateLayerObject(glyphSet)
+        layer = self.instantiateLayer(glyphSet)
+        self.beginSelfLayerNotificationObservation(layer)
+        layer.disableNotifications()
         layer.name = name
-        self._setParentDataInLayer(layer)
         if glyphSet is None:
             layer.dirty = True
         else:
             glyphSet.readLayerInfo(layer)
+            layer.dirty = False
+        layer.enableNotifications()
         self._stampLayerInfoDataState(layer)
         self._layers[name] = layer
@@ -162 +197 @@
         return layer
 
+    # -------------
+    # Dict Behavior
+    # -------------
+
     def __iter__(self):
         names = self.layerOrder
@@ -180 +219 @@
             raise KeyError("%s not in layers" % name)
         self.postNotification("LayerSet.LayerWillBeDeleted", data=dict(name=name))
+        layer = self._layers[name]
+        self.endSelfLayerNotificationObservation(layer)
         del self._layers[name]
         self._layerOrder.remove(name)
@@ -195 +236 @@
         return name in self._layers
 
-    # -------
-    # Methods
-    # -------
+    # ----
+    # Save
+    # ----
 
     def getSaveProgressBarTickCount(self, formatVersion):
@@ -281 +322 @@
             self._layerActionHistory.append(dict(action="new", name=layer.name))
 
-    # ----------------------
-    # Notification Callbacks
-    # ----------------------
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        for layer in self_layers.values():
+            self.endSelfLayerNotificationObservation(layer)
+        super(LayerSet, self).endSelfNotificationObservation()
+        self._font = None
 
     def _layerDirtyStateChange(self, notification):

packages/defcon/branches/ufo3/Lib/defcon/objects/lib.py

@@ +1 @@
+import weakref
 from defcon.objects.base import BaseDictObject
 
@@ -47 +48 @@
     representationFactories = {}
 
-    # parents
+    def __init__(self, font=None, layer=None, glyph=None):
+        self._font = None
+        self._layer = None
+        self._glyph = None
+        if font is not None:
+            self.font = font
+        if layer is not None:
+            self.layer = layer
+        if glyph is not None:
+            self.glyph = glyph
+        super(Lib, self).__init__()
+        self.beginSelfNotificationObservation()
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        if self._font is not None:
+            return self.font
+        elif self._layer is not None:
+            return self.layer
+        elif self._glyph is not None:
+            return self.glyph
+        return None
 
     def _get_font(self):
-        from defcon.objects.glyph import Glyph
-        parent = self.getParent()
-        if isinstance(parent, Glyph):
-            return parent.font
-        return parent
+        if self._font is not None:
+            return self._font()
+        elif self._layer is not None:
+            return self.layer.font
+        elif self._glyph is not None:
+            return self.glyph.font
+        return None
 
-    font = property(_get_font, doc="The :class:`Font` that this object belongs to.")
+    def _set_font(self, font):
+        assert self._font is None
+        assert self._layer is None
+        assert self._glyph is None
+        if font is not None:
+            font = weakref.ref(font)
+        self._font = font
+
+    font = property(_get_font, _set_font, doc="The :class:`Font` that this object belongs to. This should not be set externally.")
 
     def _get_layerSet(self):
@@ -67 +102 @@
 
     def _get_layer(self):
-        glyph = self.glyph
-        if glyph is None:
-            return None
-        return glyph.layer
+        if self._layer is not None:
+            return self._layer()
+        elif self._glyph is not None:
+            return self.glyph.layer
+        return None
 
-    layer = property(_get_layer, doc="The :class:`Layer` that this object belongs to (if it isn't a font lib).")
+    def _set_layer(self, layer):
+        assert self._font is None
+        assert self._layer is None
+        assert self._glyph is None
+        if layer is not None:
+            layer = weakref.ref(layer)
+        self._layer = layer
+
+    layer = property(_get_layer, _set_layer, doc="The :class:`Layer` that this object belongs to (if it isn't a font lib). This should not be set externally.")
 
     def _get_glyph(self):
-        from defcon.objects.font import Font
-        parent = self.getParent()
-        if isinstance(parent, Font):
-            return None
-        return parent
+        if self._glyph is not None:
+            return self._glyph()
+        return None
 
-    glyph = property(_get_glyph, doc="The :class:`Glyph` that this object belongs to (if it isn't a font lib).")
+    def _set_glyph(self, glyph):
+        assert self._font is None
+        assert self._layer is None
+        assert self._glyph is None
+        if glyph is not None:
+            glyph = weakref.ref(glyph)
+        self._glyph = glyph
 
+    glyph = property(_get_glyph, _set_glyph, doc="The :class:`Glyph` that this object belongs to (if it isn't a font or layer lib). This should not be set externally.")
+
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(Lib, self).endSelfNotificationObservation()
+        self._font = None
+        self._layer = None
+        self._glyph =None
 
 

packages/defcon/branches/ufo3/Lib/defcon/objects/uniData.py

@@ +1 @@
+import weakref
 import unicodedata
 from fontTools.agl import AGL2UV
@@ -44 +45 @@
     representationFactories = {}
 
-    def __init__(self):
+    def __init__(self, layer=None):
+        self._layer = None
+        if layer is not None:
+            self._layer = weakref.ref(layer)
         super(UnicodeData, self).__init__()
+        self.beginSelfNotificationObservation()
         self._glyphNameToForcedUnicode = {}
         self._forcedUnicodeToGlyphName = {}
+
+    # --------------
+    # Parent Objects
+    # --------------
+
+    def getParent(self):
+        return self.layer
 
     def _get_font(self):
@@ -963 +975 @@
         return glyphNames
 
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        super(UnicodeData, self).endSelfNotificationObservation()
+        self._layer = None
+
 
 # -----

packages/defcon/branches/ufo3/Lib/defcon/pens/glyphObjectPointPen.py

@@ -8 +8 @@
 
     def beginPath(self, identifier=None, **kwargs):
-        self._contour = self._glyph.contourClass(pointClass=self._glyph.pointClass)
+        self._contour = self._glyph.instantiateContour()
+        self._contour.disableNotifications()
         self._contour.identifier = identifier
 
@@ -14 +15 @@
         self._contour.dirty = False
         self._glyph.appendContour(self._contour)
+        self._contour.enableNotifications()
         self._contour = None
 

packages/defcon/branches/ufo3/Lib/defcon/test/testAll.py

@@ -17 +17 @@
 from defcon.objects import imageSet
 from defcon.objects import image
+from defcon.objects import dataSet
 
 test = [
@@ -34 +35 @@
     groups,
     imageSet,
-    image
+    image,
+    dataSet
 ]
 

packages/defcon/branches/ufo3/tools/infoObjectGenerator.py

@@ -68 +68 @@
 print
 
+print "import weakref"
 print "from warnings import warn"
 print "import ufoLib"
@@ -102 +103 @@
 print
 
-print "    def __init__(self, guidelineClass=None):"
+print "    def __init__(self, font=None, guidelineClass=None):"
+print "        if font is not None:"
+print "            font = weakref.ref(font)"
+print "        self._font = font"
 print "        super(Info, self).__init__()"
+print "        self.beginSelfNotificationObservation()"
 print "        self._identifiers = set()"
 print "        if guidelineClass is None:"
 print "            guidelineClass = Guideline"
 print "        self._guidelineClass = guidelineClass"
-
 
 defaults = dict(
@@ -127 +131 @@
 print
 
+print "    def __del__(self):"
+print "        super(Info, self).__del__()"
+print "        self._guidelines = None"
+print
+
+print "    def getParent(self):"
+print "        return self.font"
+print
+
 print
 print "    def _get_font(self):"
-print "        return self.getParent()"
+print "        if self._font is not None:"
+print "            return self._font()"
+print "        return None"
 print
 print "    font = property(_get_font, doc=\"The :class:`Font` that this object belongs to.\")"
@@ -192 +207 @@
     guidelines = property(_get_guidelines, _set_guidelines, doc="An ordered list of :class:`Guideline` objects stored in the info. Setting this will post a *Info.Changed* notification along with any notifications posted by the :py:meth:`Info.appendGuideline` and :py:meth:`Info.clearGuidelines` methods.")
 
-    def _setParentDataInGuideline(self, guideline):
-        guideline.setParent(self)
-        if self.dispatcher is not None:
-            guideline.addObserver(observer=self, methodName="_guidelineChanged", notification="Guideline.Changed")
-
-    def _removeParentDataInGuideline(self, guideline):
-        if self.dispatcher is not None:
-            guideline.removeObserver(observer=self, notification="Guideline.Changed")
-        guideline.setParent(None)
+    def instantiateGuideline(self, guidelineDict=None):
+        guideline = self._guidelineClass(
+            fontInfo=self,
+            guidelineDict=guidelineDict
+        )
+        return guideline
+
+    def beginSelfGuidelineNotificationObservation(self, guideline):
+        if guideline.dispatcher is None:
+            return
+        guideline.addObserver(observer=self, methodName="_guidelineChanged", notification="Guideline.Changed")
+
+    def endSelfGuidelineNotificationObservation(self, guideline):
+        if guideline.dispatcher is None:
+            return
+        guideline.endSelfNotificationObservation()
+        guideline.removeObserver(observer=self, notification="Guideline.Changed")
 
     def appendGuideline(self, guideline):
@@ -226 +249 @@
         assert guideline not in self._guidelines
         if not isinstance(guideline, self._guidelineClass):
-            guideline = self._guidelineClass(guideline)
-        if guideline.identifier is not None:
-            identifiers = self._identifiers
-            assert guideline.identifier not in identifiers
+            guideline = self.instantiateGuideline(guidelineDict=guideline)
+        assert guideline.fontInfo in (self, None), "This guideline belongs to another font."
+        if guideline.fontInfo is None:
+            assert guideline.glyph is None, "This guideline belongs to a glyph."
+        if guideline.fontInfo is None:
             if guideline.identifier is not None:
-                identifiers.add(guideline.identifier)
-        if guideline.info != self:
-            self._setParentDataInGuideline(guideline)
+                identifiers = self._identifiers
+                assert guideline.identifier not in identifiers
+                if guideline.identifier is not None:
+                    identifiers.add(guideline.identifier)
+            guideline.fontInfo = self
+            guideline.beginSelfNotificationObservation()
+        self.beginSelfGuidelineNotificationObservation(guideline)
         self._guidelines.insert(index, guideline)
         self.postNotification("Info.GuidelinesChanged")
@@ -248 +276 @@
             self._identifiers.remove(guideline.identifier)
         self._guidelines.remove(guideline)
-        self._removeParentDataInGuideline(guideline)
+        self.endSelfGuidelineNotificationObservation(guideline)
         self.postNotification("Info.GuidelinesChanged")
         self.dirty = True
@@ -269 +297 @@
         self.releaseHeldNotifications()
 
-    # ----------------------
-    # Notification Callbacks
-    # ----------------------
+    # ------------------------
+    # Notification Observation
+    # ------------------------
+
+    def endSelfNotificationObservation(self):
+        if self.dispatcher is None:
+            return
+        for guideline in self.guidelines:
+            self.endSelfGuidelinesNotificationObservation(guideline)
+        super(Info, self).endSelfNotificationObservation()
+        self._font = None
 
     def _guidelineChanged(self, notification):