OpenGLContext.events.mouseevents
index
/home/mcfletch/pylive/OpenGLContext/events/mouseevents.py

Events relating to the mouse

 
Modules
       
ctypes
OpenGLContext.events.event
OpenGLContext.events.eventmanager
OpenGL.GLU.glunurbs
OpenGL.GLU.glustruct
OpenGLContext.scenegraph.nodepath
OpenGL.platform
OpenGL.GLU.projection
OpenGL.GLU.quadrics
OpenGL.GLU.tess

 
Classes
       
Event(object)
MouseEvent
MouseButtonEvent
MouseMoveEvent
_MouseChangeEvent
MouseInEvent
MouseOutEvent
BubblingEventManager(EventManager)
MouseEventManager
MouseButtonEventManager
MouseMoveEventManager
_MouseChangeEventManager
MouseInEventManager
MouseOutEventManager

 
class MouseButtonEvent(MouseEvent)
    Mouse event representing a change of state for a mouse button
attributes:
    type -- "mousebutton"
    renderingPass -- pointer to the OpenGLContext.renderpass.RenderPass
        object associated with this event
    modifiers -- three-tuple of booleans: (shift, control, alt)
    button -- the "button ID" which changed state
        Valid Values:
            0 -- first mouse button, "left"
            1 -- second mouse button, "right"
            2 -- third mouse button, "middle"
            n -- nth mouse button, device-specific
    state -- Boolean 0 = up/released, 1 = down/pressed
    nameStack -- selection name stack, [(near, far, [names,...]),...]
 
 
Method resolution order:
MouseButtonEvent
MouseEvent
Event
object

Methods defined here:
getKey(self)
Get the event key used to lookup a handler for this event

Data and other attributes defined here:
button = -1
state = 0
type = 'mousebutton'

Methods inherited from MouseEvent:
getNameStack(self)
Get the name-stack as reported by the rendering pass.
getObjectPaths(self)
Get the object-path object (None if not set)
getPickPoint(self)
Get the 2D picking point in OpenGL coordinates
 
Note that OpenGL coordinates are counted from the bottom left
corner of the window, in contrast to most windowing libraries
which use the upper left corner as the origin.
project(self, worldCoordinate=None)
Get the screen coordinates for the event w/out
the pick-point requires that worldCoordinate and
rendering pass be available or that the
viewCoordinate field already be available.
setNameStack(self, stack)
Set the name-stack.  Called by the select render mode
setObjectPaths(self, paths)
Set the object-path sets
unproject(self, viewCoordinate=None)
Get the world coordinates for viewCoordinate for the event
 
viewCoordinate -- coordinate to project, if omitted, the
    first "hit" entry in the name-stack will be used.  Otherwise
    should be a three-item array/tuple.  The z component of
    this tuple is interpreted acording to type.  If it's an
    integer or long, it's consider a raw OpenGL depth-buffer
    value as returned in the name-stack, and is converted to
    a floating-point depth value.  If it's already a floating-
    point value, it's left as-is.

Data and other attributes inherited from MouseEvent:
atTarget = 0
currentNode = None
currentPath = ()
modelViewMatrix = None
nameStack = ()
objectPaths = None
pickPoint = ()
processMorePaths = 0
projectionMatrix = None
stopPropagation = 0
viewCoordinate = ()
viewport = None
worldCoordinate = ()

Methods inherited from Event:
__init__(self)
Initialize common event parameters
getModifiers(self)
Retrieve a tuple of the active modifier keys
 
Format is three Boolean values, (shift, control, alt)
visited(self, key, value=None)
Check for or register visitation of the given key
 
key -- an opaque hashable value, normally the node and
    field/event as a tuple.
value -- if provided, sets the current value, otherwise
    signals that the current value should be returned
 
return value: previous key value (possibly None)

Data descriptors inherited from Event:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Event:
context = None
modifiers = (0, 0, 0)
renderingPass = None

 
class MouseButtonEventManager(MouseEventManager)
    Manager for MouseButtonEvent instances
 
 
Method resolution order:
MouseButtonEventManager
MouseEventManager
BubblingEventManager
EventManager
object

Methods defined here:
registerCallback(self, button=0, state=0, modifiers=(0, 0, 0), function=None, node=None, capture=0)
Register a function to receive mouse-button events matching
the given specification  To deregister, pass None as the
function.
 
button -- integer name for the button in which you are interested
    Valid Values:
        0 -- first mouse button, "left"
        1 -- second mouse button, "right"
        2 -- third mouse button, "middle"
        n -- nth mouse button, device-specific
state -- integer state values
    Value Values:
        0/1 -- for all boolean buttons, 0 == up/released, 1 = down/pressed
    
modifiers -- (shift, control, alt) as a tuple of booleans.
function -- function taking a single argument (a KeypressEvent)
    or None to deregister the callback.
node -- if non-None, a node/object which limits scope of
    the binding.  Only the node, or children of the node
    can generate events.  Otherwise watches for "anonymous"
    messages, those which are not handled by anything else.
capture -- if true, function is called before the target's
    bindings, allowing for parents to override children's
    bindings.
    
returns the previous handler or None

Data and other attributes defined here:
type = 'mousebutton'

Methods inherited from BubblingEventManager:
ProcessEvent(self, event)
Modified version of ProcessEvent that dispatches to nodes
__init__(self)
Initialise the event manager

Data descriptors inherited from EventManager:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class MouseEvent(Event)
    Base class for all mouse-based events.
 
Provides a number of utility methods for
interacting with the mouse event and the
select render mode.
 
