root/tags/dabo-0.3.1/dEvents.py

import time
import dabo
from dabo.common import dObject
import dabo.ui as ui
import dabo.biz.dBizobj as dBizobj

class Event(dObject):
    """ Base class for Dabo events.
    
    Event objects are instantiated in self.raiseEvent(), and passed to all 
    callbacks registered with self.bindEvent().
    
    User code can define custom events by simply subclassing Event and then 
    using self.bindEvent() and self.raiseEvent() in your objects.
    """     
    def __init__(self, eventObject, uiEvent=None, *args, **kwargs):
        # Event objects get instantiated with every single event, so try
        # to keep code to a minimum here.
        
        # There isn't any superclass init code, so don't run it
        #super(Event, self).__init__()
        
        self._eventObject = eventObject
        self._uiEvent = uiEvent
        self._args = args
        self._kwargs = kwargs
        self._continue = True
        
        self._baseClass = Event
        
        self._insertEventData()
        
        if dabo.eventLogging:
            self._logEvent()
        
    
    def appliesToClass(eventClass, objectClass):
        """ Returns True if this event can be raised by the passed class.
        
        Stub: subclass events need to override with appropriate logic.
        """
        return False
    appliesToClass = classmethod(appliesToClass)
            
        
    def stop(self):
        """Stop the event from being handled by other handlers.
        
        This is an alternative to setting the Continue property to False.
        """
        self.Continue = False
        
        
    def _insertEventData(self):
        """ Place ui-specific stuff into the ui-agnostic EventData dictionary.
        """
        eventData = {}      
        nativeEvent = self._uiEvent
        kwargs = self._kwargs
        
        eventData["timestamp"] = time.localtime()

        # Add any keyword args passed:
        for key in kwargs.keys():
            eventData[key] = kwargs[key]

        # Add native event data:
        if nativeEvent is not None:
            # Each UI lib should implement getEventData()
            uiEventData = dabo.ui.getEventData(nativeEvent)
            
            for key in uiEventData.keys():
                eventData[key] = uiEventData[key]
                
        self._eventData = eventData             
                
            
    def _logEvent(self):
        """ Log the event if the event object's LogEvents property is set.
        """
        eventName = self.__class__.__name__
        
        try:
            logEvents = self._eventObject._getLogEvents()
        except AttributeError:
            logEvents = []
        noLogEvents = []
        
        if len(logEvents) > 0 and logEvents[0].lower() == "all":
            # If there are any events listed explicitly, those must not be
            # logged.
            noLogEvents = logEvents[1:]

        if eventName not in noLogEvents:        
            for logEventName in logEvents:
                if logEventName.lower() == "all" or logEventName == eventName:
                    dabo.infoLog.write("dEvent Fired: %s %s" % (self._eventObject.getAbsoluteName(), 
                        self.__class__.__name__,))
                    break

    def __getattr__(self, att):
        return getattr(self._uiEvent, att)

    def _getContinue(self):
        return self._continue
        
    def _setContinue(self, val):
        self._continue = bool(val)
        
    def _getEventObject(self):
        return self._eventObject
        
    def _setEventObject(self, obj):
        self._eventObject = obj
    
    def _getEventData(self):
        return self._eventData
        
    def _setEventData(self, dict):
        self._eventData = dict
    
    Continue = property(_getContinue, _setContinue, None,
        "Specifies whether the event is allowed to continue on to the next handler.")
        
    EventObject = property(_getEventObject, _setEventObject, None, 
        "References the object that emitted the event.")
        
    EventData = property(_getEventData, _setEventData, None,
        "Dictionary of data name/value pairs associated with the event.")
        

class DataEvent(Event):
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.biz.dBizobj)
    appliesToClass = classmethod(appliesToClass)
            
class KeyEvent(Event):
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
class MenuEvent(Event):
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, (dabo.ui.dMenu, dabo.ui.dMenuItem,
                                        dabo.ui.dMenuBar))
    appliesToClass = classmethod(appliesToClass)
    
class MouseEvent(Event):
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
class SashEvent(Event):
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dSplitter)
    appliesToClass = classmethod(appliesToClass)

    
class Activate(Event):
    """Occurs when the form or application becomes active."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, (dabo.dApp, dabo.ui.dForm, dabo.ui.dFormMain, dabo.ui.dDialog))
    appliesToClass = classmethod(appliesToClass)
    
class Close(Event):
    """Occurs when the user closes the form."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, (dabo.ui.dForm, dabo.ui.dFormMain, dabo.ui.dDialog))
    appliesToClass = classmethod(appliesToClass)
    
