Panda3D

- Main Page
- Packages
- Classes

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Public Attributes | Static Public Attributes

# Messenger Class Reference

List of all members.

## Public Member Functions
def | __init__
def | __repr__
def | accept
def | clear
def | detailedRepr
def | find
def | findAll
def | getAllAccepting
def | getEvents
def | ignore
def | ignoreAll
def | isAccepting
def | isEmpty
def | isIgnoring
def | quiet
def | replaceMethod
def | send
def | toggleVerbose
def | unquiet
def | unwatch
def | watch
def | whoAccepts
## Public Attributes
| lock
| quieting
## Static Public Attributes
tuple | notify = DirectNotifyGlobal.directNotify.newCategory("Messenger")

## Constructor & Destructor Documentation

def __init__ | ( |  | self | ) |

    One is keyed off the event name. It has the following structure:
        {event1: {object1: [method, extraArgs, persistent],
           object2: [method, extraArgs, persistent]},
         event2: {object1: [method, extraArgs, persistent],
           object2: [method, extraArgs, persistent]}}

    This dictionary allow for efficient callbacks when the messenger
    hears an event.

    A second dictionary remembers which objects are accepting which
    events. This allows for efficient ignoreAll commands.

    Or, for an example with more real data:
        {'mouseDown': {avatar: [avatar.jump, [2.0], 1]}}

## Member Function Documentation

def __repr__ | ( |  | self | ) |

    Compact version of event, acceptor pairs

def accept | ( |  | self,
|  |  | event,
|  |  | object,
|  |  | method,
|  |  | extraArgs = `[]`,
|  |  | persistent = `1`
| ) |  |

    accept(self, string, DirectObject, Function, List, Boolean)

    Make this object accept this event. When the event is
    sent (using Messenger.send or from C++), method will be executed,
    optionally passing in extraArgs.

    If the persistent flag is set, it will continue to respond
    to this event, otherwise it will respond only once.

def clear | ( |  | self | ) |

    Start fresh with a clear dict

def detailedRepr | ( |  | self | ) |

    Print out the table in a detailed readable format

def find | ( |  | self,
|  |  | needle
| ) |  |

    return a matching event (needle) if found (in haystack).
    This is primarily a debugging tool.

def findAll | ( |  | self,
|  |  | needle,
|  |  | limit = `None`
| ) |  |

    return a dict of events (needle) if found (in haystack).
    limit may be None or an integer (e.g. 1).
    This is primarily a debugging tool.

def getAllAccepting | ( |  | self,
|  |  | object
| ) |  |

    Returns the list of all events accepted by the indicated object.

def getEvents | ( |  | self | ) |

def ignore | ( |  | self,
|  |  | event,
|  |  | object
| ) |  |

    ignore(self, string, DirectObject)
    Make this object no longer respond to this event.
    It is safe to call even if it was not already accepting

def ignoreAll | ( |  | self,
|  |  | object
| ) |  |

    Make this object no longer respond to any events it was accepting
    Useful for cleanup

def isAccepting | ( |  | self,
|  |  | event,
|  |  | object
| ) |  |

    isAccepting(self, string, DirectOject)
    Is this object accepting this event?

def isEmpty | ( |  | self | ) |

def isIgnoring | ( |  | self,
|  |  | event,
|  |  | object
| ) |  |

    isIgnorning(self, string, DirectObject)
    Is this object ignoring this event?

def quiet | ( |  | self,
|  |  | message
| ) |  |

    When verbose mode is on, don't spam the output with messages
    marked as quiet.
    This is primarily a debugging tool.

    This is intended for debugging use only.
    This function is not defined if python is ran with -O (optimize).

    See Also: unquiet

def replaceMethod | ( |  | self,
|  |  | oldMethod,
|  |  | newFunction
| ) |  |

    This is only used by Finder.py - the module that lets
    you redefine functions with Control-c-Control-v

def send | ( |  | self,
|  |  | event,
|  |  | sentArgs = `[]`,
|  |  | taskChain = `None`
| ) |  |

    Send this event, optionally passing in arguments

    event is usually a string.
    sentArgs is a list of any data that you want passed along to the
        handlers listening to this event.

    If taskChain is not None, it is the name of the task chain
    which should receive the event.  If taskChain is None, the
    event is handled immediately.  Setting a non-None taskChain
    will defer the event (possibly till next frame or even later)
    and create a new, temporary task within the named taskChain,
    but this is the only way to send an event across threads.

def toggleVerbose | ( |  | self | ) |

def unquiet | ( |  | self,
|  |  | message
| ) |  |

    Remove a message from the list of messages that are not reported
    in verbose mode.
    This is primarily a debugging tool.

    This is intended for debugging use only.
    This function is not defined if python is ran with -O (optimize).

    See Also: quiet

def unwatch | ( |  | self,
|  |  | needle
| ) |  |

    return a matching event (needle) if found (in haystack).
    This is primarily a debugging tool.

    This is intended for debugging use only.
    This function is not defined if python is ran with -O (optimize).

    See Also: watch

def watch | ( |  | self,
|  |  | needle
| ) |  |

    return a matching event (needle) if found (in haystack).
    This is primarily a debugging tool.

    This is intended for debugging use only.
    This function is not defined if python is ran with -O (optimize).

    See Also: unwatch

def whoAccepts | ( |  | self,
|  |  | event
| ) |  |

    Return objects accepting the given event

## Member Data Documentation

lock

tuple notify = DirectNotifyGlobal.directNotify.newCategory("Messenger")`[static]`

quieting

All Classes Namespaces Functions Variables Enumerations Enumerator Properties