Attributes:
    type -- Event type string specifier
    viewCoordinate -- 3D vector in view-space of
        nearest-geometry intersection
    worldCoordinate -- 3D vector in model-space of
        nearest-geometry intersection
    pickPoint -- 2D view-space coordinate for mouse
    objectPaths -- NodePaths from scenegraph to each
        shape under the cursor, arranged in nearest-
        to-farthest order
    stopPropagation -- flag which, when set, stops
        the event from continuing along the capture/
        bubbling ProcessEvent path.  See:
            eventhandler.BubblingEventManager
    processMorePaths -- if true (false by default),
        then continue processing node-paths after the
        current node-path is complete.
    
(Low-level data attributes):
    nameStack -- low-level OpenGL name-stack with
        GL names and distances:
        [ (near,far,[name,...]),...]
    modelViewMatrix -- active model-view matrix for
        the context on this rendering pass
    projectionMatrix -- active projection matrix for
        the context on this rendering pass
    viewport -- viewport dimensions
 
 
Method resolution order:
MouseEvent
Event
object

Methods defined here:
getNameStack(self)
Get the name-stack as reported by the rendering pass.
getObjectPaths(self)
Get the object-path object (None if not set)
getPickPoint(self)
Get the 2D picking point in OpenGL coordinates
 
Note that OpenGL coordinates are counted from the bottom left
corner of the window, in contrast to most windowing libraries
which use the upper left corner as the origin.
project(self, worldCoordinate=None)
Get the screen coordinates for the event w/out
the pick-point requires that worldCoordinate and
rendering pass be available or that the
viewCoordinate field already be available.
setNameStack(self, stack)
Set the name-stack.  Called by the select render mode
setObjectPaths(self, paths)
Set the object-path sets
unproject(self, viewCoordinate=None)
Get the world coordinates for viewCoordinate for the event
 
viewCoordinate -- coordinate to project, if omitted, the
    first "hit" entry in the name-stack will be used.  Otherwise
    should be a three-item array/tuple.  The z component of
    this tuple is interpreted acording to type.  If it's an
    integer or long, it's consider a raw OpenGL depth-buffer
    value as returned in the name-stack, and is converted to
    a floating-point depth value.  If it's already a floating-
    point value, it's left as-is.

Data and other attributes defined here:
atTarget = 0
currentNode = None
currentPath = ()
modelViewMatrix = None
nameStack = ()
objectPaths = None
pickPoint = ()
processMorePaths = 0
projectionMatrix = None
stopPropagation = 0
type = ''
viewCoordinate = ()
viewport = None
worldCoordinate = ()

Methods inherited from Event:
__init__(self)
Initialize common event parameters
getKey(self)
Calculate the key for routing within the event manager.
 
Each subclass will define the appropriate data values for
inclusion in the key (note that the key must be a hashable
value).
getModifiers(self)
Retrieve a tuple of the active modifier keys
 
Format is three Boolean values, (shift, control, alt)
visited(self, key, value=None)
Check for or register visitation of the given key
 
key -- an opaque hashable value, normally the node and
    field/event as a tuple.
value -- if provided, sets the current value, otherwise
    signals that the current value should be returned
 
return value: previous key value (possibly None)

Data descriptors inherited from Event:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Event:
context = None
modifiers = (0, 0, 0)
renderingPass = None

 
class MouseEventManager(BubblingEventManager)
    Manager base-class for mouse-related events
 
 
Method resolution order:
MouseEventManager
BubblingEventManager
EventManager
object

Methods inherited from BubblingEventManager:
ProcessEvent(self, event)
Modified version of ProcessEvent that dispatches to nodes
__init__(self)
Initialise the event manager

Data and other attributes inherited from BubblingEventManager:
type = ''

Class methods inherited from EventManager:
registerCallback(cls, key, function=None, node=None, capture=0) from type
Register callback function for the given key (possibly node-specific)
 
key -- as returned by event.getKey()
function -- callable function taking at least an
    event object as it's first parameter, or None
node -- the node to be watched, None to register a
    context-level callback ( default )
capture -- if true, capture events before passing to
    children, rather than processing during the
    bubbling phase.  (default false)
 
Note: this method would normally be called by a sub-
    class with the calculated key for the sub-class.
 
return previous callback function or None

Data descriptors inherited from EventManager:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class MouseInEvent(_MouseChangeEvent)
    Mouse has just begun pointing to a particular path
 
The MouseInEvent indicates that the pointer has just
begun pointing to the geometry at the end of the
newPath attribute.
 
* only sent when the newPath is non-null (i.e. there
    is actual geometry under the pointer).
* sent after any corresponding MouseOutEvent for the
    lastPath has been sent
 
 
Method resolution order:
MouseInEvent
_MouseChangeEvent
MouseEvent
Event
object

Data and other attributes defined here:
type = 'mousein'

Methods inherited from _MouseChangeEvent:
__init__(self, **named)
Initialise the event with named attributes

Class methods inherited from _MouseChangeEvent:
fromMoveEvent(cls, event, lastPath, newPath) from type
Construct synthetic mouse event from a move event

Data and other attributes inherited from _MouseChangeEvent:
lastPath = ()
newPath = ()

Methods inherited from MouseEvent:
getNameStack(self)
Get the name-stack as reported by the rendering pass.
getObjectPaths(self)
Get the object-path object (None if not set)
getPickPoint(self)
Get the 2D picking point in OpenGL coordinates
 
