eventhandler.js

javascript 很酷的类库

    },
    
	
    

    

    //>	@classAttr	isc.EventHandler.dragTrackerDefaults (object literal : _lookup_ : IA)
	//		Default properties for the drag tracker.
    // @visibility internal
	//<
    
	dragTrackerDefaults : { 							
			ID:"isc_dragTracker",
			width: 10,									
			height: 10,
            offsetX: -10,
            offsetY: -10,
            autoDraw: false,
            visibility:"hidden",
			overflow:"visible",
			cursor:"arrow"
	}
}
);// END isc.EventHandler.addClassProperties()

// Add each of the event types in isc.EventHandler.eventTypes directly to the event handler object
isc.EventHandler.addClassProperties(isc.EventHandler.eventTypes);

 
isc.EventHandler.addClassMethods({


handleSyntheticEvent : function (event) {

    var target = event.target;
    event._isSynthetic = true;
//    this.logWarn("synthetic event: " + isc.echoAll(event));

    if (target) {
        event.clientX += target.getPageLeft();
        event.clientY += target.getPageTop(); 
    
        
        if(isc.Browser.isIE) {
            /*
            this.logWarn("left margin: " +  target.getLeftMargin()
                         + " border: " + target.getLeftBorderSize()
                         + " padding: " + target.getLeftPadding());
            */
            event.clientX += target.getLeftMargin() + target.getLeftBorderSize()
                             + target.getLeftPadding() + 2;
            event.clientY += target.getTopMargin() + target.getRightBorderSize() 
                             + target.getTopPadding() + 2;
        }
        /*
        this.logWarn("synthetic event on: " + target.getID() 
                     + " ("+event.type+": "+event.clientX+", "+event.clientY+")");
        */

        switch (event.type) {
            case "mouseup": this.handleMouseUp(event); break;
            case "mousedown": this.handleMouseDown(event); break;
            case "mousemove": this.handleMouseMove(event); break;
        }
    }
},

//>	@classMethod	isc.EventHandler.handleEvent()  (A)
// Routine to handle generic events that are not handled specially 
//	 (currently everything but keyPress, mouseDown, mouseUp, mouseStillDown, mouseMove).
//
//		@group	eventHandling
//
//		@param	target		(object)	Canvas or DOM object that received the event
//		@param	eventType	(string) 	name of this event
//		@param	eventInfo	(any)		information passed with a custom event (see e.g. Slider)
//
//		@return			(boolean)	false == cancel further event processing
//									anything else == continue processing
//      @visibility eventhandler
//<

handleEvent : function (target, eventType, eventInfo) {
	
        var EH = isc.EH;
    
	// process the event globally
  	if (isc.Page.handleEvent(target, eventType, eventInfo) == false) return false;

	// if the target is enabled
	// 	bubble the event up the target's chain
	if (EH.targetIsEnabled(target) && EH.bubbleEvent(target, eventType, eventInfo)==false) {
		return false;
	}
	
	return true;
},


// Handler for the page-level load event.  Internal - developers use Page.setEvent() instead
handleLoad : function (DOMevent) {
    
    // ensure that SA_Page onload fires before Page's onload handlers.  The History module in
    // particular registers onload handlers that must fire before the Page onload, but because
    // IE's attachEvent() mechanism doesn't fire events in order of registration, we need to
    // kick SA_Page here.
    if (isc.SA_Page) isc.SA_Page._firePageLoadCallbacks();

    if (!isc.Browser.isMoz) {
        
        if (isc.EH._useEventListenerForUnload() && document && document.body) {
            document.body.addEventListener("unload", isc.EH.handleUnload, false);
        }

    	return (isc.Page.handleEvent(null, isc.EH.LOAD) != false);
    } else {
        try {
    	    return (isc.Page.handleEvent(null, isc.EH.LOAD) != false);
        } catch (e) {
            isc.Log._reportJSError(e);
            throw e;; // extra semi for Safari
        }
    }
},


// Handler for the page-level unload event.  Internal - developers use Page.setEvent() instead
handleUnload : function (DOMevent) {
	
        var EH = isc.EH;

    var result = (isc.Page.handleEvent(null, EH.UNLOAD) != false);
    
	return result;
},





// NOTE: naming: 
// - handleKey*Event: directly called by DOM
// - handleKey*: called on EH object

// called directly by DOM
_$f10:"f10",
_$Escape:"Escape",
_handleNativeKeyDown : function (DOMevent) {
	// Some browsers (like Mac IE) have problems dealing with events fired before the page finishes loading.
	//	Just skip key event processing if the page hasn't loaded yet.
    //!DONTCOMBINE
	if (!isc.Page.isLoaded()) return false;
 
    
        var EH = isc.EH;

    
    

    var lastEvent = EH.lastEvent;
    
    if (!DOMevent) DOMevent = EH.getWindow().event;
    
    // Get the details of the event (stored in EH.lastEvent)
    EH.getKeyEventProperties(DOMevent);
    
    
    var syntheticKeypressFired = false,
        returnVal = true;
    
    if (EH._keyDownKeyName == lastEvent.keyName) {
        returnVal = EH.handleKeyPress();
        syntheticKeypressFired = true;
        
        
    } else returnVal = EH.handleKeyDown(DOMevent);

    
    EH._keyDownKeyName = lastEvent.keyName;
            
    
    if (returnVal != false && 
        ((isc.Browser.isIE && !syntheticKeypressFired && 
            EH._nonCharacterKeyMap[lastEvent.keyName] != null) ||
         (isc.Browser.isMoz && lastEvent.keyName == this._$f10 && this.shiftKeyDown()))
       ) 
    {
        returnVal = EH.handleKeyPress(DOMevent);
    }    

    return returnVal;
},

// handleKeyDown() fires the keyDown handler on the event target.
// called in response to document.keyDown _handleNativeKeyDown().

_$Tab:"Tab",
handleKeyDown : function (nativeEvent, scEventProperties) {
    var EH = isc.EH,
        lastEvent = EH.lastEvent,
        returnVal;

    // If the event is handled natively, we will avoid doing any of our own processing and
    // return true to allow native processing
    
    var handledNatively = EH.eventHandledNatively(lastEvent.eventType, lastEvent.nativeKeyTarget);
    if (handledNatively) returnVal = EH._handledNativelyReturnVal;

    if (scEventProperties != null) isc.addProperties(lastEvent, scEventProperties);
    
    if (!handledNatively) {    
    
        var eventInfo = [lastEvent, lastEvent.target, lastEvent.keyName];
            
        var target = lastEvent.keyTarget;
        //EH.logWarn("nativeEvent: " + EH.echoDOM(nativeEvent) +
        //           ", nativeTarget: " + EH.echoLeaf(lastEvent.nativeTarget));
    
        if (target == null) target = this.getEventTargetCanvas(nativeEvent,
                                                               lastEvent.nativeKeyTarget);

        if (EH.targetIsEnabled(target))
            returnVal = (EH.bubbleEvent(target, EH.KEY_DOWN, eventInfo) != false);
    }

    
    if (returnVal != false && this.clickMaskUp() && lastEvent.keyName == this._$Tab) {
        var topHardMask,
            registry = this.clickMaskRegistry;
        for (var i = registry.length-1; i >=0; i--) {
            if (this.isHardMask(registry[i])) {
                topHardMask = registry[i];
                break;
            }
        }
        if (topHardMask) returnVal = false;
    }
    
    return returnVal;
},

// called by DOM
_handleNativeKeyUp : function (DOMevent) {
	// Some browsers (like Mac IE) have problems dealing with events fired before the page finishes loading.
	//	Just skip key event processing if the page hasn't loaded yet.
    //!DONTCOMBINE
	if (!isc.Page.isLoaded()) return false;
    
    var EH = isc.EH,
        lastEvent = EH.lastEvent;
    
    if (!DOMevent) DOMevent = EH.getWindow().event;        
    // get key event properties (stored in EH.lastEvent)
    EH.getKeyEventProperties(DOMevent);
        
    
    if (EH._keyDownKeyName == EH.lastEvent.keyName) {
        if (EH.handleKeyPress(DOMevent) == false) return false;
    }
    
    var returnVal = EH.handleKeyUp(DOMevent)
    
    return returnVal
},

// called on EH
handleKeyUp : function (nativeEvent, scEventProperties) {

    var EH = isc.EH,
        lastEvent = EH.lastEvent,
        eventInfo = [lastEvent,  lastEvent.target, lastEvent.keyName];    
        
    // If the event is handled natively, return true to allow native processing
    if (EH.eventHandledNatively(lastEvent.eventType, lastEvent.nativeKeyTarget)) {
        // Log.logWarn("keyup event handled natively - bailing");
        return EH._handledNativelyReturnVal;
    }
        

    var returnVal = true;

    if (scEventProperties != null) {
        isc.addProperties(lastEvent, scEventProperties);
    }
    
    var target = lastEvent.keyTarget;
    if (target == null) target = this.getEventTargetCanvas(nativeEvent,
                                                           lastEvent.nativeKeyTarget);

    if (EH.targetIsEnabled(target))
        returnVal = (EH.bubbleEvent(target, EH.KEY_UP, eventInfo) != false);

    
    // On Shift+f10 to show a SmartClient context menu, return false to cancel the keyUp event.
    if (!isc.Browser.isMac && lastEvent.keyName == EH._$f10 && EH.shiftKeyDown() && 	
        isc.Menu && isc.Menu._openMenus && isc.Menu._openMenus.length > 0) 
    {
        returnVal = false;
    }
        
    
    // Clear EH.lastEvent's key properties
    EH.clearKeyEventProperties();
    
    // Return true to allow processing to continue unless something explicitly returned false.
    return returnVal;
},

// called by DOM
_handleNativeKeyPress : function (DOMevent) {
	// Some browsers (like Mac IE) have problems dealing with events fired before the page
    // finishes loading.  Just skip key event processing if the page hasn't loaded yet.
    //!DONTCOMBINE
	if (!isc.Page.isLoaded()) return false;

    
        var EH = isc.EH;

    // We already got the keyEventProperties stored in EH.lastEvent from the keyDown handler
    // However call to getKeyEventProperties required as keyCodes returned in IE are different
    // on keyDown and keyPress.
    
	var lastEvent = EH.lastEvent,
        eventType = EH.KEY_PRESS;

    if (!DOMevent) DOMevent = EH.getWindow().event;
            
    EH.getKeyEventProperties(DOMevent);
        
    
    lastEvent.eventType = eventType;

    
    if (isc.Browser.isMoz && lastEvent.keyName == this._$f10 && this.shiftKeyDown()) return;
    
    
        
    var returnVal = EH.handleKeyPress(DOMevent);
    return returnVal;

},

// called on EH 
handleKeyPress : function (nativeEvent, scEventProperties) {
    // We already got the keyEventProperties stored in EH.lastEvent from the keyDown handler
    // However call to getKeyEventProperties required as keyCodes returned in IE are different
    // on keyDown and keyPress.
	var EH = isc.EH,
        lastEvent = EH.lastEvent,
        eventType = EH.KEY_PRESS;

    // if passed already-derived event properties, apply them to the EH.lastEvent.
    if (scEventProperties != null) {
        isc.addProperties(lastEvent, scEventProperties);
    } 
    var eventInfo = {keyName:lastEvent.keyName, characterValue:lastEvent.characterValue};
       
    // update the eventType since this may be a synthetically generated keyPress event (from
    // keyUp or repeated keyDown events).
    lastEvent.eventType = eventType;
    
    
    EH._keyDownKeyName = null;