Panda3D

Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
Messenger Class Reference
Inheritance diagram for Messenger:

## Public Member Functions
| __init__ (self)
| __repr__ (self)
| accept (self, event, object, method, extraArgs=[], persistent=1)
| clear (self)
| detailedRepr (self)
| find (self, needle)
| findAll (self, needle, limit=None)
| future (self, event)
| getAllAccepting (self, object)
| getEvents (self)
| ignore (self, event, object)
| ignoreAll (self, object)
| isAccepting (self, event, object)
| isEmpty (self)
| isIgnoring (self, event, object)
| quiet (self, message)
| replaceMethod (self, oldMethod, newFunction)
| send (self, event, sentArgs=[], taskChain=None)
| toggleVerbose (self)
| unquiet (self, message)
| unwatch (self, needle)
| watch (self, needle)
| whoAccepts (self, event)

## Public Attributes
| lock = Lock()
dict | quieting

## Static Public Attributes
| detailed_repr = detailedRepr
| find_all = findAll
| get_all_accepting = getAllAccepting
| get_events = getEvents
| ignore_all = ignoreAll
| is_accepting = isAccepting
| is_empty = isEmpty
| is_ignoring = isIgnoring
| notify = DirectNotifyGlobal.directNotify.newCategory("Messenger")
| replace_method = replaceMethod
| toggle_verbose = toggleVerbose
| who_accepts = whoAccepts

## Protected Member Functions
| _getEvents (self)
| _getMessengerId (self, object)
| _getNumListeners (self, event)
| _getObject (self, id)
| _getObjects (self)
| _releaseObject (self, object)
| _storeObject (self, object)

## Protected Attributes
dict | _eventQueuesByTaskChain = {}
dict | _id2object = {}
int | _messengerIdGen = 0

## Constructor & Destructor Documentation

## ◆ __init__()

__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 allows 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

## ◆ __repr__()

__repr__ | ( |  | self | ) |

    Compact version of event, acceptor pairs

## ◆ _getEvents()

_getEvents | ( |  | self | ) |
| protected

## ◆ _getMessengerId()

_getMessengerId | ( |  | self,
|  |  | object )
| protected

## ◆ _getNumListeners()

_getNumListeners | ( |  | self,
|  |  | event )
| protected

## ◆ _getObject()

_getObject | ( |  | self,
|  |  | id )
| protected

## ◆ _getObjects()

_getObjects | ( |  | self | ) |
| protected

## ◆ _releaseObject()

_releaseObject | ( |  | self,
|  |  | object )
| protected

## ◆ _storeObject()

_storeObject | ( |  | self,
|  |  | object )
| protected

## ◆ accept()

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.

## ◆ clear()

clear | ( |  | self | ) |

    Start fresh with a clear dict

Reimplemented in NetMessenger.

## ◆ detailedRepr()

detailedRepr | ( |  | self | ) |

    Print out the table in a detailed readable format

## ◆ find()

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

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

## ◆ findAll()

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.

## ◆ future()

future | ( |  | self,
|  |  | event )

     Returns a future that is triggered by the given event name.  This
    will function only once.

## ◆ getAllAccepting()

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

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

## ◆ getEvents()

getEvents | ( |  | self | ) |

## ◆ ignore()

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

## ◆ ignoreAll()

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

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

## ◆ isAccepting()

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

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

## ◆ isEmpty()

isEmpty | ( |  | self | ) |

## ◆ isIgnoring()

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

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

## ◆ quiet()

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`

## ◆ replaceMethod()

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

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

## ◆ send()

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

    Send this event, optionally passing in arguments.

    Args:
        event (str): The name of the event.
        sentArgs (list): A list of arguments to be passed along to the
            handlers listening to this event.
        taskChain (str, optional): If not None, the name of the task chain
            which should receive the event.  If None, then 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.

Reimplemented in NetMessenger.

## ◆ toggleVerbose()

toggleVerbose | ( |  | self | ) |

## ◆ unquiet()

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`

## ◆ unwatch()

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`

## ◆ watch()

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`

## ◆ whoAccepts()

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

    Return objects accepting the given event

## Member Data Documentation

## ◆ _eventQueuesByTaskChain

dict _eventQueuesByTaskChain = {}
| protected

## ◆ _id2object

dict _id2object = {}
| protected

## ◆ _messengerIdGen

int _messengerIdGen = 0
| protected

## ◆ detailed_repr

detailed_repr = detailedRepr
| static

## ◆ find_all

find_all = findAll
| static

## ◆ get_all_accepting

get_all_accepting = getAllAccepting
| static

## ◆ get_events

get_events = getEvents
| static

## ◆ ignore_all

ignore_all = ignoreAll
| static

## ◆ is_accepting

is_accepting = isAccepting
| static

## ◆ is_empty

is_empty = isEmpty
| static

## ◆ is_ignoring

is_ignoring = isIgnoring
| static

## ◆ lock

lock = Lock()

## ◆ notify

notify = DirectNotifyGlobal.directNotify.newCategory("Messenger")
| static

## ◆ quieting

dict quieting

Initial value:
= {"NewFrame":1,
"avatarMoving":1,
"event-loop-done":1,
'collisionLoopFinished':1,
}

## ◆ replace_method

replace_method = replaceMethod
| static

## ◆ toggle_verbose

toggle_verbose = toggleVerbose
| static

## ◆ who_accepts

who_accepts = whoAccepts
| static