Returns the item which was the target of the event (if exists) or "ovrflow" for the overflow
970706
function(oThis, oEvent) {
		var jRef = get$Item(oThis, oEvent);
		if (jRef) {
			var sItemIdx = jRef.attr("itemidx");
			if (sItemIdx) {
				if (sItemIdx == "ovrflw") {
					return "ovrflw";
				} else {
					var iIdx = parseInt(sItemIdx);
					var oMenuItem = oThis.getItems()[iIdx];
					return oMenuItem;
				}
			}
		}
		return null;
	}
135729
def target_data(self):
        
        if self._td is not None:
            return self._td
        ptr = ffi.lib.LLVMPY_GetExecutionEngineTargetData(self)
        self._td = targets.TargetData(ptr)
        self._td._owned = True
        return self._td
407605
function(event) {
				var sourceNode = $.ui.fancytree.getNode(event.target);
				if(!sourceNode){ // Dynatree issue 211
					// might happen, if dragging a table *header*
					return "<div>ERROR?: helper requested but sourceNode not found</div>";
				}
				return sourceNode.tree.ext.dnd._onDragEvent("helper", sourceNode, null, event, null, null);
			}
904704
def sg_seek_streamer(self, index, force, value):
        """"""

        force = bool(force)
        err = self.sensor_graph.acknowledge_streamer(index, value, force)
        return [err]
347296
function getIEEvent() {
    var event = window.event;
    // add event.target
    event.target = event.target || event.srcElement;

    event.preventDefault = event.preventDefault || function() {
        event.returnValue = false;
    };

    event.stopPropagation = event.stopPropagation || function() {
        event.cancelBubble = true;
    };

	event.key = (event.which + 1 || event.keyCode + 1) - 1 || 0;

    return event;
}
454158
function getTargetFromShadowDom(event, defaultTarget) {
      var path, target = defaultTarget;

      // When target element is inside Shadow DOM we need to take first element from path
      // otherwise we'll get Shadow Root parent, not actual target element

      // Normalize target for WebComponents v0 implementation (in Chrome)
      path = event.path;
      if (path && path.length > 0) {
        target = path[0];
      }

      // Normalize target for WebComponents v1 implementation (standard)
      if (event.deepPath) {
        path = event.deepPath();
        if (path && path.length > 0) {
          target = path[0];
        }
      }

      return target;
    }
321361
def get_target(cls, scheme, path, fragment, username,
                   password, hostname, port, query, **kwargs):
        
        raise NotImplementedError("get_target must be overridden")
1178979
function getActualTarget() {
    var scrollX = window.scrollX,
        scrollY = window.scrollY;

    // IE is stupid and doesn't support scrollX/Y
    if(scrollX === undefined){
        scrollX = d.body.scrollLeft;
        scrollY = d.body.scrollTop;
    }

    return d.elementFromPoint(this.pageX - window.scrollX, this.pageY - window.scrollY);
}
896061
function( theEvent ) {
        var target,
            targetElement = theEvent.target,
            ui = this._ui;

        if ( !this._isOpen ) {
            return;
        }

        if ( targetElement !== ui.container[ 0 ] ) {
            target = $( targetElement );
            if ( !$.contains( ui.container[ 0 ], targetElement ) ) {
                $( this.document[ 0 ].activeElement ).one( "focus", $.proxy( function() {
                    this._safelyBlur( targetElement );
                }, this ) );
                ui.focusElement.focus();
                theEvent.preventDefault();
                theEvent.stopImmediatePropagation();
                return false;
            } else if ( ui.focusElement[ 0 ] === ui.container[ 0 ] ) {
                ui.focusElement = target;
            }
        }

        this._ignoreResizeEvents();
    }
193273
def eventFilter( self, object, event ):
        
        if ( event.type() != event.Resize ):
            return False
        
        size     = event.size()
        w        = size.width()
        h        = size.height()
        hpolicy  = Qt.ScrollBarAlwaysOff
        vpolicy  = Qt.ScrollBarAlwaysOff
        
        if ( self._minimumHeight != -1 and h < self._minimumHeight ):
            h      = self._minimumHeight
            vpolicy = Qt.ScrollBarAsNeeded
            
        if ( self._maximumHeight != -1 and self._maximumHeight < h ):
            h      = self._maximumHeight
            vpolicy = Qt.ScrollBarAsNeeded
        
        if ( self._minimumWidth != -1 and w < self._minimumWidth ):
            w      = self._minimumWidth
            hpolicy = Qt.ScrollBarAsNeeded
            
        if ( self._maximumWidth != -1 and self._maximumWidth < w ):
            w      = self._maximumWidth
            hpolicy = Qt.ScrollBarAsNeeded
        
        hruler = self.horizontalRuler()
        vruler = self.verticalRuler()
        
        hlen = hruler.minLength(Qt.Horizontal)
        vlen = hruler.minLength(Qt.Vertical)
        
        offset_w = 0
        offset_h = 0
        
