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