Note that OpenGL coordinates are counted from the bottom left
corner of the window, in contrast to most windowing libraries
which use the upper left corner as the origin.
project(self, worldCoordinate=None)
Get the screen coordinates for the event w/out
the pick-point requires that worldCoordinate and
rendering pass be available or that the
viewCoordinate field already be available.
setNameStack(self, stack)
Set the name-stack.  Called by the select render mode
setObjectPaths(self, paths)
Set the object-path sets
unproject(self, viewCoordinate=None)
Get the world coordinates for viewCoordinate for the event
 
viewCoordinate -- coordinate to project, if omitted, the
    first "hit" entry in the name-stack will be used.  Otherwise
    should be a three-item array/tuple.  The z component of
    this tuple is interpreted acording to type.  If it's an
    integer or long, it's consider a raw OpenGL depth-buffer
    value as returned in the name-stack, and is converted to
    a floating-point depth value.  If it's already a floating-
    point value, it's left as-is.

Data and other attributes inherited from MouseEvent:
atTarget = 0
currentNode = None
currentPath = ()
modelViewMatrix = None
nameStack = ()
objectPaths = None
pickPoint = ()
processMorePaths = 0
projectionMatrix = None
stopPropagation = 0
viewCoordinate = ()
viewport = None
worldCoordinate = ()

Methods inherited from Event:
getKey(self)
Calculate the key for routing within the event manager.
 
Each subclass will define the appropriate data values for
inclusion in the key (note that the key must be a hashable
value).
getModifiers(self)
Retrieve a tuple of the active modifier keys
 
Format is three Boolean values, (shift, control, alt)
visited(self, key, value=None)
Check for or register visitation of the given key
 
key -- an opaque hashable value, normally the node and
    field/event as a tuple.
value -- if provided, sets the current value, otherwise
    signals that the current value should be returned
 
return value: previous key value (possibly None)

Data descriptors inherited from Event:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Event:
context = None
modifiers = (0, 0, 0)
renderingPass = None

 
class MouseInEventManager(_MouseChangeEventManager)
    
Method resolution order:
MouseInEventManager
_MouseChangeEventManager
MouseEventManager
BubblingEventManager
EventManager
object

Data and other attributes defined here:
type = 'mousein'

Class methods inherited from _MouseChangeEventManager:
registerCallback(cls, buttons=(), modifiers=(0, 0, 0), function=None, node=None, capture=0) from type
Register a function to receive keyboard events matching
the given specification  To deregister, pass None as the
function.
 
buttons -- tuple of active buttons (in ascending order)
    Valid Values:
        () -- move with no buttons
        (n,) -- drag with single button 'n' depressed
        (n,n+x) -- drag with two buttons depressed
modifiers -- (shift, control, alt) as a tuple of booleans.
function -- function taking a single argument (a KeypressEvent)
    or None to deregister the callback.
    
returns the previous handler or None

Methods inherited from BubblingEventManager:
ProcessEvent(self, event)
Modified version of ProcessEvent that dispatches to nodes
__init__(self)
Initialise the event manager

Data descriptors inherited from EventManager:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class MouseMoveEvent(MouseEvent)
    Event representing a change of position for the mouse.
 
Can represent either a "free move" or a "drag" with buttons
depressed.  See the buttons field for a list of the button IDs
active while moving
 
attributes:
    type -- "mousemove"
    renderingPass -- pointer to the OpenGLContext.renderpass.RenderPass
        object associated with this event
    modifiers -- three-tuple of booleans: (shift, control, alt)
    buttons -- tuple of active buttons (in ascending order)
        Valid Values:
            () -- move with no buttons
            (n,) -- drag with single button 'n' depressed
            (n,n+x) -- drag with two buttons depressed
    nameStack -- selection name stack, [(near, far, [names,...]),...]
 
 
Method resolution order:
MouseMoveEvent
MouseEvent
Event
object

Methods defined here:
getButtons(self)
Return the active buttons as a tuple of integers.
getKey(self)
Get the event key used to lookup a handler for this event

Data and other attributes defined here:
buttons = ()
dragStart = ()
type = 'mousemove'

Methods inherited from MouseEvent:
getNameStack(self)
Get the name-stack as reported by the rendering pass.
getObjectPaths(self)
Get the object-path object (None if not set)
getPickPoint(self)
Get the 2D picking point in OpenGL coordinates
 
Note that OpenGL coordinates are counted from the bottom left
corner of the window, in contrast to most windowing libraries
which use the upper left corner as the origin.
project(self, worldCoordinate=None)
Get the screen coordinates for the event w/out
the pick-point requires that worldCoordinate and
rendering pass be available or that the
viewCoordinate field already be available.
setNameStack(self, stack)
Set the name-stack.  Called by the select render mode
setObjectPaths(self, paths)
Set the object-path sets
unproject(self, viewCoordinate=None)
Get the world coordinates for viewCoordinate for the event
 
viewCoordinate -- coordinate to project, if omitted, the
    first "hit" entry in the name-stack will be used.  Otherwise
    should be a three-item array/tuple.  The z component of
    this tuple is interpreted acording to type.  If it's an
    integer or long, it's consider a raw OpenGL depth-buffer
    value as returned in the name-stack, and is converted to
    a floating-point depth value.  If it's already a floating-
    point value, it's left as-is.

Data and other attributes inherited from MouseEvent:
atTarget = 0
currentNode = None
currentPath = ()
modelViewMatrix = None
nameStack = ()
objectPaths = None
pickPoint = ()
processMorePaths = 0
projectionMatrix = None
stopPropagation = 0
viewCoordinate = ()
viewport = None
worldCoordinate = ()

