root/trunk/dabo/dObject.py

# -*- coding: utf-8 -*-
import string
import types
import new
import dabo
from dabo.lib.propertyHelperMixin import PropertyHelperMixin
from dabo.lib.doDefaultMixin import DoDefaultMixin
from dabo.lib.eventMixin import EventMixin
from dabo.lib.autosuper import autosuper
from dabo.dPref import dPref
from dabo.dLocalize import _

class Dummy(object):
    # Much thanks to Robin Dunn for a workaround to a nasty problem that reared
    # its head starting with wxPython 2.7, when we had to switch around the order
    # of base classes so that wxPython's properties didn't trump Dabo's. Neither
    # of us really understand what is happening, but it is at the Python level,
    # and suffice it to say making dObject first inherit from this Dummy class
    # fixes the issue, which was ultimately caused by autosuper's __slots__.
    pass

class dObject(Dummy, autosuper, DoDefaultMixin, PropertyHelperMixin, 
        EventMixin):
    """ The basic ancestor of all dabo objects."""
    # Subclasses can set these to False, in which case they are responsible
    # for maintaining the following call order:
    #   self._beforeInit()
    #   # optional stuff
    #   super().__init__()
    #   # optional stuff
    #   self._afterInit()
    # or, not calling super() at all, but remember to call _initProperties() and
    # the call to setProperties() at the end!
    _call_beforeInit, _call_afterInit, _call_initProperties = True, True, True

    def __init__(self, properties=None, attProperties=None, *args, **kwargs):
        if not hasattr(self, "_properties"):
            self._properties = {}
        if self._call_beforeInit:
            self._beforeInit()
        if self._call_initProperties:
            self._initProperties()

        # Now that user code has had an opportunity to set the properties, we can 
        # see if there are properties sent to the constructor which will augment 
        # or override the properties set in beforeInit().
        
        # Some classes that are not inherited from the ui-layer PEM mixin classes
        # can have attProperties passed. Since these are all passed as strings, we
        # need to convert them to their proper type and add them to the properties
        # dict.
        if properties is None:
            properties = {}
        if attProperties:
            for prop, val in attProperties.items():
                if prop in ("designerClass", ):
                    continue
                if prop in properties:
                    # The properties value has precedence, so ignore.
                    continue
                typ = type(getattr(self, prop))
                if not issubclass(typ, basestring):
                    try:
                        val = typ(val)
                    except ValueError, e:
                        # Sometimes int values can be stored as floats
                        if typ in (int, long):
                            val = float(val)
                        else:
                            raise e
                properties[prop] = val

        # The keyword properties can come from either, both, or none of:
        #    + the properties dict
        #    + the kwargs dict
        # Get them sanitized into one dict:
        if properties is not None:
            # Override the class values
            for k,v in properties.items():
                self._properties[k] = v
        properties = self._extractKeywordProperties(kwargs, self._properties)
        if kwargs:
            # Some kwargs haven't been handled.
            bad = ", ".join(["'%s'" % kk for kk in kwargs.keys()])
            raise TypeError, ("Invalid keyword arguments passed to %s: %s") % (self.__repr__(), bad)

        if self._call_afterInit:
            self._afterInit()
        self.setProperties(properties)
        
        DoDefaultMixin.__init__(self)       
        PropertyHelperMixin.__init__(self)      
        EventMixin.__init__(self)       


    def __repr__(self):
        bc = self.BaseClass
        if bc is None:
            bc = self.__class__
        strval = "%s" % bc
        classname = strval.split("'")[1]
        classparts = classname.split(".")
        if ".ui.ui" in classname:
            # Simplify the different UI toolkits
            pos = classparts.index("ui")
            classparts.pop(pos+1)
        # Remove the duplicate class name that happens
        # when the class name is the same as the file.
        while (len(classparts) > 1) and (classparts[-1] == classparts[-2]):
            classparts.pop()
        classname = ".".join(classparts)

        try:
            nm = self.Name
        except AttributeError:
            nm = ""

        regid = getattr(self, "RegID", "")
        if regid:
            nm = regid

        if (not nm) or (nm == "?"):
            # No name; use module.classname
            nm = "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
        _id = self._getID()
        return "<%(nm)s (baseclass %(classname)s, id:%(_id)s)>" % locals()


    def _getID(self):
        """Defaults to the Python id() function. Objects in sub-modules, such as the various
        UI toolkits, can override to substitute something more relevant to them.
        """
        return id(self)


    def beforeInit(self, *args, **kwargs):
        """ Subclass hook. Called before the object is fully instantiated.
        Usually, user code should override afterInit() instead, but there may be
        cases where you need to set an attribute before the init stage is fully
        underway.
        """
        pass
        

    def afterInit(self):
        """ Subclass hook. Called after the object's __init__ has run fully.
        Subclasses should place their __init__ code here in this hook, instead of 
        overriding __init__ directly, to avoid conflicting with base Dabo behavior.
        """
        pass
        

    def initProperties(self):
        """ Hook for subclasses. User subclasses should set properties 
        here, such as:
            self.Name = "MyTextBox"
            self.BackColor = (192,192,192)
        """
        pass

        
    def initEvents(self):
        """ Hook for subclasses. User code should do custom event binding 
        here, such as:
            self.bindEvent(dEvents.GotFocus, self.customGotFocusHandler)
        """
        pass
        
            
    def _beforeInit(self):
        """Framework subclass hook."""
        self.beforeInit()


    def _initProperties(self):
        """Framework subclass hook."""
        self.initProperties()


    def _afterInit(self):
        """Framework subclass hook."""
        self.afterInit()


    def getAbsoluteName(self):
        """Return the fully qualified name of the object."""
        names = [self.Name, ]
        object = self
        while True:
            try:
                parent = object.Parent
            except AttributeError:
                # Parent not necessarily defined
                parent = None
            if parent:
                try:
                    name = parent.Name
                except AttributeError:
                    name = "?"
                names.append(name)
                object = parent
            else:
                break
        names.reverse()
        return ".".join(names)

        
    def getMethodList(cls, refresh=False):
        """Return the list of (Dabo) methods for this class or instance."""
        try:
            methodList = cls.__methodList
        except AttributeError:
            methodList = None

        if refresh:
            methodList = None

        if isinstance(methodList, list):
            ## A prior call has already generated the methodList
            return methodList

        methodList = []
        for c in cls.__mro__:
            for item in dir(c):
                if item[0] in string.lowercase:
                    if c.__dict__.has_key(item):
                        if type(c.__dict__[item]) in (types.MethodType, types.FunctionType):
                            if methodList.count(item) == 0:
                                methodList.append(item)
        methodList.sort()
        cls.__methodList = methodList
        return methodList
    getMethodList = classmethod(getMethodList)
    
    
    def _addCodeAsMethod(self, cd):
        """This method takes a dictionary containing method names as
        keys, and the method code as the corresponding values, compiles
        it, and adds the methods to this object. If the method name begins 
        with 'on', and dabo.autoBindEvents is True, an event binding will be 
        made just as with normal auto-binding. If the code cannot be 
        compiled successfully, an error message will be added
        to the Dabo ErrorLog, and the method will not be added.
        """
        cls = self.__class__
        for nm, code in cd.items():
            try:
                code = code.replace("\n]", "]")
                compCode = compile(code, "", "exec")
            except SyntaxError, e:
                dabo.errorLog.write(_("Method '%s' of object '%s' has the following error: %s")
                        % (nm, self.Name, e))
                continue
            # OK, we have the compiled code. Add it to the class definition.
            # NOTE: if the method name and the name in the 'def' statement
            # are not the same, the results are undefined, and will probably crash.
            nmSpace = {}
            exec compCode in nmSpace
            mthd = nmSpace[nm]
            exec "self.%s = %s.__get__(self)" % (nm, nm)
            newMethod = new.instancemethod(mthd, self)
            setattr(self, nm, newMethod)
            

    # Property definitions begin here
    def _getApplication(self):
        # dApp saves a ref to itself inside the dabo module object.
        return dabo.dAppRef
    
    
    def _getBaseClass(self):
        # Every Dabo baseclass must set self._baseClass explicitly, to itself. For instance:
        #   class dBackend(object)
        #       def __init__(self):
        #           self._baseClass = dBackend
        # IOW, BaseClass isn't the actual Python base class of the object, but the Dabo-
        # relative base class.
        try:
            return self._baseClass
        except AttributeError:
            return None

        
    def _getBasePrefKey(self):
        try:
            ret = self._basePrefKey
        except AttributeError:
            ret = self._basePrefKey = ""
        return ret

    def _setBasePrefKey(self, val):
        if not isinstance(val, types.StringTypes):
            raise TypeError, 'BasePrefKey must be a string.'
        self._basePrefKey = val
        pm = self.PreferenceManager
        if pm is not None:
            if not pm._key:
                pm._key = val


    def _getClass(self):
        return self.__class__


    def _getLogEvents(self):
        # This is expensive, as it is semi-recursive upwards in the containership 
        # until some parent object finally reports a LogEvents property. In normal 
        # use, this will be the Application object.
        try:
            le = self._logEvents
        except AttributeError:
            # Try to get the value from the parent object, or the Application if
            # no Parent.
            if self.Parent is not None:
                parent = self.Parent
            else:
                if self == self.Application:
                    parent = None
                else:
                    parent = self.Application
            try:
                le = parent.LogEvents
            except AttributeError:
                le = []
        return le
            
    def _setLogEvents(self, val):
        self._logEvents = list(val)

        
    def _getName(self):
        try:
            return self._name
        except AttributeError:
            return "?"
    
    def _setName(self, val):
        if not isinstance(val, types.StringTypes):
            raise TypeError, 'Name must be a string.'
        if not len(val.split()) == 1:
            raise KeyError, 'Name must not contain any spaces'
        self._name = val
        
        
    def _getParent(self):
        # Subclasses must override as necessary. Parent/child relationships 
        # don't exist for all nonvisual objects, and implementation of parent/child
        # relationships will vary. This implementation is the simplest.
        try:
            return self._parent
        except AttributeError:
            return None
        
    def _setParent(self, obj):
        # Subclasses must override as necessary.
        self._parent = obj


    def _getPreferenceManager(self):
        try:
            ret = self._preferenceManager
        except AttributeError:
            ret = None
            if self.Application is not self:
                try:
                    ret = self._preferenceManager = self.Application.PreferenceManager
                except AttributeError: pass
            if ret is None:
                ret = self._preferenceManager = dPref(key=self.BasePrefKey)
        return ret

    def _setPreferenceManager(self, val):
        if not isinstance(val, dPref):
            raise TypeError, 'PreferenceManager must be a dPref object'
        self._preferenceManager = val
    

    Application = property(_getApplication, None, None, 
            _("Read-only object reference to the Dabo Application object.  (dApp)."))
    
    BaseClass = property(_getBaseClass, None, None, 
            _("The base Dabo class of the object. Read-only.  (class)"))
    
    BasePrefKey = property(_getBasePrefKey, _setBasePrefKey, None,
            _("Base key used when saving/restoring preferences  (str)"))
    
    Class = property(_getClass, None, None,
            _("The class the object is based on. Read-only.  (class)"))
    
    LogEvents = property(_getLogEvents, _setLogEvents, None, 
            _("""Specifies which events to log.  (list of strings)
            
            If the first element is 'All', all events except the following listed events 
            will be logged. 
            Event logging is resource-intensive, so in addition to setting this LogEvents
            property, you also need to make the following call:
            >>> dabo.eventLogging = True
            """))
                    
    Name = property(_getName, _setName, None, 
            _("The name of the object.  (str)"))
    
    Parent = property(_getParent, _setParent, None, 
            _("The containing object.  (obj)"))
    
    PreferenceManager = property(_getPreferenceManager, _setPreferenceManager, None,
            _("Reference to the Preference Management object  (dPref)"))
    

