Class DOMEventFacade
                        
                        
                    
                    
                    
                
  
                    
                        Wraps a DOM event, properties requiring browser abstraction are
fixed here.  Provids a security layer when required.
                    
                    
                    
                        
                            Properties
                            
                                    
                                    
                                    
                                    
                                        
                                            The button that was pushed.
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The charCode for key events.  Same as keyCode
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            Node reference for the element that the listener was attached to.
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The keyCode for key events.  Uses charCode if keyCode is not available
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The X location of the event on the page (including scroll)
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The Y location of the event on the page (including scroll)
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            Node reference to the relatedTarget
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            Node reference for the targeted element
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            webkit key remapping required for Safari < 3.1
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            Number representing the direction and velocity of the movement of the mousewheel.
Negative is down, the higher the number, the faster.  Applies to the mousewheel event.
                                        
                                     
     
                                        
                                    
                                     
                                    
                                    
                                    
                                        
                                            The button that was pushed.  Same as button.
                                        
                                     
     
                                        
                                    
                                     
                             
                         
                     
                    
                        
                            Methods
                            
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            halt
                                           (
                                                
                                                        
                                                         immediate
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Stops the event propagation and prevents the default
event behavior.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        immediate
                                                        <boolean>
                                                        if true additional listeners
on the current target will not be executed
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            preventDefault
                                           (
                                                
                                                        
                                                         returnValue
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Prevents the event's default behavior
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        returnValue
                                                        <string>
                                                        sets the returnValue of the event to this value
(rather than the default false value).  This can be used to add a customized 
confirmation query to the beforeunload event).
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                         private 
                                        
                                        
                                        void
                                            resolve
                                           (
                                            )
                                        
                                        
                                        
                                            Returns a wrapped node.  Intended to be used on event targets,
so it will return the node's parent if the target is a text
node.
If accessing a property of the node throws an error, this is
probably the anonymous div wrapper Gecko adds inside text
nodes.  This likely will only occur when attempting to access
the relatedTarget.  In this case, we now return null because
the anonymous div is completely useless and we do not know
what the related target was because we can't even get to
the element's parent node.
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            stopImmediatePropagation
                                           (
                                            )
                                        
                                        
                                        
                                            Stops the propagation to the next bubble target and
prevents any additional listeners from being exectued
on the current target.
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            stopPropagation
                                           (
                                            )
                                        
                                        
                                        
                                            Stops the propagation to the next bubble target