Methods inherited from Event:
__init__(self)
Initialize common event parameters
getModifiers(self)
Retrieve a tuple of the active modifier keys
 
Format is three Boolean values, (shift, control, alt)
visited(self, key, value=None)
Check for or register visitation of the given key
 
key -- an opaque hashable value, normally the node and
    field/event as a tuple.
value -- if provided, sets the current value, otherwise
    signals that the current value should be returned
 
return value: previous key value (possibly None)

Data descriptors inherited from Event:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Event:
context = None
modifiers = (0, 0, 0)
renderingPass = None

 
class MouseMoveEventManager(MouseEventManager)
    Manager for MouseMoveEvent instances
 
lastPath -- tracks the last-pointed-to path, used to
    generate mousein and mouseout event types.
 
 
Method resolution order:
MouseMoveEventManager
MouseEventManager
BubblingEventManager
EventManager
object

Methods defined here:
ProcessEvent(self, event)
Dispatch an incoming event
 
This method tracks previously-pointed paths and generates
synthetic "mousein" and "mouseout" events
registerCallback(self, buttons=(), modifiers=(0, 0, 0), function=None, node=None, capture=0)
Register a function to receive keyboard events matching
the given specification  To deregister, pass None as the
function.
 
buttons -- tuple of active buttons (in ascending order)
    Valid Values:
        () -- move with no buttons
        (n,) -- drag with single button 'n' depressed
        (n,n+x) -- drag with two buttons depressed
modifiers -- (shift, control, alt) as a tuple of booleans.
function -- function taking a single argument (a KeypressEvent)
    or None to deregister the callback.
    
returns the previous handler or None

Data and other attributes defined here:
lastPath = ()
type = 'mousemove'

Methods inherited from BubblingEventManager:
__init__(self)
Initialise the event manager

Data descriptors inherited from EventManager:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class MouseOutEvent(_MouseChangeEvent)
    Mouse has just stopped pointing to a particular path
 
The MouseOutEvent indicates that the pointer has just
stopped pointing to the geometry at the end of the
lastPath attribute.
 
* only sent when the lastPath is non-null (i.e. there
    was actual geometry under the pointer).
* sent before any corresponding MouseInEvent for the
    newPath has been sent
 
 
Method resolution order:
MouseOutEvent
_MouseChangeEvent
MouseEvent
Event
object

Data and other attributes defined here:
type = 'mouseout'

Methods inherited from _MouseChangeEvent:
__init__(self, **named)
Initialise the event with named attributes

Class methods inherited from _MouseChangeEvent:
fromMoveEvent(cls, event, lastPath, newPath) from type
Construct synthetic mouse event from a move event

Data and other attributes inherited from _MouseChangeEvent:
lastPath = ()
newPath = ()

Methods inherited from MouseEvent:
getNameStack(self)
Get the name-stack as reported by the rendering pass.
getObjectPaths(self)
Get the object-path object (None if not set)
getPickPoint(self)
Get the 2D picking point in OpenGL coordinates
 
Note that OpenGL coordinates are counted from the bottom left
corner of the window, in contrast to most windowing libraries
which use the upper left corner as the origin.
project(self, worldCoordinate=None)
Get the screen coordinates for the event w/out
the pick-point requires that worldCoordinate and
rendering pass be available or that the
viewCoordinate field already be available.
setNameStack(self, stack)
Set the name-stack.  Called by the select render mode
setObjectPaths(self, paths)
Set the object-path sets
unproject(self, viewCoordinate=None)
Get the world coordinates for viewCoordinate for the event
 
viewCoordinate -- coordinate to project, if omitted, the
    first "hit" entry in the name-stack will be used.  Otherwise
    should be a three-item array/tuple.  The z component of
    this tuple is interpreted acording to type.  If it's an
    integer or long, it's consider a raw OpenGL depth-buffer
    value as returned in the name-stack, and is converted to
    a floating-point depth value.  If it's already a floating-
    point value, it's left as-is.

Data and other attributes inherited from MouseEvent:
atTarget = 0
currentNode = None
currentPath = ()
modelViewMatrix = None
nameStack = ()
objectPaths = None
pickPoint = ()
processMorePaths = 0
projectionMatrix = None
stopPropagation = 0
viewCoordinate = ()
viewport = None
worldCoordinate = ()

Methods inherited from Event:
getKey(self)
Calculate the key for routing within the event manager.
 
Each subclass will define the appropriate data values for
inclusion in the key (note that the key must be a hashable
value).
getModifiers(self)
Retrieve a tuple of the active modifier keys
 
Format is three Boolean values, (shift, control, alt)
visited(self, key, value=None)
Check for or register visitation of the given key
 
key -- an opaque hashable value, normally the node and
    field/event as a tuple.
value -- if provided, sets the current value, otherwise
    signals that the current value should be returned
 
return value: previous key value (possibly None)

Data descriptors inherited from Event:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Event:
context = None
modifiers = (0, 0, 0)
renderingPass = None

 
class MouseOutEventManager(_MouseChangeEventManager)
    
Method resolution order:
MouseOutEventManager
_MouseChangeEventManager
MouseEventManager
BubblingEventManager
EventManager
object

Data and other attributes defined here:
type = 'mouseout'

Class methods inherited from _MouseChangeEventManager:
registerCallback(cls, buttons=(), modifiers=(0, 0, 0), function=None, node=None, capture=0) from type
Register a function to receive keyboard events matching
the given specification  To deregister, pass None as the
function.
 