if __name__ == "__main__":
    d = dObject()
    print d.Application
    app = dabo.dApp()
    print d.Application

    print _("Testing doDefault():")
    class TestBase(list, dObject):
        # No myMethod here
        pass

    class MyTest1(TestBase):
        def myMethod(self):
            print _("MyTest1.myMethod called.")
            MyTest1.doDefault()
        
    class MyTest2(MyTest1): pass

    class MyTest(MyTest2):
        def myMethod(self):
            print _("MyTest.myMethod called.")
            MyTest.doDefault()

    print _("Test 1: simple test:")         
    t = MyTest()
    t.myMethod()

    print _("\nTest 2: diamond inheritence test:")

    class A(dObject):
        def meth(self, arg):
            print self.__class__
            arg.append("A")

    class B(A):
        def meth(self, arg):
            print self.__class__
            arg.append("B")
            B.doDefault(arg)

    class C(A):
        def meth(self, arg):
            print self.__class__
            arg.append("C")
            C.doDefault(arg)

    class D(B,C):
        def meth(self, arg):
            print self.__class__
            arg.append("D")
            D.doDefault(arg)

    t = D()
    testList = []
    t.meth(testList)
    print testList

    print _("\n\nTesting super():")
    class TestBase(list, dObject):
        # No myMethod here
        pass

    class MyTest1(TestBase):
        def myMethod(self):
            print _("MyTest1.myMethod called.")
            self.super()
        
    class MyTest2(MyTest1): pass

    class MyTest(MyTest2):
        def myMethod(self):
            print _("MyTest.myMethod called.")
            self.super()

    print _("Test 1: simple test:")         
    t = MyTest()
    t.myMethod()

    print _("\nTest 2: diamond inheritence test:")

    class A(dObject):
        def meth(self, arg):
            print self.__class__
            arg.append("A")

    class B(A):
        def meth(self, arg):
            print self.__class__
            arg.append("B")
            self.super(arg)

    class C(A):
        def meth(self, arg):
            print self.__class__
            arg.append("C")
            self.super(arg)

    class D(B,C):
        def meth(self, arg):
            print self.__class__
            arg.append("D")
            self.super(arg)

    t = D()
    testList = []
    t.meth(testList)
    print testList