itself, meaning that other lists bound to the first list were not being
synced.

of a hack/workaround, that allows functions to be put on the callqueue, and
thus executed 'safely' (i.e. callbacks executed in the correct order).

messy. The entire listener/notification system needs refactoring.

because whynot. Also adjusted String.cast method to be less silly.

temporarily disabled.

collision with fslpy/notifier

bindable._callAllListeners function caches listeners.

bound methods, and functions.

to avoid circular refs.

__setitem__. Is now suppressed.

instances to which the target one is bound.

attribute listeners are notified. Notification is now implemented in the
bindable module, which uses a new feature of the callqueue to ensure
that listeners are notified in the correct order:

  1. Listeners of the source PV object
  2. Listeners of any bound PV objects
  3. Listeners triggered by changes to other properties made by any of
     the above.

prepare and call listeners. More changes to come (which will reveal the
reasons as to why these re-organisations are occurring).

immediately (i.e. not on the CallQueue). PropertyValue now also uses a
Listener class to organise value/attribute listeners and their
respective states. More changes to come.

elsewhere.

are now local to the function that uses them (e.g. matplotlib,
numpy). GUI related functionality is now loaded by the application code
explicitly calling the props.initGUI function, so that wx is not
implicitly imported.

keys (PropertyValueLists). I learnt a new and shitty thing today - if
you have two objects, and o1 == o2, then hash(o1) has to be equal to
hash(o2).

replace the entire list contents.

subsequently being GC'd.

weakrefs. Debugging rubbish is in code, need to do more testing  before
putting into master branch.

dequeue an enqueued function. PropertyValue.removeListener takes
advantage of this feature.

method. addListener fixes to syncable and widgets_list

used. This is because if weakrefs are used for lambda/inner functions,
they will be GC'd immediately.

instances, PV context (which are always HasProps instances), and
callback functions. This is so that a HasProps instance can be gc'd
even if a PV/instance data object still holds a reference to it.

There may be some additional work required in the bindable/syncable
modules ..

triggers enqueueing of list level listeners immediately. Previously,
list-level listeners were queued when the list-level post-notify
function was called (which could be at some arbitrary point in the
future).

were not being notified on choice update

synchronisation is guaranteed to occur before any notification, and
notification occurs in order.