class Create(Event):
    """Occurs after the control or form is created."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
class Deactivate(Event):
    """Occurs when another form becomes active."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, (dabo.dApp, dabo.ui.dForm, dabo.ui.dFormMain, dabo.ui.dDialog))
    appliesToClass = classmethod(appliesToClass)
    
class Destroy(Event):
    """Occurs when the control or form is destroyed."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
class Hit(Event):
    """Occurs with the control's default event (button click, listbox pick, checkbox, etc.)"""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, (ui.dBitmapButton, ui.dButton, ui.dCheckBox,
            ui.dDropdownList, ui.dEditBox, ui.dListBox,
            ui.dRadioGroup, ui.dSlider, ui.dSpinner, ui.dTextBox,
            ui.dTimer, ui.dToggleButton, ui.dMenuItem))
    appliesToClass = classmethod(appliesToClass)
    
class Idle(Event):
    """Occurs when the event loop has no active events to process.
    
    This is a good place to put redraw or other such UI-intensive code, so that it 
    will only run when the application is otherwise not busy doing other (more 
    important) things.
    """
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
class ItemPicked(Event):
    """Occurs when an item was picked from a picklist."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, (dabo.ui.dDataNavForm, dabo.ui.dFormDataNav))
    appliesToClass = classmethod(appliesToClass)
    
class GotFocus(Event):
    """Occurs when the control gets the focus."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)

    
class KeyChar(KeyEvent):
    """Occurs when a key is depressed and released on the focused control or form."""
    pass
    
class KeyDown(KeyEvent):
    """Occurs when any key is depressed on the focused control or form."""
    pass
    
class KeyUp(KeyEvent):
    """Occurs when any key is released on the focused control or form."""
    pass

    
class LostFocus(Event):
    """Occurs when the control loses the focus."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)


class LostFocus(Event):
    """Occurs when the control loses the focus."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)


class MenuHighlight(MenuEvent):
    """Occurs when a menu item is highlighted."""
    pass


class Move(Event):
    """Occurs when the control's position changes."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
        
class MouseEnter(MouseEvent):
    """Occurs when the mouse pointer enters the form or control."""
    pass
    
class MouseLeave(MouseEvent): 
    """Occurs when the mouse pointer leaves the form or control."""
    pass
    
class MouseLeftClick(MouseEvent):
    """Occurs when the mouse's left button is depressed and released on the control."""
    pass
    
class MouseLeftDoubleClick(MouseEvent):
    """Occurs when the mouse's left button is double-clicked on the control."""
    pass
    
class MouseMove(MouseEvent):
    """Occurs when the mouse moves in the control."""
    
class MouseRightClick(MouseEvent):
    """Occurs when the mouse mouse's right button is depressed and released on the control."""
    pass
    
class MouseLeftDown(MouseEvent):
    """Occurs when the mouse's left button is depressed on the control."""
    pass
    
class MouseLeftUp(MouseEvent):
    """Occurs when the mouse's left button is released on the control."""
    pass
    
class MouseRightDown(MouseEvent):
    """Occurs when the mouse's right button is depressed on the control."""
    pass
    
class MouseRightUp(MouseEvent):
    """Occurs when the mouse's right button is released on the control."""
    pass

    
class Paint(Event):
    """Occurs when it is time to paint the control."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
class PageEnter(Event):
    """Occurs when the page becomes the active page."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPage)
    appliesToClass = classmethod(appliesToClass)
    
class PageLeave(Event):
    """Occurs when a different page becomes active."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPage)
    appliesToClass = classmethod(appliesToClass)


class Resize(Event):
    """Occurs when the control or form is resized."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dPemMixin)
    appliesToClass = classmethod(appliesToClass)
    
        
class RowNumChanged(DataEvent):
    """Occurs when the cursor's row number has changed."""
    pass

    
class SashDoubleClick(SashEvent):
    """Occurs when a user double-clicks on the sash of a splitter window."""
    pass

    
class ValueChanged(Event):
    """Occurs when the control's value has changed, whether programmatically or interactively."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dDataControlMixin.dDataControlMixin)
    appliesToClass = classmethod(appliesToClass)
    
class ValueRefresh(Event):
    """Occurs when the form wants the controls to refresh their values."""
    def appliesToClass(eventClass, objectClass):
        return issubclass(objectClass, dabo.ui.dForm)
    appliesToClass = classmethod(appliesToClass)