def OnPathChange(self, path):
     assert doout(value)
     # FIXME: Should this check if the input is a real valid dir?
     # Alternative the BindingString can be marked as read-only
     # (need to develop) and only settable via a direct call to
     # __set__
     self.widget.SetPath(path)

    def __init__(self, name, group=None, **kwargs):
        self.group = group
        if group is not None:
            self._groups[group].append(self)

        assert doout(name, kwargs)
        BindingWidget.__init__(self, name, **kwargs)

def load_package(cls, package, reloading, results):
    for modname in dir(package):
        if modname.startswith('_'):
            continue

        mod = getattr(package, modname)
        if not isinstance(mod, types.ModuleType):
            continue

        doout('checking', modname)
        try:
            reload(mod)
        except ImportError, e:
            results.append(e)
        except Exception, e:
            results.append(e)

    def OnValueChange(self, value):
        assert doout(value)
        newvalue = min(self.max, max(self.min, value))

        if value != newvalue:
            self._set('value', newvalue)

        self.widget.SetValue(newvalue)

    def rd(self, bindname, obj):
        assert doout()
        if not self.doconfig:
            return self.getdefault(obj)

        rdfunc = getattr(self.config, self.rdattr)
        value = rdfunc(bindname, self.getdefault(obj))
        self.config.Flush()
        return value

    def OnItemsChange(self, value):
        assert doout(value)
        # FIXME: A more complex policy is needed to ensure that if
        # string x is selected it remains selected after we clear the
        # combobox or if for example the previous
        self.widget.Clear()
        self.widget.SetItems(value)

        # make sure it's selected if possible
        self.stringselection = self.stringselection

 def OnStringSelectionChange(self, value):
     assert doout(value)
     retval = self.widget.SetStringSelection(value)
     # The variable must contain the reality and not what was sent,
     # because the operation may fail if the "value" is not in the
     # list of items (use _set to avoid an infinite loop)
     self._set('stringselection', self.widget.GetStringSelection())
     # No event was emitted ... manual selection update
     self._set('selection', self.widget.GetSelection())
     return retval

    def OnRadioButton(self, event):
        assert doout(event)
        event.Skip()
        # self.value = event.GetInt()
        # This avoids a callback to
        value = event.GetInt()
        self._set('value', value)

        # Manage the group
        for radio in self._groups[self.group]:
            if radio != self:
                radio._set('value', not value)

    def findwidget(self):
        assert doout()
        if not self.wname:
            self.wname = 'm_' + self.wprefix.lower() + self.name.lower()

        for attr in dir(self.owner):
            if attr.lower() == self.wname:
                self.widget = getattr(self.owner, attr, None)
                break

        assert getattr(self, 'widget', None),\
            'Failed to acquire widget - ' + self.wname

 def addcallback(self, callback):
     assert doout(callback)
     # im_self ensures if the object is not there it will not be found
     bindname = self.makebindname(callback.im_self)
     try:
         self.callbacks[bindname][callback.im_self] = callback
     except KeyError:
         pass
     else:
         # Tell the callback the current value
         # (it will for example check/uncheck a checkbox)
         # callback(self.__get__(self, self.__class__))
         callback(self.__get__(callback.im_self,
                               callback.im_self.__class__))

def load_submodule(cls, submod, reloading, results):
    load_methods(cls, submod, reloading)

    if hasattr(submod, '__package__'):
        doout('submod.__package_', submod.__package__)
        doout('submod.__name__', submod.__name__)
        if submod.__package__ and submod.__package__ == submod.__name__:
            doout('loading package', submod.__name__)
            load_package(cls, submod, reloading, results)

    def __get__(self, obj, cls=None):
        assert doout(obj, cls)
        if obj is None:
            # this prevents early auto-setting if for example a
            # decorator does a "dir" of the class attributes even
            # before the registry object has been created and allows
            # access to the object itself
            return self

        objbindname = self.makebindname(obj)

        try:
            return self.ncache[objbindname]
        except KeyError:
            value = self.rd(objbindname, obj)
            value = self.postrd(value, obj)
            self.ncache[objbindname] = value
            return value

    def __set__(self, obj, value, cb=True):
        assert doout(obj, value)
        objbindname = self.makebindname(obj)
        try:
            if self.ncache[objbindname] == value:
                return
        except KeyError:
            pass

        self.ncache[objbindname] = value
        wrvalue = self.prewr(value)
        self.wr(objbindname, wrvalue)
        # self.config.Flush()

        # Report to any callback
        # if obj is not None:
        if cb:
            map(lambda callback: callback(value),
                self.callbacks[objbindname].itervalues())

    def OnCheckBox(self, event):
        assert doout(event)
        event.Skip()
        # self.value = event.GetInt()
        # This avoids a callback to
        value = event.GetInt()

        if self.group is not None:
            if not value:  # in a group and being set to False ... no
                self.widget.SetValue(True)
                if not self.value:  # check the value
                    self._set('value', True)

            else:
                self._set('value', True)
                # in a grou and being set to True
                for checkbox in self._groups[self.group]:
                    if checkbox != self:
                        checkbox._set('value', False)
                        checkbox.widget.SetValue(False)
            return

        # Not in a group
        self._set('value', value)

 def OnKillFocus(self, event):
     assert doout(event)
     event.Skip()
     self._set('value', self.widget.GetValue())

 def OnFilePickerChanged(self, event):
     assert doout(event)
     event.Skip()
     # value can also be gotten from self.widget
     self._set('path', event.GetPath())

 def OnSelectionChange(self, value):
     assert doout(value)
     self.widget.SetSelection(value)

 def OnTextChange(self, value):
     assert doout(value)
     self.widget.SetValue(value)

 def OnTextEnter(self, event):
     assert doout(event)
     event.Skip()
     self.value = event.GetString()
     self.items.append(self.value)
     self.stringselection = self.value

 def OnText(self, event):
     assert doout(event)
     event.Skip()
     self.value = event.GetString()