#        if ( hlen > w ):
#            w        = hlen
#            hpolicy  = Qt.ScrollBarAlwaysOn
#            offset_h = 25
#        
#        if ( vlen > h ):
#            h        = vlen
#            vpolicy  = Qt.ScrollBarAlwaysOn
#            offset_w = 25
        
        self.setSceneRect(0, 0, w - offset_w, h - offset_h)
        object.setVerticalScrollBarPolicy(vpolicy)
        object.setHorizontalScrollBarPolicy(hpolicy)
        
        return False
339998
function(ev) {
            // Ignore right clicks
            if (ev.which !== Garnish.PRIMARY_CLICK) {
                return;
            }

            // Ignore if we already have a target
            if (this.$targetItem) {
                return;
            }

            // Ignore if they didn't actually click on the handle
            var $target = $(ev.target),
                $handle = this._getItemHandle(ev.currentTarget);

            if (!$target.is($handle) && !$target.closest($handle).length) {
                return;
            }

            // Make sure the target isn't a button (unless the button is the handle)
            if (ev.currentTarget !== ev.target && this.settings.ignoreHandleSelector) {
                if (
                    $target.is(this.settings.ignoreHandleSelector) ||
                    $target.closest(this.settings.ignoreHandleSelector).length
                ) {
                    return;
                }
            }

            ev.preventDefault();

            // Make sure that dragging is allowed right now
            if (!this.allowDragging()) {
                return;
            }

            // Capture the target
            this.$targetItem = $(ev.currentTarget);

            // Capture the current mouse position
            this.mousedownX = this.mouseX = ev.pageX;
            this.mousedownY = this.mouseY = ev.pageY;

            // Capture the difference between the mouse position and the target item's offset
            var offset = this.$targetItem.offset();
            this.mouseOffsetX = ev.pageX - offset.left;
            this.mouseOffsetY = ev.pageY - offset.top;

            // Listen for mousemove, mouseup
            this.addListener(Garnish.$doc, 'mousemove', '_handleMouseMove');
            this.addListener(Garnish.$doc, 'mouseup', '_handleMouseUp');
        }
1014886
function canOverflow(el, axis) {
    var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];

    return overflowValue === 'auto' || overflowValue === 'scroll';
  }
921494
function create(targetScrollY) {
  var scrollPositionStream = ScrollStream.create();
  var overTheLineStream = Stream.create();
  var pastScrollY = false;
  var firstRun = true;

  Stream.onValue(scrollPositionStream, function onScrollTrackPosition_(currentScrollY) {
    if ((firstRun || pastScrollY) && (currentScrollY < targetScrollY)) {
      pastScrollY = false;
      Stream.emit(overTheLineStream, ['before', targetScrollY]);
    } else if ((firstRun || !pastScrollY) && (currentScrollY >= targetScrollY)) {
      pastScrollY = true;
      Stream.emit(overTheLineStream, ['after', targetScrollY]);
    }

    firstRun = false;
  });

  return overTheLineStream;
}
312567
def dropEvent( self, event ):
        
        filt = self.dragDropFilter()
        if not filt:
            super(XTreeWidget, self).dropEvent(event)
            return
        
        filt(self, event)
1339238
function(oThis, oEvent){
		oEvent.stopPropagation();
		oEvent.preventDefault();

		var jTarget = jQuery(oEvent.target);
		var sTargetId = jTarget.attr("id");

		if (!sTargetId) {
			return;
		}

		//Handle event for the end of an expandable step
		var iIdx = sTargetId.lastIndexOf("-expandend");
		if (iIdx != -1) {
			var oStep = sap.ui.getCore().byId(sTargetId.substring(0, iIdx));
			if (oStep && oThis.indexOfStep(oStep) >= 0) {
				oStep.handleSelect(oEvent, true);
				return;
			}
		}

		//Handle select on delimiter
		if (sTargetId == oThis.getId() + "-Start") {
			if (jTarget.hasClass("sapUiRoadMapStartScroll")) {
				scrollToNextStep(oThis, "prev", true);
			} else {
				refreshFocus(oThis);
			}
		} else if (sTargetId == oThis.getId() + "-End") {
			if (jTarget.hasClass("sapUiRoadMapEndScroll")) {
				scrollToNextStep(oThis, "next", true);
			} else {
				refreshFocus(oThis);
			}
		}
	}
1223642
private Object getEvent(EventEnvelope eventEnvelope) {
        Object event = eventEnvelope.getEvent();
        if (event instanceof Data) {
            event = eventService.nodeEngine.toObject(event);
        }
        return event;
    }
1300335
def eventFilter(self, object, event):
        
        if object == self.parent() and event.type() == QtCore.QEvent.Resize:
            self.resize(event.size())
        elif event.type() == QtCore.QEvent.Close:
            self.setResult(0)
        return False