buttons -- tuple of active buttons (in ascending order)
    Valid Values:
        () -- move with no buttons
        (n,) -- drag with single button 'n' depressed
        (n,n+x) -- drag with two buttons depressed
modifiers -- (shift, control, alt) as a tuple of booleans.
function -- function taking a single argument (a KeypressEvent)
    or None to deregister the callback.
    
returns the previous handler or None

Methods inherited from BubblingEventManager:
ProcessEvent(self, event)
Modified version of ProcessEvent that dispatches to nodes
__init__(self)
Initialise the event manager

Data descriptors inherited from EventManager:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class _MouseChangeEvent(MouseEvent)
    Base class for mouse in/out events
 
The mouse in/out event types are "synthetic",
that is, they are generated by other events
when certain conditions are true.  The change
events allow for easily constructing common
interface elements such as mouse-overs.
 
Attributes:
    lastPath -- previous value for target path,
        in essence, the state from which we have
        come
    newPath -- new value for target path,
        in essence, the new state to which we have
        just changed
 
The change event also includes all attributes
of the MouseMoveEvent which triggered the change,
see the MouseMoveEvent class for details.
 
Change events are sent anonymously and from
the set of nodes which have _changed_ in the path,
rather than all nodes in the new/old path.
 
 
Method resolution order:
_MouseChangeEvent
MouseEvent
Event
object

Methods defined here:
__init__(self, **named)
Initialise the event with named attributes

Class methods defined here:
fromMoveEvent(cls, event, lastPath, newPath) from type
Construct synthetic mouse event from a move event

Data and other attributes defined here:
lastPath = ()
newPath = ()

Methods inherited from MouseEvent:
getNameStack(self)
Get the name-stack as reported by the rendering pass.
getObjectPaths(self)
Get the object-path object (None if not set)
getPickPoint(self)
Get the 2D picking point in OpenGL coordinates
 
Note that OpenGL coordinates are counted from the bottom left
corner of the window, in contrast to most windowing libraries
which use the upper left corner as the origin.
project(self, worldCoordinate=None)
Get the screen coordinates for the event w/out
the pick-point requires that worldCoordinate and
rendering pass be available or that the
viewCoordinate field already be available.
setNameStack(self, stack)
Set the name-stack.  Called by the select render mode
setObjectPaths(self, paths)
Set the object-path sets
unproject(self, viewCoordinate=None)
Get the world coordinates for viewCoordinate for the event
 
viewCoordinate -- coordinate to project, if omitted, the
    first "hit" entry in the name-stack will be used.  Otherwise
    should be a three-item array/tuple.  The z component of
    this tuple is interpreted acording to type.  If it's an
    integer or long, it's consider a raw OpenGL depth-buffer
    value as returned in the name-stack, and is converted to
    a floating-point depth value.  If it's already a floating-
    point value, it's left as-is.

Data and other attributes inherited from MouseEvent:
atTarget = 0
currentNode = None
currentPath = ()
modelViewMatrix = None
nameStack = ()
objectPaths = None
pickPoint = ()
processMorePaths = 0
projectionMatrix = None
stopPropagation = 0
type = ''
viewCoordinate = ()
viewport = None
worldCoordinate = ()

Methods inherited from Event:
getKey(self)
Calculate the key for routing within the event manager.
 
Each subclass will define the appropriate data values for
inclusion in the key (note that the key must be a hashable
value).
getModifiers(self)
Retrieve a tuple of the active modifier keys
 
Format is three Boolean values, (shift, control, alt)
visited(self, key, value=None)
Check for or register visitation of the given key
 
key -- an opaque hashable value, normally the node and
    field/event as a tuple.
value -- if provided, sets the current value, otherwise
    signals that the current value should be returned
 
return value: previous key value (possibly None)

Data descriptors inherited from Event:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Event:
context = None
modifiers = (0, 0, 0)
renderingPass = None

 
class _MouseChangeEventManager(MouseEventManager)
    Manager for _MouseChangeEvent instances
 
 
Method resolution order:
_MouseChangeEventManager
MouseEventManager
BubblingEventManager
EventManager
object

Class methods defined here:
registerCallback(cls, buttons=(), modifiers=(0, 0, 0), function=None, node=None, capture=0) from type
Register a function to receive keyboard events matching
the given specification  To deregister, pass None as the
function.
 
buttons -- tuple of active buttons (in ascending order)
    Valid Values:
        () -- move with no buttons
        (n,) -- drag with single button 'n' depressed
        (n,n+x) -- drag with two buttons depressed
modifiers -- (shift, control, alt) as a tuple of booleans.
function -- function taking a single argument (a KeypressEvent)
    or None to deregister the callback.
    
returns the previous handler or None

Methods inherited from BubblingEventManager:
ProcessEvent(self, event)
Modified version of ProcessEvent that dispatches to nodes
__init__(self)
Initialise the event manager

Data and other attributes inherited from BubblingEventManager:
type = ''

Data descriptors inherited from EventManager:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
glCheckError(...)
Base GL Error checker compatible with new ctypes errcheck protocol
 
This function will raise a GLError with just the calling information
available at the C-calling level, i.e. the error code, cArguments,
baseOperation and result.  Higher-level code is responsible for any 
extra annotations.
 
Note:
        glCheckError relies on glBegin/glEnd interactions to 
        prevent glGetError being called during a glBegin/glEnd 
        sequence.  If you are calling glBegin/glEnd in C you 
        should call onBegin and onEnd appropriately.

 
Data
        DEBUG = 10
GLU_AUTO_LOAD_MATRIX = GLU_AUTO_LOAD_MATRIX
GLU_BEGIN = GLU_BEGIN
GLU_CCW = GLU_CCW
GLU_CULLING = GLU_CULLING
GLU_CW = GLU_CW
GLU_DISPLAY_MODE = GLU_DISPLAY_MODE
GLU_DOMAIN_DISTANCE = GLU_DOMAIN_DISTANCE
GLU_EDGE_FLAG = GLU_EDGE_FLAG
GLU_END = GLU_END
GLU_ERROR = GLU_ERROR
GLU_EXTENSIONS = GLU_EXTENSIONS
GLU_EXTERIOR = GLU_EXTERIOR
GLU_FALSE = GLU_FALSE
GLU_FILL = GLU_FILL
GLU_FLAT = GLU_FLAT
GLU_INCOMPATIBLE_GL_VERSION = GLU_INCOMPATIBLE_GL_VERSION
GLU_INSIDE = GLU_INSIDE
GLU_INTERIOR = GLU_INTERIOR
GLU_INVALID_ENUM = GLU_INVALID_ENUM
GLU_INVALID_OPERATION = GLU_INVALID_OPERATION
GLU_INVALID_VALUE = GLU_INVALID_VALUE
GLU_LINE = GLU_LINE
GLU_MAP1_TRIM_2 = GLU_MAP1_TRIM_2
GLU_MAP1_TRIM_3 = GLU_MAP1_TRIM_3
GLU_NONE = GLU_NONE
GLU_NURBS_BEGIN = GLU_NURBS_BEGIN
GLU_NURBS_BEGIN_DATA = GLU_NURBS_BEGIN_DATA
GLU_NURBS_BEGIN_DATA_EXT = GLU_NURBS_BEGIN_DATA_EXT
GLU_NURBS_BEGIN_EXT = GLU_NURBS_BEGIN_EXT
GLU_NURBS_COLOR = GLU_NURBS_COLOR
GLU_NURBS_COLOR_DATA = GLU_NURBS_COLOR_DATA
GLU_NURBS_COLOR_DATA_EXT = GLU_NURBS_COLOR_DATA_EXT
GLU_NURBS_COLOR_EXT = GLU_NURBS_COLOR_EXT
GLU_NURBS_END = GLU_NURBS_END
GLU_NURBS_END_DATA = GLU_NURBS_END_DATA
GLU_NURBS_END_DATA_EXT = GLU_NURBS_END_DATA_EXT
GLU_NURBS_END_EXT = GLU_NURBS_END_EXT
GLU_NURBS_ERROR = GLU_NURBS_ERROR
GLU_NURBS_ERROR1 = GLU_NURBS_ERROR1
GLU_NURBS_ERROR10 = GLU_NURBS_ERROR10
GLU_NURBS_ERROR11 = GLU_NURBS_ERROR11
GLU_NURBS_ERROR12 = GLU_NURBS_ERROR12
GLU_NURBS_ERROR13 = GLU_NURBS_ERROR13
GLU_NURBS_ERROR14 = GLU_NURBS_ERROR14
GLU_NURBS_ERROR15 = GLU_NURBS_ERROR15
GLU_NURBS_ERROR16 = GLU_NURBS_ERROR16
GLU_NURBS_ERROR17 = GLU_NURBS_ERROR17
GLU_NURBS_ERROR18 = GLU_NURBS_ERROR18
GLU_NURBS_ERROR19 = GLU_NURBS_ERROR19
GLU_NURBS_ERROR2 = GLU_NURBS_ERROR2
GLU_NURBS_ERROR20 = GLU_NURBS_ERROR20
GLU_NURBS_ERROR21 = GLU_NURBS_ERROR21
GLU_NURBS_ERROR22 = GLU_NURBS_ERROR22
GLU_NURBS_ERROR23 = GLU_NURBS_ERROR23
GLU_NURBS_ERROR24 = GLU_NURBS_ERROR24
GLU_NURBS_ERROR25 = GLU_NURBS_ERROR25
GLU_NURBS_ERROR26 = GLU_NURBS_ERROR26
GLU_NURBS_ERROR27 = GLU_NURBS_ERROR27
GLU_NURBS_ERROR28 = GLU_NURBS_ERROR28
GLU_NURBS_ERROR29 = GLU_NURBS_ERROR29
GLU_NURBS_ERROR3 = GLU_NURBS_ERROR3
GLU_NURBS_ERROR30 = GLU_NURBS_ERROR30
GLU_NURBS_ERROR31 = GLU_NURBS_ERROR31
GLU_NURBS_ERROR32 = GLU_NURBS_ERROR32
GLU_NURBS_ERROR33 = GLU_NURBS_ERROR33
GLU_NURBS_ERROR34 = GLU_NURBS_ERROR34
GLU_NURBS_ERROR35 = GLU_NURBS_ERROR35
GLU_NURBS_ERROR36 = GLU_NURBS_ERROR36
GLU_NURBS_ERROR37 = GLU_NURBS_ERROR37
GLU_NURBS_ERROR4 = GLU_NURBS_ERROR4
GLU_NURBS_ERROR5 = GLU_NURBS_ERROR5
GLU_NURBS_ERROR6 = GLU_NURBS_ERROR6
GLU_NURBS_ERROR7 = GLU_NURBS_ERROR7
GLU_NURBS_ERROR8 = GLU_NURBS_ERROR8
GLU_NURBS_ERROR9 = GLU_NURBS_ERROR9
GLU_NURBS_MODE = GLU_NURBS_MODE
GLU_NURBS_MODE_EXT = GLU_NURBS_MODE_EXT
GLU_NURBS_NORMAL = GLU_NURBS_NORMAL
GLU_NURBS_NORMAL_DATA = GLU_NURBS_NORMAL_DATA
GLU_NURBS_NORMAL_DATA_EXT = GLU_NURBS_NORMAL_DATA_EXT
GLU_NURBS_NORMAL_EXT = GLU_NURBS_NORMAL_EXT
GLU_NURBS_RENDERER = GLU_NURBS_RENDERER
GLU_NURBS_RENDERER_EXT = GLU_NURBS_RENDERER_EXT
GLU_NURBS_TESSELLATOR = GLU_NURBS_TESSELLATOR
GLU_NURBS_TESSELLATOR_EXT = GLU_NURBS_TESSELLATOR_EXT
GLU_NURBS_TEXTURE_COORD = GLU_NURBS_TEXTURE_COORD
GLU_NURBS_TEXTURE_COORD_DATA = GLU_NURBS_TEXTURE_COORD_DATA
GLU_NURBS_TEX_COORD_DATA_EXT = GLU_NURBS_TEX_COORD_DATA_EXT
GLU_NURBS_TEX_COORD_EXT = GLU_NURBS_TEX_COORD_EXT
GLU_NURBS_VERTEX = GLU_NURBS_VERTEX
GLU_NURBS_VERTEX_DATA = GLU_NURBS_VERTEX_DATA
GLU_NURBS_VERTEX_DATA_EXT = GLU_NURBS_VERTEX_DATA_EXT
GLU_NURBS_VERTEX_EXT = GLU_NURBS_VERTEX_EXT
GLU_OBJECT_PARAMETRIC_ERROR = GLU_OBJECT_PARAMETRIC_ERROR
GLU_OBJECT_PARAMETRIC_ERROR_EXT = GLU_OBJECT_PARAMETRIC_ERROR_EXT
GLU_OBJECT_PATH_LENGTH = GLU_OBJECT_PATH_LENGTH
GLU_OBJECT_PATH_LENGTH_EXT = GLU_OBJECT_PATH_LENGTH_EXT
GLU_OUTLINE_PATCH = GLU_OUTLINE_PATCH
GLU_OUTLINE_POLYGON = GLU_OUTLINE_POLYGON
GLU_OUTSIDE = GLU_OUTSIDE
GLU_OUT_OF_MEMORY = GLU_OUT_OF_MEMORY
GLU_PARAMETRIC_ERROR = GLU_PARAMETRIC_ERROR
GLU_PARAMETRIC_TOLERANCE = GLU_PARAMETRIC_TOLERANCE
GLU_PATH_LENGTH = GLU_PATH_LENGTH
GLU_POINT = GLU_POINT
GLU_SAMPLING_METHOD = GLU_SAMPLING_METHOD
GLU_SAMPLING_TOLERANCE = GLU_SAMPLING_TOLERANCE
GLU_SILHOUETTE = GLU_SILHOUETTE
GLU_SMOOTH = GLU_SMOOTH
GLU_TESS_BEGIN = GLU_TESS_BEGIN
GLU_TESS_BEGIN_DATA = GLU_TESS_BEGIN_DATA
GLU_TESS_BOUNDARY_ONLY = GLU_TESS_BOUNDARY_ONLY
GLU_TESS_COMBINE = GLU_TESS_COMBINE
GLU_TESS_COMBINE_DATA = GLU_TESS_COMBINE_DATA
GLU_TESS_COORD_TOO_LARGE = GLU_TESS_COORD_TOO_LARGE
GLU_TESS_EDGE_FLAG = GLU_TESS_EDGE_FLAG
GLU_TESS_EDGE_FLAG_DATA = GLU_TESS_EDGE_FLAG_DATA
GLU_TESS_END = GLU_TESS_END
GLU_TESS_END_DATA = GLU_TESS_END_DATA
GLU_TESS_ERROR = GLU_TESS_ERROR
GLU_TESS_ERROR1 = GLU_TESS_ERROR1
GLU_TESS_ERROR2 = GLU_TESS_ERROR2
GLU_TESS_ERROR3 = GLU_TESS_ERROR3
GLU_TESS_ERROR4 = GLU_TESS_ERROR4
GLU_TESS_ERROR5 = GLU_TESS_ERROR5
GLU_TESS_ERROR6 = GLU_TESS_ERROR6
GLU_TESS_ERROR7 = GLU_TESS_ERROR7
GLU_TESS_ERROR8 = GLU_TESS_ERROR8
GLU_TESS_ERROR_DATA = GLU_TESS_ERROR_DATA
GLU_TESS_MAX_COORD = GLU_TESS_MAX_COORD
GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_MISSING_BEGIN_CONTOUR
GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_MISSING_BEGIN_POLYGON
GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_MISSING_END_CONTOUR
GLU_TESS_MISSING_END_POLYGON = GLU_TESS_MISSING_END_POLYGON
GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_NEED_COMBINE_CALLBACK
GLU_TESS_TOLERANCE = GLU_TESS_TOLERANCE
GLU_TESS_VERTEX = GLU_TESS_VERTEX
GLU_TESS_VERTEX_DATA = GLU_TESS_VERTEX_DATA
GLU_TESS_WINDING_ABS_GEQ_TWO = GLU_TESS_WINDING_ABS_GEQ_TWO
GLU_TESS_WINDING_NEGATIVE = GLU_TESS_WINDING_NEGATIVE
GLU_TESS_WINDING_NONZERO = GLU_TESS_WINDING_NONZERO
GLU_TESS_WINDING_ODD = GLU_TESS_WINDING_ODD
GLU_TESS_WINDING_POSITIVE = GLU_TESS_WINDING_POSITIVE
GLU_TESS_WINDING_RULE = GLU_TESS_WINDING_RULE
GLU_TRUE = GLU_TRUE
GLU_UNKNOWN = GLU_UNKNOWN
GLU_U_STEP = GLU_U_STEP
GLU_VERSION = GLU_VERSION
GLU_VERSION_1_1 = GLU_VERSION_1_1
GLU_VERSION_1_2 = GLU_VERSION_1_2
GLU_VERSION_1_3 = GLU_VERSION_1_3
GLU_VERTEX = GLU_VERTEX
GLU_V_STEP = GLU_V_STEP
GLvoid = None
__file__ = '/home/mcfletch/pylive/OpenGLContext/events/mouseevents.pyc'
__name__ = 'OpenGLContext.events.mouseevents'
__package__ = 'OpenGLContext.events'
event_log = <logging.Logger instance at 0x360b050>
gluBeginCurve = <CFunctionType object at 0x2590ae0>
gluBeginPolygon = <CFunctionType object at 0x2590bb0>
gluBeginSurface = <CFunctionType object at 0x2590c80>
gluBeginTrim = <CFunctionType object at 0x2590d50>
gluBuild1DMipmapLevels = <CFunctionType object at 0x2590e20>
gluBuild1DMipmaps = <CFunctionType object at 0x2590ef0>
gluBuild2DMipmapLevels = <CFunctionType object at 0x28ec050>
gluBuild2DMipmaps = <CFunctionType object at 0x28ec120>
gluBuild3DMipmapLevels = <CFunctionType object at 0x28ec1f0>
gluBuild3DMipmaps = <CFunctionType object at 0x28ec2c0>
gluCheckExtension = <OpenGL.wrapper.gluCheckExtension object at 0x28fa368>
gluCylinder = <CFunctionType object at 0x28ec460>
gluDeleteNurbsRenderer = <CFunctionType object at 0x28ec530>
gluDeleteQuadric = <CFunctionType object at 0x28ec600>
gluDeleteTess = <CFunctionType object at 0x28ec6d0>
gluDisk = <CFunctionType object at 0x28ec7a0>
gluEndCurve = <CFunctionType object at 0x28ec870>
gluEndPolygon = <CFunctionType object at 0x28ec940>
gluEndSurface = <CFunctionType object at 0x28eca10>
gluEndTrim = <CFunctionType object at 0x28ecae0>
gluErrorString = <CFunctionType object at 0x28ecbb0>
gluGetNurbsProperty = <OpenGL.wrapper.gluGetNurbsProperty object at 0x28fa5f0>
gluGetString = <CFunctionType object at 0x28ecd50>
gluGetTessProperty = OpenGL.lazywrapper.lazy( 'gluGetTessProperty' )
gluLoadSamplingMatrices = <OpenGL.wrapper.gluLoadSamplingMatrices object at 0x28faa70>
gluLookAt = <CFunctionType object at 0x28ef050>
gluNewNurbsRenderer = OpenGL.lazywrapper.lazy( 'gluNewNurbsRenderer' )
gluNewQuadric = <CFunctionType object at 0x28f4c80>
gluNewTess = OpenGL.lazywrapper.lazy( 'gluNewTess' )
gluNextContour = <CFunctionType object at 0x28ef390>
gluNurbsCallbackData = OpenGL.lazywrapper.lazy( 'gluNurbsCallbackData' )
gluNurbsCallbackDataEXT = OpenGL.lazywrapper.lazy( 'gluNurbsCallbackDataEXT' )
gluNurbsCurve = OpenGL.lazywrapper.lazy( 'gluNurbsCurve' )
gluNurbsProperty = <CFunctionType object at 0x28ef7a0>
gluNurbsSurface = OpenGL.lazywrapper.lazy( 'gluNurbsSurface' )
gluOrtho2D = <CFunctionType object at 0x28ef940>
gluPartialDisk = <CFunctionType object at 0x28efa10>
gluPerspective = <CFunctionType object at 0x28efae0>
gluPickMatrix = <OpenGL.wrapper.gluPickMatrix object at 0x28fb440>
gluProject = OpenGL.lazywrapper.lazy( 'gluProject' )
gluPwlCurve = OpenGL.lazywrapper.lazy( 'gluPwlCurve' )
gluQuadricDrawStyle = <CFunctionType object at 0x28efef0>
gluQuadricNormals = <CFunctionType object at 0x28f4050>
gluQuadricOrientation = <CFunctionType object at 0x28f4120>
gluQuadricTexture = <CFunctionType object at 0x28f41f0>
gluScaleImage = <CFunctionType object at 0x28f42c0>
gluSphere = <CFunctionType object at 0x28f4390>
gluTessBeginContour = <CFunctionType object at 0x28f4460>
gluTessEndContour = <CFunctionType object at 0x28f46d0>
gluTessEndPolygon = <CFunctionType object at 0x28f47a0>
gluTessNormal = <CFunctionType object at 0x28f4870>
gluTessProperty = <CFunctionType object at 0x28f4940>
gluUnProject = OpenGL.lazywrapper.lazy( 'gluUnProject' )
gluUnProject4 = OpenGL.lazywrapper.lazy( 'gluUnProject4' )